[android] move GENSHIN_SPOOF flag to genshinSpoof flavor

[macos] dynarmic: Implement VectorMin/Max{S,U}64 emitters (Apple Silicon fix)

Implements the missing A64 backend emitters for VectorMinS64, VectorMinU64, VectorMaxS64, and VectorMaxU64.

These IR opcodes are generated by the optimizer but lack direct hardware instruction support for 64-bit elements in the base NEON set (e.g., UMIN.2D does not exist). They are implemented using a compare (CMGT/CMHI) followed by a bitwise select (BSL). This correctly selects between the two source registers, whereas using BIT would incorrectly zero out elements.

This implementation is guarded by #ifdef __APPLE__ to ensure no impact on other platforms.

Unit tests could not be added to a64.cpp because UMIN.2D is not a valid A64 instruction, causing the assembler (Oaknut) to reject it. The fix was verified by running Team Sonic Racing, which previously crashed on this synthetic opcode.

Fixes crash in Team Sonic Racing on macOS.

Co-authored-by: crueter <crueter@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3421
Reviewed-by: Lizzie <lizzie@eden-emu.dev>
Reviewed-by: crueter <crueter@eden-emu.dev>

CMakeLists.txt

@@ -268,11 +268,6 @@ if (NOT EXISTS ${PROJECT_BINARY_DIR}/${compat_json})
     file(WRITE ${PROJECT_BINARY_DIR}/${compat_json} "")
 endif()
 
-if (YUZU_LEGACY)
-    message(WARNING "Making legacy build. Performance may suffer.")
-    add_compile_definitions(YUZU_LEGACY)
-endif()
-
 if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
     set(HAS_NCE 1)
     add_compile_definitions(HAS_NCE=1)
@@ -424,10 +419,10 @@ if (zstd_ADDED)
     add_library(zstd::libzstd ALIAS libzstd_static)
 endif()
 
-if (NOT YUZU_STATIC_ROOM)
-    # nlohmann
-    AddJsonPackage(nlohmann)
+# nlohmann
+AddJsonPackage(nlohmann)
 
+if (NOT YUZU_STATIC_ROOM)
     # zlib
     AddJsonPackage(zlib)
 
@@ -485,7 +480,7 @@ endfunction()
 # =============================================
 
 if (APPLE)
-    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia)
+    foreach(fw Carbon Metal Cocoa IOKit CoreVideo CoreMedia Security)
         find_library(${fw}_LIBRARY ${fw} REQUIRED)
         list(APPEND PLATFORM_LIBRARIES ${${fw}_LIBRARY})
     endforeach()

CMakeModules/GenerateSCMRev.cmake

@@ -33,9 +33,11 @@ endif()
 set(GIT_DESC ${BUILD_VERSION})
 
 # Generate cpp with Git revision from template
-# Also if this is a CI build, add the build name (ie: Nightly, Canary) to the scm_rev file as well
 
-# Auto-updater metadata! Must somewhat mirror GitHub/Forgejo API endpoint
+# TODO(crueter): Stable releases feed.
+set(BUILD_AUTO_UPDATE_STABLE_REPO "eden-emu/eden")
+set(BUILD_AUTO_UPDATE_STABLE_API "git.eden-emu.dev")
+set(BUILD_AUTO_UPDATE_STABLE_API_PATH "/api/v1/repos/")
 
 set(BUILD_AUTO_UPDATE_API_PATH "/latest/release.json")
 if (NIGHTLY_BUILD)

docs/Caveats.md

@@ -4,7 +4,8 @@
 - [Arch Linux](#arch-linux)
 - [Gentoo Linux](#gentoo-linux)
 - [macOS](#macos)
-- [Solaris](#solaris)
+- [OpenIndiana](#openindiana)
+- [OmniOS](#omnios)
 - [HaikuOS](#haikuos)
 - [OpenBSD](#openbsd)
 - [FreeBSD](#freebsd)
@@ -31,14 +32,14 @@ If you're having issues with building, always consult that ebuild.
 
 macOS is largely untested. Expect crashes, significant Vulkan issues, and other fun stuff.
 
-## Solaris
+## OpenIndiana
 
 Always consult [the OpenIndiana package list](https://pkg.openindiana.org/hipster/en/index.shtml) to cross-verify availability.
 
 Run the usual update + install of essential toolings: `sudo pkg update && sudo pkg install git cmake`.
 
-- **gcc**: `sudo pkg install developer/gcc-14`.
-- **clang**: Version 20 is broken, use `sudo pkg install developer/clang-19`.
+- **gcc**: Install either `developer/gcc-14`.
+- **clang**: Version 20 is broken, install `developer/clang-19`.
 
 Qt Widgets appears to be broken. For now, add `-DENABLE_QT=OFF` to your configure command. In the meantime, a Qt Quick frontend is in the works--check back later!
 
@@ -67,6 +68,31 @@ export LIBGL_ALWAYS_SOFTWARE=1
 - If using OpenIndiana, due to a bug in SDL2's CMake configuration, audio driver defaults to SunOS `<sys/audioio.h>`, which does not exist on OpenIndiana. Using external or bundled SDL2 may solve this.
 - System OpenSSL generally does not work. Instead, use `-DYUZU_USE_BUNDLED_OPENSSL=ON` to use a bundled static OpenSSL, or build a system dependency from source.
 
+## OmniOS
+
+Install `developer/gcc14` on OmniOS using pkgsrc.
+
+Since so many dependencies are missing on `OmniOS`, you may wish to use `-DCPMUTIL_FORCE_BUNDLED=ON -DYUZU_USE_EXTERNAL_SDL2=ON`
+
+For OmniOS you are required to build glslang yourself:
+```sh
+sudo pkg install python-313
+git clone --depth=1 https://github.com/KhronosGroup/glslang.git
+cd glslang
+python3.13 ./update_glslang_sources.py
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -- -j `nproc`
+cmake --install build
+```
+
+It may be tempting to specify `-t glslang`, but this will cause installation to fail. So don't.
+
+Using `--parallel` on CMake incorrectly passes `dmake ... -jn` instead of `dmake ... -j n`, this is a bug with OmniOS's CMake, and as such it's recommended to not use this option until it's fixed.
+
+You may also need to install `gmake` in order to properly build FFmpeg, this is provided by the `build-essential` package.
+
+If it wasn't obvious already, you require a X11 server to properly run the emulator within OmniOS, [this guide](https://web.archive.org/web/20260424200928/https://geekblood.wordpress.com/2017/10/26/installing-x11-and-a-desktop-environment-on-omnios/) is a great starting point for that, the links to pkgsrc are outdated so follow [this exemplar](https://pkgsrc.smartos.org/install-on-illumos/) as well:
+
 ## HaikuOS
 
 It's recommended to do a `pkgman full-sync` before installing. See [HaikuOS: Installing applications](https://www.haiku-os.org/guides/daily-tasks/install-applications/). Sometimes the process may be interrupted by an error like "Interrupted syscall". Simply firing the command again fixes the issue. By default `g++` is included on the default installation.

docs/Deps.md

@@ -291,13 +291,23 @@ pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmak
 
 </details>
 <details>
-<summary>Solaris / OpenIndiana</summary>
+<summary>OpenIndiana</summary>
 
 ```sh
-sudo pkg install qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
+sudo pkg install git cmake qt6 boost glslang libzip library/lz4 libusb-1 nlohmann-json openssl opus sdl2 zlib compress/zstd unzip pkg-config nasm autoconf mesa library/libdrm header-drm developer/fmt
 ```
 
-[Caveats](./Caveats.md#solaris).
+[Caveats](./Caveats.md#openindiana).
+
+</details>
+<details>
+<summary>OmniOS</summary>
+
+```sh
+sudo pkgin install git cmake autoconf build-essential libusb-1 nasm gcc13
+```
+
+[Caveats](./Caveats.md#omnios).
 
 </details>
 <details>

src/CMakeLists.txt

@@ -25,6 +25,16 @@ if (NIGHTLY_BUILD)
     add_compile_definitions(NIGHTLY_BUILD)
 endif()
 
+if (YUZU_LEGACY)
+    message(WARNING "Making legacy build. Performance may suffer.")
+    add_compile_definitions(YUZU_LEGACY)
+endif()
+
+if (GENSHIN_SPOOF)
+    message(WARNING "Making Genshin spoof build")
+    add_compile_definitions(GENSHIN_SPOOF)
+endif()
+
 # Set compilation flags
 if (MSVC AND NOT CXX_CLANG)
     set(CMAKE_CONFIGURATION_TYPES Debug Release CACHE STRING "" FORCE)

src/android/app/build.gradle.kts

@@ -203,6 +203,12 @@ android {
             resValue("string", "app_name_suffixed", "Eden Optimized")
             applicationId = "com.miHoYo.Yuanshen"
 
+            externalNativeBuild {
+                cmake {
+                    arguments.add("-DGENSHIN_SPOOF=ON")
+                }
+            }
+
             ndk {
                 abiFilters += listOf("arm64-v8a")
             }

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -33,6 +33,19 @@ import org.yuzu.yuzu_emu.applets.web.WebBrowser
  * with the native side of the Yuzu code.
  */
 object NativeLibrary {
+    @Keep
+    data class UpdateResult(
+        var tag: String = "",
+        var title: String = "",
+        var body: String = "",
+        var url: String = "",
+        var assets: MutableList<String> = mutableListOf()
+    ) {
+        fun addAsset(asset: String) {
+            assets.add(asset)
+        }
+    }
+
     @JvmField
     var sEmulationActivity = WeakReference<EmulationActivity?>(null)
 
@@ -240,17 +253,7 @@ object NativeLibrary {
     /**
      * Checks for available updates.
      */
-    external fun checkForUpdate(): Array<String>?
-
-    /**
-     * Return the URL to the release page
-     */
-    external fun getUpdateUrl(version: String): String
-
-    /**
-     * Return the URL to download the APK for the given version
-     */
-    external fun getUpdateApkUrl(tag: String, artifact: String, packageId: String): String
+    external fun checkForUpdate(): UpdateResult?
 
     /**
      * Returns whether the update checker is enabled through CMAKE options.

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -34,10 +34,6 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_DEBUG("debug"),
     RENDERER_PATCH_OLD_QCOM_DRIVERS("patch_old_qcom_drivers"),
     RENDERER_VERTEX_INPUT_DYNAMIC_STATE("vertex_input_dynamic_state"),
-    FORCE_IDENTITY_SWIZZLE("force_identity_swizzle"),
-    FORCE_LDR_TO_SRGB("force_ldr_to_srgb"),
-    RENDERER_PROVOKING_VERTEX("provoking_vertex"),
-    RENDERER_DESCRIPTOR_INDEXING("descriptor_indexing"),
     RENDERER_SAMPLE_SHADING("sample_shading"),
     GPU_UNSWIZZLE_ENABLED("gpu_unswizzle_enabled"),
     PICTURE_IN_PICTURE("picture_in_picture"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/IntSetting.kt

@@ -17,8 +17,6 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     RENDERER_VRAM_USAGE_MODE("vram_usage_mode"),
     RENDERER_NVDEC_EMULATION("nvdec_emulation"),
     RENDERER_ASTC_DECODE_METHOD("accelerate_astc"),
-    RENDERER_ASTC_RECOMPRESSION("astc_recompression"),
-    RENDERER_FORMAT_REINTERPRETATION("format_reinterpretation"),
     RENDERER_ACCURACY("gpu_accuracy"),
     RENDERER_RESOLUTION("resolution_setup"),
     RENDERER_VSYNC("use_vsync"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -148,34 +148,6 @@ abstract class SettingsItem(
                     descriptionId = R.string.vertex_input_dynamic_state_description
                 )
             )
-            put(
-                SwitchSetting(
-                    BooleanSetting.FORCE_IDENTITY_SWIZZLE,
-                    titleId = R.string.force_identity_swizzle,
-                    descriptionId = R.string.force_identity_swizzle_description
-                )
-            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.FORCE_LDR_TO_SRGB,
-                    titleId = R.string.force_ldr_to_srgb,
-                    descriptionId = R.string.force_ldr_to_srgb_description
-                )
-            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_DESCRIPTOR_INDEXING,
-                    titleId = R.string.descriptor_indexing,
-                    descriptionId = R.string.descriptor_indexing_description
-                )
-            )
-            put(
-                SwitchSetting(
-                    BooleanSetting.RENDERER_SAMPLE_SHADING,
-                    titleId = R.string.sample_shading,
-                    descriptionId = R.string.sample_shading_description
-                )
-            )
             put(
                 SliderSetting(
                     IntSetting.RENDERER_SAMPLE_SHADING,
@@ -363,23 +335,6 @@ abstract class SettingsItem(
                     valuesId = R.array.astcDecodingMethodValues
                 )
             )
-            put(
-                SingleChoiceSetting(
-                    IntSetting.RENDERER_ASTC_RECOMPRESSION,
-                    titleId = R.string.astc_recompression,
-                    descriptionId = R.string.astc_recompression_description,
-                    choicesId = R.array.astcRecompressionMethodNames,
-                    valuesId = R.array.astcRecompressionMethodValues
-                )
-            )
-            put(
-                SingleChoiceSetting(
-                    IntSetting.RENDERER_FORMAT_REINTERPRETATION,
-                    titleId = R.string.format_reinterpretation,
-                    choicesId = R.array.formatReinterpretationNames,
-                    valuesId = R.array.formatReinterpretationValues
-                )
-            )
             put(
                 SingleChoiceSetting(
                     IntSetting.RENDERER_VRAM_USAGE_MODE,

src/android/app/src/main/java/org/yuzu/yuzu_emu/ui/main/MainActivity.kt

@@ -175,25 +175,25 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             val latestVersion = NativeLibrary.checkForUpdate()
             if (latestVersion != null) {
                 runOnUiThread {
-                    val tag: String = latestVersion[0]
-                    val name: String = latestVersion[1]
-                    showUpdateDialog(tag, name)
+                    showUpdateDialog(latestVersion)
                 }
             }
         }.start()
     }
 
-    private fun showUpdateDialog(tag: String, name: String) {
+    // TODO(crueter): body, "View on Forgejo" button
+    private fun showUpdateDialog(release: NativeLibrary.UpdateResult) {
         MaterialAlertDialogBuilder(this)
             .setTitle(R.string.update_available)
-            .setMessage(getString(R.string.update_available_description, name))
+            .setMessage(getString(R.string.update_available_description, release.title))
             .setPositiveButton(android.R.string.ok) { _, _ ->
-                var artifact = tag
-                // Nightly builds have a slightly different format
-                if (NativeLibrary.isNightlyBuild()) {
-                    artifact = tag.substringAfter('.', tag)
+                val assets = release.assets
+
+                if (assets.isEmpty()) {
+                    openLink(release.url)
+                } else {
+                    downloadAndInstallUpdate(release)
                 }
-                downloadAndInstallUpdate(tag, artifact)
             }
             .setNeutralButton(R.string.cancel) { dialog, _ ->
                 dialog.dismiss()
@@ -206,17 +206,23 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             .show()
     }
 
-    private fun downloadAndInstallUpdate(version: String, artifact: String) {
+    private fun openLink(link: String) {
+        val intent = Intent(Intent.ACTION_VIEW, link.toUri())
+        startActivity(intent)
+    }
+
+    private fun downloadAndInstallUpdate(release: NativeLibrary.UpdateResult) {
         CoroutineScope(Dispatchers.IO).launch {
             val packageId = applicationContext.packageName
-            val apkUrl = NativeLibrary.getUpdateApkUrl(version, artifact, packageId)
+            val asset = release.assets[0]
+            val artifact = asset.split("/").last()
             val apkFile = File(cacheDir, "update-$artifact.apk")
 
             withContext(Dispatchers.Main) {
                 showDownloadProgressDialog()
             }
 
-            val downloader = APKDownloader(apkUrl, apkFile)
+            val downloader = APKDownloader(asset, apkFile)
             downloader.download(
                 onProgress = { progress ->
                     runOnUiThread {
@@ -248,7 +254,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                         } else {
                             Toast.makeText(
                                 this@MainActivity,
-                                getString(R.string.update_download_failed) + "\n\nURL: $apkUrl",
+                                getString(R.string.update_download_failed) + "\n\nURL: $asset",
                                 Toast.LENGTH_LONG
                             ).show()
                         }
@@ -277,7 +283,7 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
     private fun updateDownloadProgress(progress: Int) {
         progressBar?.progress = progress
-        progressMessage?.text = "$progress%"
+        progressMessage?.text = getString(R.string.percent, progress)
     }
 
     private fun dismissDownloadProgressDialog() {

src/android/app/src/main/jni/native.cpp

@@ -1699,76 +1699,76 @@ JNIEXPORT jboolean JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_isNightlyBuild(
 #ifdef ENABLE_UPDATE_CHECKER
 
 
-JNIEXPORT jobjectArray JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_checkForUpdate(
+JNIEXPORT jobject JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_checkForUpdate(
         JNIEnv* env,
         jobject obj) {
-    std::optional<UpdateChecker::Update> release = UpdateChecker::GetUpdate();
+    std::optional<Common::Net::Release> release = UpdateChecker::GetUpdate();
     if (!release) return nullptr;
 
     const std::string tag = release->tag;
-    const std::string name = release->name;
+    const std::string title = release->title;
+    const std::string body = release->body;
+    const std::string url = release->html_url;
 
-    jobjectArray result = env->NewObjectArray(2, env->FindClass("java/lang/String"), nullptr);
+    // Android *should* only ever define a single asset.
+    // If not, something has gone wrong, but the Kotlin side can handle it.
+    const auto assets = release->GetPlatformAssets();
 
-    const jstring jtag = env->NewStringUTF(tag.c_str());
-    const jstring jname = env->NewStringUTF(name.c_str());
-
-    env->SetObjectArrayElement(result, 0, jtag);
-    env->SetObjectArrayElement(result, 1, jname);
-    env->DeleteLocalRef(jtag);
-    env->DeleteLocalRef(jname);
-
-    return result;
-}
-
-JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateUrl(
-        JNIEnv* env,
-        jobject obj,
-        jstring version) {
-    const char* version_str = env->GetStringUTFChars(version, nullptr);
-    const std::string url = fmt::format("{}/{}",
-        std::string{Common::g_build_auto_update_api},
-        version_str);
-    env->ReleaseStringUTFChars(version, version_str);
-    return env->NewStringUTF(url.c_str());
-}
-
-JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getUpdateApkUrl(
-        JNIEnv* env,
-        jobject obj,
-        jstring tag,
-        jstring artifact,
-        jstring packageId) {
-    const char* version_str = env->GetStringUTFChars(tag, nullptr);
-    const char* artifact_str = env->GetStringUTFChars(artifact, nullptr);
-    const char* package_id_str = env->GetStringUTFChars(packageId, nullptr);
-
-    std::string variant;
-    std::string package_id(package_id_str);
-
-    if (package_id.find("dev.legacy.eden_emulator") != std::string::npos) {
-        variant = "legacy";
-    } else if (package_id.find("com.miHoYo.Yuanshen") != std::string::npos) {
-        variant = "optimized";
-    } else {
-#ifdef ARCHITECTURE_arm64
-        variant = "standard";
-#else
-        variant = "chromeos";
-#endif
+    jclass updateResultClass = env->FindClass("org/yuzu/yuzu_emu/NativeLibrary$UpdateResult");
+    if (!updateResultClass) {
+        LOG_ERROR(Frontend, "Could not find UpdateResult class");
+        return nullptr;
     }
 
-    const std::string apk_filename = fmt::format("Eden-Android-{}-{}.apk", artifact_str, variant);
+    jmethodID updateResultCtor = env->GetMethodID(updateResultClass, "<init>", "()V");
 
-    const std::string url = fmt::format("{}/{}/{}",
-        std::string{Common::g_build_auto_update_api},
-        version_str, apk_filename);
+    if (!updateResultCtor) {
+        LOG_ERROR(Frontend, "Could not find UpdateResult ctor");
+        env->DeleteLocalRef(updateResultClass);
+        return nullptr;
+    }
 
-    env->ReleaseStringUTFChars(tag, version_str);
-    env->ReleaseStringUTFChars(artifact, artifact_str);
-    env->ReleaseStringUTFChars(packageId, package_id_str);
-    return env->NewStringUTF(url.c_str());
+    jmethodID setTag = env->GetMethodID(updateResultClass, "setTag", "(Ljava/lang/String;)V");
+    jmethodID setTitle = env->GetMethodID(updateResultClass, "setTitle", "(Ljava/lang/String;)V");
+    jmethodID setBody = env->GetMethodID(updateResultClass, "setBody", "(Ljava/lang/String;)V");
+    jmethodID setUrl = env->GetMethodID(updateResultClass, "setUrl", "(Ljava/lang/String;)V");
+    jmethodID addAsset = env->GetMethodID(updateResultClass, "addAsset", "(Ljava/lang/String;)V");
+
+    jobject updateResult = env->NewObject(updateResultClass, updateResultCtor);
+
+    LOG_DEBUG(Frontend, "Tag: {}", tag);
+    LOG_DEBUG(Frontend, "Title: {}", title);
+    LOG_DEBUG(Frontend, "Body: {}", body);
+    LOG_DEBUG(Frontend, "Url: {}", url);
+
+    const auto jtag = env->NewStringUTF(tag.c_str());
+    const auto jtitle = env->NewStringUTF(title.c_str());
+    const auto jbody = env->NewStringUTF(body.c_str());
+    const auto jurl = env->NewStringUTF(url.c_str());
+
+    env->CallVoidMethod(updateResult, setTag, jtag);
+    env->CallVoidMethod(updateResult, setTitle, jtitle);
+    env->CallVoidMethod(updateResult, setBody, jbody);
+    env->CallVoidMethod(updateResult, setUrl, jurl);
+
+    // TODO(crueter): Handling for multiple assets?
+    // Maybe another data class x(
+    for (const Common::Net::Asset &a : assets) {
+        const auto jaurl = env->NewStringUTF(a.path.c_str());
+        env->CallVoidMethod(updateResult, addAsset, jaurl);
+        env->DeleteLocalRef(jaurl);
+    }
+
+    env->DeleteLocalRef(jtag);
+    env->DeleteLocalRef(jtitle);
+    env->DeleteLocalRef(jbody);
+    env->DeleteLocalRef(jurl);
+
+    env->DeleteLocalRef(updateResultClass);
+
+    return updateResult;
 }
+
 #endif
 
 JNIEXPORT jstring JNICALL Java_org_yuzu_yuzu_1emu_NativeLibrary_getBuildVersion(

src/android/app/src/main/res/values-ar/strings.xml

@@ -1159,5 +1159,6 @@
     <string name="license_fidelityfx_fsr_description">تحسين الجودة بدرجة عالية من AMD</string>
     <string name="external_content">محتوى خارجي</string>
     <string name="add_folders">إضافة مجلد</string>
+    <string name="percent">%1$d%%</string>
 
 </resources>

src/android/app/src/main/res/values-es/strings.xml

@@ -767,7 +767,7 @@
     <string name="version">Versión</string>
     <string name="copy_details">Copiar detalles</string>
     <string name="add_ons">Complementos</string>
-    <string name="add_ons_description">Activa/desactiva mods, actualizaciones y contenidos descargables</string>
+    <string name="add_ons_description">Alternar mods, actualizaciones y contenido descargable</string>
     <string name="playtime">Tiempo jugado:</string>
     <string name="reset_playtime">Borrar tiempo de juego</string>
     <string name="reset_playtime_description">Restablecer el tiempo de juego actual a 0 segundos</string>
@@ -1153,5 +1153,6 @@
     <string name="license_fidelityfx_fsr_description">Upscaling de alta calidad de AMD</string>
     <string name="external_content">Contenido externo</string>
     <string name="add_folders">Añadir carpeta</string>
+    <string name="percent">%1$d%%</string>
 
 </resources>

src/android/app/src/main/res/values-ru/strings.xml

@@ -1150,5 +1150,4 @@
     <string name="license_fidelityfx_fsr_description">Высококачественное масштабирование от AMD</string>
     <string name="external_content">Дополнительный контент</string>
     <string name="add_folders">Добавить папку</string>
-
-</resources>
+    </resources>

src/android/app/src/main/res/values-uk/strings.xml

@@ -1155,5 +1155,6 @@
     <string name="license_fidelityfx_fsr_description">Високоякісне масштабування від AMD</string>
     <string name="external_content">Зовнішній вміст</string>
     <string name="add_folders">Додати теку</string>
+    <string name="percent">%1$d%%</string>
 
 </resources>

src/android/app/src/main/res/values-zh-rCN/strings.xml

@@ -483,6 +483,8 @@
     <string name="enable_buffer_history">启用缓冲区历史</string>
     <string name="enable_buffer_history_description">启用对先前缓冲区状态的访问。此选项可在某些游戏中提升渲染质量并保持性能的一致性。</string>
     <string name="use_optimized_vertex_buffers">优化顶点缓冲区</string>
+    <string name="use_optimized_vertex_buffers_description">启用经过优化的顶点缓冲区绑定以提升性能。需要 Mesa 26.0 及以上版本的 Turnip 或 QCOM 驱动程序。若使用较旧版本的 Turnip 驱动则会导致崩溃。</string>
+
     <string name="hacks">Hacks</string>
 
     <string name="fast_gpu_time">GPU 超频频率</string>
@@ -490,6 +492,9 @@
     <string name="skip_cpu_inner_invalidation">跳过CPU内部无效化</string>
     <string name="skip_cpu_inner_invalidation_description">在内存更新期间跳过某些CPU端缓存无效化，减少CPU使用率并提高其性能。可能会导致某些游戏出现故障或崩溃。</string>
     <string name="fix_bloom_effects">修复 Bloom 效果</string>
+    <string name="fix_bloom_effects_description">减少《塞尔达传说：智慧的再现》（Adreno A6XX - A7XX/ Turnip）中的 bloom 模糊，并移除《Burnout》中的 bloom 效果。警告：可能会导致在其他游戏中出现图形异常。</string>
+    <string name="emulate_bgr565">模拟 BGR565</string>
+    <string name="emulate_bgr565_description">修复了游戏中的颜色反转以及出现的异常画面瑕疵或奇怪阴影问题</string>
     <string name="renderer_asynchronous_shaders">使用异步着色器</string>
     <string name="renderer_asynchronous_shaders_description">异步编译着色器。这可能会减少卡顿，但也可能会导致图形错误。</string>
     <string name="gpu_unswizzle_settings">GPU 还原设置</string>
@@ -1144,5 +1149,6 @@
     <string name="license_fidelityfx_fsr_description">AMD 的高品质画面增强技术</string>
     <string name="external_content">外部内容</string>
     <string name="add_folders">添加文件夹</string>
+    <string name="percent">%1$d%%</string>
 
 </resources>

src/android/app/src/main/res/values/strings.xml

@@ -1783,5 +1783,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
     <string name="external_content">External Content</string>
     <string name="add_folders">Add Folder</string>
+    <string name="percent">%1$d%%</string>
 
 </resources>

src/common/CMakeLists.txt

@@ -147,7 +147,8 @@ add_library(
     zstd_compression.h
     fs/ryujinx_compat.h fs/ryujinx_compat.cpp
     fs/symlink.h fs/symlink.cpp
-    httplib.h)
+    httplib.h
+    net/net.h net/net.cpp)
 
 if(WIN32)
     target_sources(common PRIVATE windows/timer_resolution.cpp
@@ -245,7 +246,7 @@ else()
     target_link_libraries(common PUBLIC Boost::headers)
 endif()
 
-target_link_libraries(common PUBLIC Boost::filesystem Boost::context httplib::httplib)
+target_link_libraries(common PUBLIC Boost::filesystem Boost::context httplib::httplib nlohmann_json::nlohmann_json)
 
 if (lz4_ADDED)
     target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)

src/common/host_memory.cpp

@@ -693,9 +693,7 @@ void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length,
     ASSERT(virtual_offset % PageAlignment == 0);
     ASSERT(host_offset % PageAlignment == 0);
     ASSERT(length % PageAlignment == 0);
-    if (impl && virtual_base) {
-        ASSERT(virtual_offset + length <= virtual_size);
-    }
+    ASSERT(virtual_offset + length <= virtual_size);
     ASSERT(host_offset + length <= backing_size);
     if (length == 0 || !virtual_base || !impl) {
         return;
@@ -706,9 +704,7 @@ void HostMemory::Map(size_t virtual_offset, size_t host_offset, size_t length,
 void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap) {
     ASSERT(virtual_offset % PageAlignment == 0);
     ASSERT(length % PageAlignment == 0);
-    if (impl && virtual_base) {
-        ASSERT(virtual_offset + length <= virtual_size);
-    }
+    ASSERT(virtual_offset + length <= virtual_size);
     if (length == 0 || !virtual_base || !impl) {
         return;
     }
@@ -718,9 +714,7 @@ void HostMemory::Unmap(size_t virtual_offset, size_t length, bool separate_heap)
 void HostMemory::Protect(size_t virtual_offset, size_t length, MemoryPermission perm) {
     ASSERT(virtual_offset % PageAlignment == 0);
     ASSERT(length % PageAlignment == 0);
-    if (impl && virtual_base) {
-        ASSERT(virtual_offset + length <= virtual_size);
-    }
+    ASSERT(virtual_offset + length <= virtual_size);
     if (length == 0 || !virtual_base || !impl) {
         return;
     }

src/common/multi_level_page_table.inc

@@ -13,13 +13,13 @@
 namespace Common {
 
 template <typename BaseAddr>
-MultiLevelPageTable<BaseAddr>::MultiLevelPageTable(std::size_t address_space_bits_,
-                                                   std::size_t first_level_bits_,
-                                                   std::size_t page_bits_)
-    : address_space_bits{address_space_bits_},
-      first_level_bits{first_level_bits_}, page_bits{page_bits_} {
+MultiLevelPageTable<BaseAddr>::MultiLevelPageTable(std::size_t address_space_bits_, std::size_t first_level_bits_, std::size_t page_bits_)
+    : address_space_bits{address_space_bits_}
+    , first_level_bits{first_level_bits_}
+    , page_bits{page_bits_}
+{
     if (page_bits == 0) {
-      return;
+        return;
     }
     first_level_shift = address_space_bits - first_level_bits;
     first_level_chunk_size = (1ULL << (first_level_shift - page_bits)) * sizeof(BaseAddr);
@@ -30,12 +30,9 @@ MultiLevelPageTable<BaseAddr>::MultiLevelPageTable(std::size_t address_space_bit
     void* base{VirtualAlloc(nullptr, alloc_size, MEM_RESERVE, PAGE_READWRITE)};
 #else
     void* base{mmap(nullptr, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)};
-
-    if (base == MAP_FAILED) {
+    if (base == MAP_FAILED)
         base = nullptr;
-    }
 #endif
-
     ASSERT(base);
     base_ptr = reinterpret_cast<BaseAddr*>(base);
 }
@@ -56,29 +53,21 @@ template <typename BaseAddr>
 void MultiLevelPageTable<BaseAddr>::ReserveRange(u64 start, std::size_t size) {
     const u64 new_start = start >> first_level_shift;
     const u64 new_end = (start + size) >> first_level_shift;
-    for (u64 i = new_start; i <= new_end; i++) {
-        if (!first_level_map[i]) {
+    for (u64 i = new_start; i <= new_end; i++)
+        if (!first_level_map[i])
             AllocateLevel(i);
-        }
-    }
 }
 
 template <typename BaseAddr>
-void MultiLevelPageTable<BaseAddr>::AllocateLevel(u64 level) {
-    void* ptr = reinterpret_cast<char *>(base_ptr) + level * first_level_chunk_size;
+void MultiLevelPageTable<BaseAddr>::AllocateLevel(u64 index) {
+    void* ptr = reinterpret_cast<char *>(base_ptr) + index * first_level_chunk_size;
 #ifdef _WIN32
-    void* base{VirtualAlloc(ptr, first_level_chunk_size, MEM_COMMIT, PAGE_READWRITE)};
-#else
-    void* base{mmap(ptr, first_level_chunk_size, PROT_READ | PROT_WRITE,
-                    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)};
-
-    if (base == MAP_FAILED) {
-        base = nullptr;
-    }
-#endif
+    void* base = VirtualAlloc(ptr, first_level_chunk_size, MEM_COMMIT, PAGE_READWRITE);
     ASSERT(base);
-
-    first_level_map[level] = base;
+#else
+    void* base = ptr;
+#endif
+    first_level_map[index] = base;
 }
 
 } // namespace Common

src/common/net/net.cpp

@@ -0,0 +1,287 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <optional>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/replace.hpp>
+#include <boost/algorithm/string/split.hpp>
+
+#include <fmt/format.h>
+#include "common/scm_rev.h"
+#include "net.h"
+
+#include "common/logging.h"
+
+#include "common/httplib.h"
+
+#ifdef YUZU_BUNDLED_OPENSSL
+#include <openssl/cert.h>
+#endif
+
+#define QT_TR_NOOP(x) x
+
+namespace Common::Net {
+
+std::vector<Asset> Release::GetPlatformAssets() const {
+    // TODO(crueter): Need better handling for this as a whole.
+#ifdef NIGHTLY_BUILD
+    std::vector<std::string> result;
+    boost::algorithm::split(result, tag, boost::is_any_of("."));
+    if (result.size() != 2)
+        return {};
+    const auto ref = result.at(1);
+#else
+    const auto ref = tag;
+#endif
+
+    std::vector<Asset> found_assets;
+
+    // FIXME: This is mildly inefficient.
+    // Finds assets based on a hierarchy of regex search strings.
+    const auto find_asset = [&found_assets, ref, this](const std::string& name,
+                                                       const std::vector<std::string>& suffixes) {
+        for (const std::string& asset : assets) {
+            for (const auto& suffix : suffixes) {
+                if (asset.ends_with(suffix)) {
+                    const std::string_view asset_sv = asset;
+                    const size_t pos = asset_sv.find_last_of('/');
+                    const std::string_view filename =
+                        (pos != std::string_view::npos) ? asset_sv.substr(pos + 1) : asset_sv;
+
+                    found_assets.emplace_back(Asset{
+                        .name = name,
+                        .url = host,
+                        .path = asset,
+                        .filename = std::string{filename},
+                    });
+                    return;
+                }
+            }
+        }
+    };
+
+#ifdef _WIN32
+#ifdef ARCHITECTURE_x86_64
+    find_asset("Standard", {"amd64-msvc-standard.exe", "amd64-msvc-standard.zip", "mingw-amd64-gcc-standard.exe", "mingw-amd64-gcc-standard.zip"});
+    find_asset("PGO", {"mingw-amd64-clang-pgo.exe", "mingw-amd64-clang-pgo.zip"});
+#elif defined(ARCHITECTURE_arm64)
+    find_asset("Standard", {"mingw-arm64-clang-standard.exe", "mingw-arm64-clang-standard.zip"});
+    find_asset("PGO", {"mingw-arm64-clang-pgo.exe", "mingw-arm64-clang-pgo.zip"});
+#endif
+#elif defined(__APPLE__)
+#ifdef ARCHITECTURE_arm64
+    find_asset("Standard", {".dmg", ".tar.gz"});
+#endif
+#elif defined(__ANDROID__)
+#ifdef ARCHITECTURE_x86_64
+    find_asset("Standard", {"chromeos.apk"});
+#elif defined(ARCHITECTURE_arm64)
+#ifdef YUZU_LEGACY
+    find_asset("Standard", {"legacy.apk"});
+#elif defined(GENSHIN_SPOOF)
+    find_asset("Standard", {"optimized.apk"});
+#else
+    find_asset("Standard", {"standard.apk"});
+#endif
+#endif
+#endif
+    return found_assets;
+}
+
+static inline u64 ParseIsoTimestamp(const std::string& iso) {
+    if (iso.empty())
+        return 0;
+
+    std::string buf = iso;
+    if (buf.back() == 'Z')
+        buf.pop_back();
+
+    std::tm tm{};
+    std::istringstream ss(buf);
+    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
+    if (ss.fail())
+        return 0;
+
+#ifdef _WIN32
+    return static_cast<u64>(_mkgmtime(&tm));
+#else
+    return static_cast<u64>(timegm(&tm));
+#endif
+}
+
+std::optional<Release> Release::FromJson(const nlohmann::json& json, const std::string& host,
+                                         const std::string& repo) {
+    Release rel;
+    if (!json.is_object())
+        return std::nullopt;
+
+    rel.tag = json.value("tag_name", std::string{});
+    if (rel.tag.empty())
+        return std::nullopt;
+
+    rel.title = json.value("name", rel.tag);
+    rel.id = json.value("id", std::hash<std::string>{}(rel.title));
+
+    rel.published = ParseIsoTimestamp(json.value("published_at", std::string{}));
+    rel.prerelease = json.value("prerelease", false);
+
+    auto body = json.value("body", rel.title);
+    boost::replace_all(body, "\\r", "");
+    boost::replace_all(body, "\\n", "\n");
+    rel.body = body;
+
+    rel.host = host;
+
+    const auto release_base =
+        fmt::format("{}/{}/releases", Common::g_build_auto_update_website, repo);
+    const auto fallback_html = fmt::format("{}/tag/{}", release_base, rel.tag);
+    rel.html_url = json.value("html_url", fallback_html);
+
+    // This is our own "fake" API.
+    if (json.contains("base")) {
+        const auto base = json.value("base", fmt::format("https://{}", Common::g_build_auto_update_api));
+        rel.base_download_url = fmt::format("{}/{}", base, rel.tag);
+
+        // Assets are easy :)
+        rel.assets = json.value("assets", std::vector<std::string>{});
+    } else {
+        const auto base_download_url = fmt::format("/{}/releases/download/{}", repo, rel.tag);
+
+        rel.base_download_url = base_download_url;
+
+        // assets are a bit more complex here. :(
+        std::vector<std::string> assets;
+        const nlohmann::json& arr = json["assets"];
+        for (const auto &obj : arr) {
+            const auto url = obj.value("browser_download_url", std::string{});
+            assets.emplace_back(url);
+        }
+
+        rel.assets = assets;
+    }
+
+    return rel;
+}
+
+std::optional<Release> Release::FromJson(const std::string_view& json, const std::string& host,
+                                         const std::string& repo) {
+    try {
+        return FromJson(nlohmann::json::parse(json), host, repo);
+    } catch (std::exception& e) {
+        LOG_WARNING(Common, "Failed to parse JSON: {}", e.what());
+    }
+
+    return {};
+}
+
+std::vector<Release> Release::ListFromJson(const nlohmann::json& json, const std::string& host,
+                                           const std::string& repo) {
+    if (!json.is_array())
+        return {};
+
+    std::vector<Release> releases;
+    for (const auto& obj : json) {
+        auto rel = Release::FromJson(obj, host, repo);
+        if (rel)
+            releases.emplace_back(rel.value());
+    }
+    return releases;
+}
+
+std::vector<Release> Release::ListFromJson(const std::string_view& json, const std::string& host,
+                                           const std::string& repo) {
+    try {
+        return ListFromJson(nlohmann::json::parse(json), host, repo);
+    } catch (std::exception& e) {
+        LOG_WARNING(Common, "Failed to parse JSON: {}", e.what());
+    }
+
+    return {};
+}
+
+std::optional<std::string> MakeRequest(const std::string& url, const std::string& path) {
+    try {
+        constexpr std::size_t timeout_seconds = 15;
+
+        std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(url);
+        client->set_connection_timeout(timeout_seconds);
+        client->set_read_timeout(timeout_seconds);
+        client->set_write_timeout(timeout_seconds);
+
+#ifdef YUZU_BUNDLED_OPENSSL
+        client->load_ca_cert_store(kCert, sizeof(kCert));
+#endif
+
+        if (client == nullptr) {
+            LOG_ERROR(Common, "Invalid URL {}{}", url, path);
+            return {};
+        }
+
+        httplib::Request request{
+            .method = "GET",
+            .path = path,
+        };
+
+        client->set_follow_location(true);
+        httplib::Result result = client->send(request);
+
+        if (!result) {
+            LOG_ERROR(Common, "GET to {}{} returned null", url, path);
+            return {};
+        }
+
+        const auto& response = result.value();
+        if (response.status >= 400) {
+            LOG_ERROR(Common, "GET to {}{} returned error status code: {}", url, path,
+                      response.status);
+            return {};
+        }
+        if (!response.headers.contains("content-type")) {
+            LOG_ERROR(Common, "GET to {}{} returned no content", url, path);
+            return {};
+        }
+
+        return response.body;
+    } catch (std::exception& e) {
+        LOG_ERROR(Common, "GET to {}{} failed during update check: {}", url, path, e.what());
+        return std::nullopt;
+    }
+}
+
+std::vector<Release> GetReleases() {
+    const auto body = GetReleasesBody();
+
+    if (!body) {
+        LOG_WARNING(Common, "Failed to get stable releases");
+        return {};
+    }
+
+    const std::string_view body_str = body.value();
+    const auto url = fmt::format("https://{}", Common::g_build_auto_update_stable_api);
+    return Release::ListFromJson(body_str, url, Common::g_build_auto_update_stable_repo);
+}
+
+std::optional<Release> GetLatestRelease() {
+    const auto releases_path =  Common::g_build_auto_update_api_path;
+    const auto url = fmt::format("https://{}", Common::g_build_auto_update_api);
+
+    const auto body = MakeRequest(url, releases_path);
+    if (!body) {
+        LOG_WARNING(Common, "Failed to get latest release");
+        return std::nullopt;
+    }
+
+    const std::string_view body_str = body.value();
+    return Release::FromJson(body_str, url, Common::g_build_auto_update_repo);
+}
+
+std::optional<std::string> GetReleasesBody() {
+    const auto releases_path =
+        fmt::format("/{}/{}/releases", Common::g_build_auto_update_stable_api_path,
+                    Common::g_build_auto_update_stable_repo);
+    const auto url = fmt::format("https://{}", Common::g_build_auto_update_stable_api);
+
+    return MakeRequest(url, releases_path);
+}
+
+} // namespace Common::Net

src/common/net/net.h

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+#include <nlohmann/json.hpp>
+#include "common/common_types.h"
+
+namespace Common::Net {
+
+typedef struct {
+    std::string name;
+    std::string url;
+    std::string path;
+    std::string filename;
+} Asset;
+
+typedef struct Release {
+    std::string title;
+    std::string body;
+    std::string tag;
+    std::string base_download_url;
+    std::string html_url;
+    std::string host;
+
+    std::vector<std::string> assets;
+
+    u64 id;
+    u64 published;
+    bool prerelease;
+
+    // Get the relevant list of assets for the current platform.
+    std::vector<Asset> GetPlatformAssets() const;
+
+    static std::optional<Release> FromJson(const nlohmann::json& json, const std::string &host, const std::string& repo);
+    static std::optional<Release> FromJson(const std::string_view& json, const std::string &host, const std::string& repo);
+    static std::vector<Release> ListFromJson(const nlohmann::json &json, const std::string &host, const std::string &repo);
+    static std::vector<Release> ListFromJson(const std::string_view &json, const std::string &host, const std::string &repo);
+} Release;
+
+// Make a request via httplib, and return the response body if applicable.
+std::optional<std::string> MakeRequest(const std::string &url, const std::string &path);
+
+// Get all of the latest stable releases.
+std::vector<Release> GetReleases();
+
+// Get all of the latest stable releases as text.
+std::optional<std::string> GetReleasesBody();
+
+// Get the latest release of the current channel.
+std::optional<Release> GetLatestRelease();
+
+}

src/common/page_table.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -142,10 +142,8 @@ struct PageTable {
     VirtualBuffer<PageEntryData> entries;
     static_assert(sizeof(PageEntryData) == 32);
 
-    std::size_t current_address_space_width_in_bits{};
-
     u8* fastmem_arena{};
-
+    std::size_t current_address_space_width_in_bits{};
     std::size_t page_size{};
 };
 

src/common/scm_rev.cpp.in

@@ -22,6 +22,9 @@
 #define BUILD_AUTO_UPDATE_API "@BUILD_AUTO_UPDATE_API@"
 #define BUILD_AUTO_UPDATE_API_PATH "@BUILD_AUTO_UPDATE_API_PATH@"
 #define BUILD_AUTO_UPDATE_REPO "@BUILD_AUTO_UPDATE_REPO@"
+#define BUILD_AUTO_UPDATE_STABLE_API "@BUILD_AUTO_UPDATE_STABLE_API@"
+#define BUILD_AUTO_UPDATE_STABLE_API_PATH "@BUILD_AUTO_UPDATE_STABLE_API_PATH@"
+#define BUILD_AUTO_UPDATE_STABLE_REPO "@BUILD_AUTO_UPDATE_STABLE_REPO@"
 #define IS_NIGHTLY_BUILD @IS_NIGHTLY_BUILD@
 
 namespace Common {
@@ -45,5 +48,8 @@ constexpr const char g_build_auto_update_website[] = BUILD_AUTO_UPDATE_WEBSITE;
 constexpr const char g_build_auto_update_api[] = BUILD_AUTO_UPDATE_API;
 constexpr const char g_build_auto_update_api_path[] = BUILD_AUTO_UPDATE_API_PATH;
 constexpr const char g_build_auto_update_repo[] = BUILD_AUTO_UPDATE_REPO;
+constexpr const char g_build_auto_update_stable_api[] = BUILD_AUTO_UPDATE_STABLE_API;
+constexpr const char g_build_auto_update_stable_api_path[] = BUILD_AUTO_UPDATE_STABLE_API_PATH;
+constexpr const char g_build_auto_update_stable_repo[] = BUILD_AUTO_UPDATE_STABLE_REPO;
 
 } // namespace Common

src/common/scm_rev.h

@@ -28,5 +28,8 @@ extern const char g_build_auto_update_website[];
 extern const char g_build_auto_update_api[];
 extern const char g_build_auto_update_api_path[];
 extern const char g_build_auto_update_repo[];
+extern const char g_build_auto_update_stable_api[];
+extern const char g_build_auto_update_stable_api_path[];
+extern const char g_build_auto_update_stable_repo[];
 
 } // namespace Common

src/common/settings.cpp

@@ -52,7 +52,6 @@ SWITCHABLE(AstcRecompression, true);
 SWITCHABLE(AudioMode, true);
 SWITCHABLE(CpuBackend, true);
 SWITCHABLE(CpuAccuracy, true);
-SWITCHABLE(FormatReinterpretation, true);
 SWITCHABLE(FullscreenMode, true);
 SWITCHABLE(GpuAccuracy, true);
 SWITCHABLE(GpuLogLevel, true);

src/common/settings.h

@@ -69,7 +69,6 @@ SWITCHABLE(AstcRecompression, true);
 SWITCHABLE(AudioMode, true);
 SWITCHABLE(CpuBackend, true);
 SWITCHABLE(CpuAccuracy, true);
-SWITCHABLE(FormatReinterpretation, true);
 SWITCHABLE(FullscreenMode, true);
 SWITCHABLE(GpuAccuracy, true);
 SWITCHABLE(Language, true);
@@ -470,11 +469,7 @@ struct Values {
                                                                   "astc_recompression",
                                                                   Category::RendererAdvanced};
 
-    SwitchableSetting<FormatReinterpretation, true> format_reinterpretation{
-        linkage,
-        FormatReinterpretation::Disabled,
-        "format_reinterpretation",
-        Category::RendererAdvanced};
+
     SwitchableSetting<bool> sync_memory_operations{linkage,
                                                    false,
                                                    "sync_memory_operations",
@@ -483,9 +478,6 @@ struct Values {
                                                    true,
                                                    true};
 
-    SwitchableSetting<bool> force_identity_swizzle{linkage, false, "force_identity_swizzle",
-                                                     Category::RendererAdvanced};
-
     SwitchableSetting<bool> renderer_force_max_clock{linkage, false, "force_max_clock",
                                                      Category::RendererAdvanced};
 
@@ -616,60 +608,6 @@ struct Values {
 #endif
                                                        "vertex_input_dynamic_state", Category::RendererExtensions};
 
-#ifdef ANDROID
-    // Shader Float Controls (Android only) - Eden Veil / Extensions
-    // Force enable VK_KHR_shader_float_controls even if driver has known issues
-    // Allows fine-tuning float behavior to match Switch/Maxwell or optimize performance
-    SwitchableSetting<bool> shader_float_controls_force_enable{linkage,
-                                                               false,
-                                                               "shader_float_controls_force_enable",
-                                                               Category::RendererExtensions,
-                                                               Specialization::Paired};
-
-    // Individual float behavior controls (visible only when force_enable is true)
-    // Multiple can be active simultaneously EXCEPT FTZ and DenormPreserve (mutually exclusive)
-    //
-    // Recommended configurations:
-    //   Switch-native: FTZ=ON, RTE=ON, SignedZero=ON (matches Maxwell behavior)
-    //   Performance:   FTZ=ON only (fastest)
-    //   Accuracy:      DenormPreserve=ON, RTE=ON, SignedZero=ON (slowest, highest precision)
-    SwitchableSetting<bool> shader_float_ftz{linkage,
-                                             false,
-                                             "shader_float_ftz",
-                                             Category::RendererExtensions,
-                                             Specialization::Default,
-                                             true,
-                                             false,
-                                             &shader_float_controls_force_enable};
-
-    SwitchableSetting<bool> shader_float_denorm_preserve{linkage,
-                                                         false,
-                                                         "shader_float_denorm_preserve",
-                                                         Category::RendererExtensions,
-                                                         Specialization::Default,
-                                                         true,
-                                                         false,
-                                                         &shader_float_controls_force_enable};
-
-    SwitchableSetting<bool> shader_float_rte{linkage,
-                                             false,
-                                             "shader_float_rte",
-                                             Category::RendererExtensions,
-                                             Specialization::Default,
-                                             true,
-                                             false,
-                                             &shader_float_controls_force_enable};
-
-    SwitchableSetting<bool> shader_float_signed_zero_inf_nan{linkage,
-                                                             false,
-                                                             "shader_float_signed_zero_inf_nan",
-                                                             Category::RendererExtensions,
-                                                             Specialization::Default,
-                                                             true,
-                                                             false,
-                                                             &shader_float_controls_force_enable};
-#endif
-
     Setting<bool> renderer_debug{linkage, false, "debug", Category::RendererDebug};
     Setting<bool> renderer_shader_feedback{linkage, false, "shader_feedback",
                                            Category::RendererDebug};

src/common/settings_enums.h

@@ -158,17 +158,6 @@ ENUM(ExtendedDynamicState, Disabled, EDS1, EDS2, EDS3);
 ENUM(GpuLogLevel, Off, Errors, Standard, Verbose, All)
 ENUM(GameListMode, TreeView, GridView);
 ENUM(SpeedMode, Standard, Turbo, Slow);
-ENUM(FormatReinterpretation, Disabled, R32UintToR32Sfloat, R32SintToR32Uint, R32SfloatToR32Sint)
-
-// Shader Float Controls behavior modes
-// These control how floating-point denormals and special values are handled in shaders
-ENUM(ShaderFloatBehavior,
-     DriverDefault,        // Let driver choose (safest, may not match Switch behavior)
-     SwitchNative,         // Emulate Switch/Maxwell behavior (FTZ + RTE + SignedZero)
-     FlushToZero,          // FTZ only - flush denorms to zero (fastest, some precision loss)
-     PreserveDenorms,      // Preserve denorms (slowest, highest precision)
-     RoundToEven,          // RTE rounding mode (IEEE 754 compliant)
-     SignedZeroInfNan);    // Preserve signed zero, inf, nan (accuracy for edge cases)
 
 template <typename Type>
 inline std::string_view CanonicalizeEnum(Type id) {

src/common/virtual_buffer.h

@@ -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
 
@@ -21,7 +24,9 @@ public:
     //     "with the current allocator");
 
     constexpr VirtualBuffer() = default;
-    explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
+    explicit VirtualBuffer(std::size_t count) noexcept
+        : alloc_size{count * sizeof(T)}
+    {
         base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
     }
 
@@ -33,8 +38,8 @@ public:
     VirtualBuffer& operator=(const VirtualBuffer&) = delete;
 
     VirtualBuffer(VirtualBuffer&& other) noexcept
-        : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
-                                                                   nullptr} {}
+        : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr), nullptr}
+    {}
 
     VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
         alloc_size = std::exchange(other.alloc_size, 0);
@@ -42,35 +47,31 @@ public:
         return *this;
     }
 
-    void resize(std::size_t count) {
-        const auto new_size = count * sizeof(T);
-        if (new_size == alloc_size) {
-            return;
+    void resize(std::size_t count) noexcept {
+        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
+            FreeMemoryPages(base_ptr, alloc_size);
+            alloc_size = new_size;
+            base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
         }
-
-        FreeMemoryPages(base_ptr, alloc_size);
-
-        alloc_size = new_size;
-        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
     }
 
-    [[nodiscard]] constexpr const T& operator[](std::size_t index) const {
+    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
         return base_ptr[index];
     }
 
-    [[nodiscard]] constexpr T& operator[](std::size_t index) {
+    [[nodiscard]] constexpr T& operator[](std::size_t index) noexcept {
         return base_ptr[index];
     }
 
-    [[nodiscard]] constexpr T* data() {
+    [[nodiscard]] constexpr T* data() noexcept {
         return base_ptr;
     }
 
-    [[nodiscard]] constexpr const T* data() const {
+    [[nodiscard]] constexpr const T* data() const noexcept {
         return base_ptr;
     }
 
-    [[nodiscard]] constexpr std::size_t size() const {
+    [[nodiscard]] constexpr std::size_t size() const noexcept {
         return alloc_size / sizeof(T);
     }
 

src/core/debugger/gdbstub_arch.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -283,7 +283,7 @@ std::string_view GDBStubA32::GetTargetXML() const {
     <reg name="r11" bitsize="32" type="uint32"/>
     <reg name="r12" bitsize="32" type="uint32"/>
     <reg name="sp" bitsize="32" type="data_ptr"/>
-    <reg name="lr" bitsize="32" type="code_ptr"/>
+    <reg name="lr" bitsize="32"/>
     <reg name="pc" bitsize="32" type="code_ptr"/>
     <!-- The CPSR is register 25, rather than register 16, because
          the FPA registers historically were placed between the PC

src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -109,7 +109,7 @@ Result AesCtrCounterExtendedStorage::GetEntryList(Entry* out_entries, s32* out_e
     R_UNLESS(out_entries != nullptr || entry_count == 0, ResultNullptrArgument);
 
     // Check that our range is valid.
-    BucketTree::Offsets table_offsets;
+    BucketTree::Offsets table_offsets{};
     R_TRY(m_table.GetOffsets(std::addressof(table_offsets)));
 
     R_UNLESS(table_offsets.IsInclude(offset, size), ResultOutOfRange);
@@ -167,7 +167,7 @@ size_t AesCtrCounterExtendedStorage::Read(u8* buffer, size_t size, size_t offset
     ASSERT(Common::IsAligned(offset, BlockSize));
     ASSERT(Common::IsAligned(size, BlockSize));
 
-    BucketTree::Offsets table_offsets;
+    BucketTree::Offsets table_offsets{};
     ASSERT(R_SUCCEEDED(m_table.GetOffsets(std::addressof(table_offsets))));
 
     ASSERT(table_offsets.IsInclude(offset, size));

src/core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -89,7 +92,7 @@ public:
     virtual size_t Read(u8* buffer, size_t size, size_t offset) const override;
 
     virtual size_t GetSize() const override {
-        BucketTree::Offsets offsets;
+        BucketTree::Offsets offsets{};
         ASSERT(R_SUCCEEDED(m_table.GetOffsets(std::addressof(offsets))));
 
         return offsets.end_offset;

src/core/file_sys/fssystem/fssystem_bucket_tree.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -270,7 +270,7 @@ Result BucketTree::Find(Visitor* visitor, s64 virtual_address) {
     R_UNLESS(virtual_address >= 0, ResultInvalidOffset);
     R_UNLESS(!this->IsEmpty(), ResultOutOfRange);
 
-    BucketTree::Offsets offsets;
+    BucketTree::Offsets offsets{};
     R_TRY(this->GetOffsets(std::addressof(offsets)));
 
     R_TRY(visitor->Initialize(this, offsets));

src/core/file_sys/fssystem/fssystem_compressed_storage.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -125,7 +125,7 @@ private:
             }
 
             // Get the table offsets.
-            BucketTree::Offsets table_offsets;
+            BucketTree::Offsets table_offsets{};
             R_TRY(m_table.GetOffsets(std::addressof(table_offsets)));
 
             // Validate arguments.
@@ -177,7 +177,7 @@ private:
             ASSERT(out != nullptr);
 
             // Get our table offsets.
-            BucketTree::Offsets offsets;
+            BucketTree::Offsets offsets{};
             R_TRY(m_table.GetOffsets(std::addressof(offsets)));
 
             // Set the output.
@@ -195,7 +195,7 @@ private:
             R_SUCCEED_IF(size == 0);
 
             // Get the table offsets.
-            BucketTree::Offsets table_offsets;
+            BucketTree::Offsets table_offsets{};
             R_TRY(m_table.GetOffsets(std::addressof(table_offsets)));
 
             // Validate arguments.

src/core/file_sys/fssystem/fssystem_indirect_storage.cpp

@@ -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
 
@@ -52,7 +55,7 @@ Result IndirectStorage::GetEntryList(Entry* out_entries, s32* out_entry_count, s
     R_UNLESS(out_entries != nullptr || entry_count == 0, ResultNullptrArgument);
 
     // Check that our range is valid.
-    BucketTree::Offsets table_offsets;
+    BucketTree::Offsets table_offsets{};
     R_TRY(m_table.GetOffsets(std::addressof(table_offsets)));
 
     R_UNLESS(table_offsets.IsInclude(offset, size), ResultOutOfRange);

src/core/file_sys/fssystem/fssystem_indirect_storage.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -164,7 +167,7 @@ Result IndirectStorage::OperatePerEntry(s64 offset, s64 size, F func) {
     R_SUCCEED_IF(size == 0);
 
     // Get the table offsets.
-    BucketTree::Offsets table_offsets;
+    BucketTree::Offsets table_offsets{};
     R_TRY(m_table.GetOffsets(std::addressof(table_offsets)));
 
     // Validate arguments.

src/core/file_sys/fssystem/fssystem_sparse_storage.cpp

@@ -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
 
@@ -18,7 +21,7 @@ size_t SparseStorage::Read(u8* buffer, size_t size, size_t offset) const {
     SparseStorage* self = const_cast<SparseStorage*>(this);
 
     if (self->GetEntryTable().IsEmpty()) {
-        BucketTree::Offsets table_offsets;
+        BucketTree::Offsets table_offsets{};
         ASSERT(R_SUCCEEDED(self->GetEntryTable().GetOffsets(std::addressof(table_offsets))));
         ASSERT(table_offsets.IsInclude(offset, size));
 

src/core/hle/kernel/k_page_table_base.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -191,8 +191,7 @@ Result KPageTableBase::InitializeForKernel(bool is_64_bit, KVirtualAddress start
     m_cached_physical_heap_region = nullptr;
 
     // Initialize our implementation.
-    m_impl = std::make_unique<Common::PageTable>();
-    m_impl->Resize(m_address_space_width, PageBits);
+    m_impl.Resize(m_address_space_width, PageBits);
 
     // Set the tracking memory.
     m_memory = std::addressof(memory);
@@ -202,13 +201,7 @@ Result KPageTableBase::InitializeForKernel(bool is_64_bit, KVirtualAddress start
                                                m_memory_block_slab_manager));
 }
 
-Result KPageTableBase::InitializeForProcess(Svc::CreateProcessFlag as_type, bool enable_aslr,
-                                            bool enable_das_merge, bool from_back,
-                                            KMemoryManager::Pool pool, KProcessAddress code_address,
-                                            size_t code_size, KSystemResource* system_resource,
-                                            KResourceLimit* resource_limit,
-                                            Core::Memory::Memory& memory,
-                                            KProcessAddress aslr_space_start) {
+Result KPageTableBase::InitializeForProcess(Svc::CreateProcessFlag as_type, bool enable_aslr, bool enable_das_merge, bool from_back, KMemoryManager::Pool pool, KProcessAddress code_address, size_t code_size, KSystemResource* system_resource, KResourceLimit* resource_limit, Core::Memory::Memory& memory, KProcessAddress aslr_space_start) {
     // Calculate region extents.
     const size_t as_width = GetAddressSpaceWidth(as_type);
     const KProcessAddress start = 0;
@@ -319,14 +312,10 @@ Result KPageTableBase::InitializeForProcess(Svc::CreateProcessFlag as_type, bool
     // Determine random placements for each region.
     size_t alias_rnd = 0, heap_rnd = 0, stack_rnd = 0, kmap_rnd = 0;
     if (enable_aslr) {
-        alias_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) *
-                    RegionAlignment;
-        heap_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) *
-                   RegionAlignment;
-        stack_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) *
-                    RegionAlignment;
-        kmap_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) *
-                   RegionAlignment;
+        alias_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
+        heap_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
+        stack_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
+        kmap_rnd = KSystemControl::GenerateRandomRange(0, remaining_size / RegionAlignment) * RegionAlignment;
     }
 
     // Setup heap and alias regions.
@@ -445,15 +434,13 @@ Result KPageTableBase::InitializeForProcess(Svc::CreateProcessFlag as_type, bool
     ASSERT(heap_last < kmap_start || kmap_last < heap_start);
 
     // Initialize our implementation.
-    m_impl = std::make_unique<Common::PageTable>();
-    m_impl->Resize(m_address_space_width, PageBits);
+    m_impl.Resize(m_address_space_width, PageBits);
 
     // Set the tracking memory.
     m_memory = std::addressof(memory);
 
     // Initialize our memory block manager.
-    R_RETURN(m_memory_block_manager.Initialize(m_address_space_start, m_address_space_end,
-                                               m_memory_block_slab_manager));
+    R_RETURN(m_memory_block_manager.Initialize(m_address_space_start, m_address_space_end, m_memory_block_slab_manager));
 }
 
 Result KPageTableBase::FinalizeProcess() {
@@ -476,7 +463,7 @@ void KPageTableBase::Finalize() {
     this->FinalizeProcess();
 
     auto BlockCallback = [&](KProcessAddress addr, u64 size) {
-        if (m_impl->fastmem_arena) {
+        if (m_impl.fastmem_arena) {
             m_system.DeviceMemory().buffer.Unmap(GetInteger(addr), size, false);
         }
 
@@ -514,9 +501,6 @@ void KPageTableBase::Finalize() {
         m_resource_limit->Release(Svc::LimitableResource::PhysicalMemoryMax,
                                   m_mapped_ipc_server_memory);
     }
-
-    // Close the backing page table, as the destructor is not called for guest objects.
-    m_impl.reset();
 }
 
 KProcessAddress KPageTableBase::GetRegionAddress(Svc::MemoryState state) const {
@@ -2349,7 +2333,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            m_impl->BeginTraversal(std::addressof(next_entry), std::addressof(context), virt_addr);
+            m_impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), virt_addr);
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         // Set tracking variables.
@@ -2360,7 +2344,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         while (true) {
             // Continue the traversal.
             traverse_valid =
-                m_impl->ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                m_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             if (!traverse_valid) {
                 break;
             }
@@ -5730,14 +5714,14 @@ Result KPageTableBase::Operate(PageLinkedList* page_list, KProcessAddress virt_a
         this->MakePageGroup(pages_to_close, virt_addr, num_pages);
 
         // Unmap.
-        m_memory->UnmapRegion(*m_impl, virt_addr, num_pages * PageSize, separate_heap);
+        m_memory->UnmapRegion(m_impl, virt_addr, num_pages * PageSize, separate_heap);
 
         R_SUCCEED();
     }
     case OperationType::Map: {
         ASSERT(virt_addr != 0);
         ASSERT(Common::IsAligned(GetInteger(virt_addr), PageSize));
-        m_memory->MapMemoryRegion(*m_impl, virt_addr, num_pages * PageSize, phys_addr,
+        m_memory->MapMemoryRegion(m_impl, virt_addr, num_pages * PageSize, phys_addr,
                                   ConvertToMemoryPermission(properties.perm), false);
 
         // Open references to pages, if we should.
@@ -5754,7 +5738,7 @@ Result KPageTableBase::Operate(PageLinkedList* page_list, KProcessAddress virt_a
     case OperationType::ChangePermissions:
     case OperationType::ChangePermissionsAndRefresh:
     case OperationType::ChangePermissionsAndRefreshAndFlush: {
-        m_memory->ProtectRegion(*m_impl, virt_addr, num_pages * PageSize,
+        m_memory->ProtectRegion(m_impl, virt_addr, num_pages * PageSize,
                                 ConvertToMemoryPermission(properties.perm));
         R_SUCCEED();
     }
@@ -5788,7 +5772,7 @@ Result KPageTableBase::Operate(PageLinkedList* page_list, KProcessAddress virt_a
             const size_t size{node.GetNumPages() * PageSize};
 
             // Map the pages.
-            m_memory->MapMemoryRegion(*m_impl, virt_addr, size, node.GetAddress(),
+            m_memory->MapMemoryRegion(m_impl, virt_addr, size, node.GetAddress(),
                                       ConvertToMemoryPermission(properties.perm), separate_heap);
 
             virt_addr += size;

src/core/hle/kernel/k_page_table_base.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -215,7 +215,7 @@ private:
     mutable KLightLock m_general_lock;
     mutable KLightLock m_map_physical_memory_lock;
     KLightLock m_device_map_lock;
-    std::unique_ptr<Common::PageTable> m_impl{};
+    Common::PageTable m_impl{};
     Core::Memory::Memory* m_memory{};
     KMemoryBlockManager m_memory_block_manager{};
     u32 m_allocate_option{};
@@ -300,26 +300,11 @@ public:
     }
 
 public:
-    Core::Memory::Memory& GetMemory() {
-        return *m_memory;
-    }
-
-    Core::Memory::Memory& GetMemory() const {
-        return *m_memory;
-    }
-
-    Common::PageTable& GetImpl() {
-        return *m_impl;
-    }
-
-    Common::PageTable& GetImpl() const {
-        return *m_impl;
-    }
-
-    size_t GetNumGuardPages() const {
-        return this->IsKernel() ? 1 : 4;
-    }
-
+    [[nodiscard]] Core::Memory::Memory& GetMemory() noexcept { return *m_memory; }
+    [[nodiscard]] Core::Memory::Memory const& GetMemory() const noexcept { return *m_memory; }
+    [[nodiscard]] Common::PageTable& GetImpl() noexcept { return m_impl; }
+    [[nodiscard]] Common::PageTable const& GetImpl() const noexcept { return m_impl; }
+    [[nodiscard]] size_t GetNumGuardPages() const noexcept { return this->IsKernel() ? 1 : 4; }
 protected:
     // NOTE: These three functions (Operate, Operate, FinalizeUpdate) are virtual functions
     // in Nintendo's kernel. We devirtualize them, since KPageTable is the only derived

src/core/hle/kernel/k_process_page_table.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -33,21 +33,10 @@ public:
         m_page_table.Finalize();
     }
 
-    Core::Memory::Memory& GetMemory() {
-        return m_page_table.GetMemory();
-    }
-
-    Core::Memory::Memory& GetMemory() const {
-        return m_page_table.GetMemory();
-    }
-
-    Common::PageTable& GetImpl() {
-        return m_page_table.GetImpl();
-    }
-
-    Common::PageTable& GetImpl() const {
-        return m_page_table.GetImpl();
-    }
+    [[nodiscard]] Core::Memory::Memory& GetMemory() noexcept { return m_page_table.GetMemory(); }
+    [[nodiscard]] Core::Memory::Memory const& GetMemory() const noexcept { return m_page_table.GetMemory(); }
+    [[nodiscard]] Common::PageTable& GetImpl() noexcept { return m_page_table.GetImpl(); }
+    [[nodiscard]] Common::PageTable const& GetImpl() const noexcept { return m_page_table.GetImpl(); }
 
     size_t GetNumGuardPages() const {
         return m_page_table.GetNumGuardPages();

src/core/hle/kernel/physical_core.cpp

@@ -50,6 +50,14 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) {
     };
 
     const auto ExitContext = [&]() {
+        // Save the JIT context back to the thread so the debugger can
+        // read the current register state. Debug halt paths (step,
+        // breakpoint, watchpoint) return from RunThread without going
+        // through the scheduler's Unload/SaveContext.
+        if (system.DebuggerEnabled()) {
+            interface->GetContext(thread->GetContext());
+        }
+
         // Unlock the thread.
         interface->UnlockThread(thread);
 
@@ -97,11 +105,16 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) {
         }
 
         // Determine why we stopped.
-        const bool supervisor_call = True(hr & Core::HaltReason::SupervisorCall);
-        const bool prefetch_abort = True(hr & Core::HaltReason::PrefetchAbort);
-        const bool breakpoint = True(hr & Core::HaltReason::InstructionBreakpoint);
-        const bool data_abort = True(hr & Core::HaltReason::DataAbort);
-        const bool interrupt = True(hr & Core::HaltReason::BreakLoop);
+        // If a step completed successfully, skip other halt reason handlers —
+        // the step takes priority (e.g. step may also set InstructionBreakpoint
+        // if the next instruction happens to be a breakpoint).
+        const bool step_completed = True(hr & Core::HaltReason::StepThread)
+                                    && thread->GetStepState() == StepState::StepPerformed;
+        const bool supervisor_call = !step_completed && True(hr & Core::HaltReason::SupervisorCall);
+        const bool prefetch_abort = !step_completed && True(hr & Core::HaltReason::PrefetchAbort);
+        const bool breakpoint = !step_completed && True(hr & Core::HaltReason::InstructionBreakpoint);
+        const bool data_abort = !step_completed && True(hr & Core::HaltReason::DataAbort);
+        const bool interrupt = !step_completed && True(hr & Core::HaltReason::BreakLoop);
 
         // Since scheduling may occur here, we cannot use any cached
         // state after returning from calls we make.
@@ -111,6 +124,11 @@ void PhysicalCore::RunThread(Kernel::KThread* thread) {
         if (breakpoint || prefetch_abort) {
             if (breakpoint) {
                 interface->RewindBreakpointInstruction();
+                // RewindBreakpointInstruction sets the JIT state to the
+                // saved breakpoint context. Update the thread context to
+                // match, since ExitContext already saved the post-execution
+                // state.
+                interface->GetContext(thread->GetContext());
             }
             if (system.DebuggerEnabled()) {
                 system.GetDebugger().NotifyThreadStopped(thread);

src/core/hle/service/bcat/news/builtin_news.cpp

@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+#include "common/net/net.h"
+#include "common/scm_rev.h"
 #include "core/hle/service/bcat/news/builtin_news.h"
 #include "core/hle/service/bcat/news/msgpack.h"
 #include "core/hle/service/bcat/news/news_storage.h"
@@ -22,10 +24,8 @@
 #include <filesystem>
 #include <fstream>
 #include <future>
-#include <iomanip>
 #include <mutex>
 #include <optional>
-#include <sstream>
 #include <thread>
 
 #ifdef YUZU_BUNDLED_OPENSSL
@@ -35,9 +35,6 @@
 namespace Service::News {
 namespace {
 
-// TODO(crueter): COMPILE DEFINITION
-constexpr const char* GitHubAPI_EdenReleases = "/api/v1/repos/eden-emu/eden/releases";
-
 // Cached logo data
 std::vector<u8> default_logo_small;
 std::vector<u8> default_logo_large;
@@ -66,24 +63,6 @@ u32 HashToNewsId(std::string_view key) {
     return static_cast<u32>(std::hash<std::string_view>{}(key) & 0x7FFFFFFF);
 }
 
-u64 ParseIsoTimestamp(const std::string& iso) {
-    if (iso.empty()) return 0;
-
-    std::string buf = iso;
-    if (buf.back() == 'Z') buf.pop_back();
-
-    std::tm tm{};
-    std::istringstream ss(buf);
-    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
-    if (ss.fail()) return 0;
-
-#ifdef _WIN32
-    return static_cast<u64>(_mkgmtime(&tm));
-#else
-    return static_cast<u64>(timegm(&tm));
-#endif
-}
-
 std::vector<u8> TryLoadFromDisk(const std::filesystem::path& path) {
     if (!std::filesystem::exists(path)) return {};
 
@@ -100,8 +79,9 @@ std::vector<u8> TryLoadFromDisk(const std::filesystem::path& path) {
     return data;
 }
 
+// TODO(crueter): Migrate to use Common::Net
 std::vector<u8> DownloadImage(const std::string& url_path, const std::filesystem::path& cache_path) {
-    LOG_INFO(Service_BCAT, "Downloading image: https://eden-emu.dev{}", url_path);
+    LOG_DEBUG(Service_BCAT, "Downloading image: https://eden-emu.dev{}", url_path);
     try {
         httplib::Client cli("https://eden-emu.dev");
         cli.set_follow_location(true);
@@ -226,67 +206,6 @@ void WriteCachedJson(std::string_view json) {
     (void)Common::FS::WriteStringToFile(path, Common::FS::FileType::TextFile, json);
 }
 
-std::optional<std::string> DownloadReleasesJson() {
-    try {
-#ifdef YUZU_BUNDLED_OPENSSL
-        const auto url = "https://git.eden-emu.dev";
-#else
-        const auto url = "git.eden-emu.dev";
-#endif
-
-        // TODO(crueter): This is duplicated between frontend and here.
-        constexpr auto path = GitHubAPI_EdenReleases;
-
-        constexpr std::size_t timeout_seconds = 15;
-
-        std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(url);
-        client->set_connection_timeout(timeout_seconds);
-        client->set_read_timeout(timeout_seconds);
-        client->set_write_timeout(timeout_seconds);
-
-#ifdef YUZU_BUNDLED_OPENSSL
-        client->load_ca_cert_store(kCert, sizeof(kCert));
-#endif
-
-        if (client == nullptr) {
-            LOG_ERROR(Service_BCAT, "Invalid URL {}{}", url, path);
-            return {};
-        }
-
-        httplib::Request request{
-            .method = "GET",
-            .path = path,
-        };
-
-        client->set_follow_location(true);
-        httplib::Result result = client->send(request);
-
-        if (!result) {
-            LOG_ERROR(Service_BCAT, "GET to {}{} returned null", url, path);
-            return {};
-        } else if (result->status < 400) {
-            return result->body;
-        }
-
-        if (result->status >= 400) {
-            LOG_ERROR(Service_BCAT,
-                      "GET to {}{} returned error status code: {}",
-                      url,
-                      path,
-                      result->status);
-            return {};
-        }
-
-        if (!result->headers.contains("content-type")) {
-            LOG_ERROR(Service_BCAT, "GET to {}{} returned no content", url, path);
-            return {};
-        }
-    } catch (...) {
-        LOG_WARNING(Service_BCAT, " failed to download releases");
-    }
-    return std::nullopt;
-}
-
 // idk but News App does not render Markdown or HTML, so remove some formatting.
 std::string SanitizeMarkdown(std::string_view markdown) {
     std::string result;
@@ -342,9 +261,7 @@ std::string SanitizeMarkdown(std::string_view markdown) {
     return text;
 }
 
-std::string FormatBody(const nlohmann::json& release, std::string_view title) {
-    std::string body = release.value("body", std::string{});
-
+std::string FormatBody(std::string body, const std::string_view &title) {
     if (body.empty()) {
         return std::string(title);
     }
@@ -375,52 +292,32 @@ std::string FormatBody(const nlohmann::json& release, std::string_view title) {
     return body;
 }
 
-void ImportReleases(std::string_view json_text) {
-    nlohmann::json root;
-    try {
-        root = nlohmann::json::parse(json_text);
-    } catch (...) {
-        LOG_WARNING(Service_BCAT, "failed to parse JSON");
-        return;
-    }
-
-    if (!root.is_array()) return;
-
+void ImportReleases(const std::vector<Common::Net::Release> &releases) {
     std::vector<u32> news_ids;
-    for (const auto& rel : root) {
-        if (!rel.is_object()) continue;
-        std::string title = rel.value("name", rel.value("tag_name", std::string{}));
-        if (title.empty()) continue;
-
-        const u64 release_id = rel.value("id", 0);
-        const u32 news_id = release_id ? static_cast<u32>(release_id & 0x7FFFFFFF) : HashToNewsId(title);
+    for (const auto& rel : releases) {
+        const u32 news_id = u32(rel.id & 0x7FFFFFFF);
         news_ids.push_back(news_id);
     }
 
     PreloadNewsImages(news_ids);
 
-    for (const auto& rel : root) {
-        if (!rel.is_object()) continue;
+    for (const auto& rel : releases) {
+        const std::string title = rel.title;
+        const std::string body = rel.body;
+        const std::string html_url = rel.html_url;
 
-        std::string title = rel.value("name", rel.value("tag_name", std::string{}));
-        if (title.empty()) continue;
-
-        const u64 release_id = rel.value("id", 0);
-        const u32 news_id = release_id ? static_cast<u32>(release_id & 0x7FFFFFFF) : HashToNewsId(title);
-        const u64 published = ParseIsoTimestamp(rel.value("published_at", std::string{}));
+        const u32 news_id = u32(rel.id & 0x7FFFFFFF);
+        const u64 published = rel.published;
         const u64 pickup_limit = published + 600000000;
-        const u32 priority = rel.value("prerelease", false) ? 1500 : 2500;
+        const u32 priority = rel.prerelease ? 1500 : 2500;
 
-        std::string author = "eden";
-        if (rel.contains("author") && rel["author"].is_object()) {
-            author = rel["author"].value("login", "eden");
-        }
+        std::string author = "Eden";
 
-        auto payload = BuildMsgpack(title, FormatBody(rel, title), title, published,
+        auto payload = BuildMsgpack(title, FormatBody(body, title), title, published,
                                     pickup_limit, priority, {"en"}, author, {},
-                                    rel.value("html_url", std::string{}), news_id);
+                                    html_url, news_id);
 
-        const std::string news_id_str = fmt::format("LA{:020}", news_id);
+        const std::string news_id_str = fmt::format("LA{:020}", rel.id);
 
         GithubNewsMeta meta{
             .news_id = news_id_str,
@@ -565,15 +462,21 @@ void EnsureBuiltinNewsLoaded() {
         LoadDefaultLogos();
 
         if (const auto cached = ReadCachedJson()) {
-            ImportReleases(*cached);
-            LOG_DEBUG(Service_BCAT, "news: {} entries loaded from cache", NewsStorage::Instance().ListAll().size());
+            const std::string_view body = cached.value();
+            const auto releases = Common::Net::Release::ListFromJson(body, Common::g_build_auto_update_stable_api, Common::g_build_auto_update_stable_repo);
+            ImportReleases(releases);
+
+            LOG_INFO(Service_BCAT, "news: {} entries loaded from cache", NewsStorage::Instance().ListAll().size());
         }
 
         std::thread([] {
-            if (const auto fresh = DownloadReleasesJson()) {
-                WriteCachedJson(*fresh);
-                ImportReleases(*fresh);
-                LOG_DEBUG(Service_BCAT, "news: {} entries updated from Forgejo", NewsStorage::Instance().ListAll().size());
+            if (const auto fresh = Common::Net::GetReleasesBody()) {
+                const std::string_view body = fresh.value();
+                WriteCachedJson(body);
+                const auto releases = Common::Net::Release::ListFromJson(body, Common::g_build_auto_update_stable_api, Common::g_build_auto_update_stable_repo);
+                ImportReleases(releases);
+
+                LOG_INFO(Service_BCAT, "news: {} entries updated from Forgejo", NewsStorage::Instance().ListAll().size());
             }
         }).detach();
     });

src/core/hle/service/hle_ipc.cpp

@@ -396,24 +396,6 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
     const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
                            BufferDescriptorB()[buffer_index].Size()};
     const std::size_t buffer_size{GetWriteBufferSize(buffer_index)};
-
-    // Defensive check: if client didn't provide output buffer, log detailed error but don't crash
-    if (buffer_size == 0) {
-        LOG_ERROR(Core,
-                  "WriteBuffer called but client provided NO output buffer! "
-                  "Requested size: 0x{:X}, buffer_index: {}, is_buffer_b: {}, "
-                  "BufferB count: {}, BufferC count: {}",
-                  size, buffer_index, is_buffer_b, BufferDescriptorB().size(),
-                  BufferDescriptorC().size());
-
-        // Log command context for debugging
-        LOG_ERROR(Core, "IPC Command: 0x{:X}, Type: {}", GetCommand(),
-                  static_cast<u32>(GetCommandType()));
-
-        // Return 0 instead of crashing - let service handle error
-        return 0;
-    }
-
     if (size > buffer_size) {
         LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
                      buffer_size);

src/core/hle/service/nvdrv/core/nvmap.cpp

@@ -89,7 +89,7 @@ void NvMap::UnmapHandle(Handle& handle_description) {
 
     // Free and unmap the handle from Host1x GMMU
     if (handle_description.pin_virt_address) {
-        host1x.GMMU().Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
+        host1x.gmmu_manager.Unmap(static_cast<GPUVAddr>(handle_description.pin_virt_address),
                             handle_description.aligned_size);
         host1x.Allocator().Free(handle_description.pin_virt_address,
                                 static_cast<u32>(handle_description.aligned_size));
@@ -169,12 +169,8 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
     std::scoped_lock lock(handle_description->mutex);
     const auto map_low_area = [&] {
         if (handle_description->pin_virt_address == 0) {
-            auto& gmmu_allocator = host1x.Allocator();
-            auto& gmmu = host1x.GMMU();
-            u32 address =
-                gmmu_allocator.Allocate(static_cast<u32>(handle_description->aligned_size));
-            gmmu.Map(static_cast<GPUVAddr>(address), handle_description->d_address,
-                     handle_description->aligned_size);
+            u32 address = host1x.Allocator().Allocate(u32(handle_description->aligned_size));
+            host1x.gmmu_manager.Map(GPUVAddr(address), handle_description->d_address, handle_description->aligned_size);
             handle_description->pin_virt_address = address;
         }
     };

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -10,6 +10,7 @@
 
 #include "common/alignment.h"
 #include "common/assert.h"
+#include "common/common_types.h"
 #include "common/logging.h"
 #include "core/core.h"
 #include "core/hle/service/nvdrv/core/container.h"
@@ -130,12 +131,12 @@ NvResult nvhost_as_gpu::AllocAsEx(IoctlAllocAsEx& params) {
 
     const auto start_pages{static_cast<u32>(vm.va_range_start >> VM::PAGE_SIZE_BITS)};
     const auto end_pages{static_cast<u32>(vm.va_range_split >> VM::PAGE_SIZE_BITS)};
-    vm.small_page_allocator = std::make_shared<VM::Allocator>(start_pages, end_pages);
+    vm.small_page_allocator.emplace(start_pages, end_pages);
 
     const auto start_big_pages{static_cast<u32>(vm.va_range_split >> vm.big_page_size_bits)};
     const auto end_big_pages{
         static_cast<u32>((vm.va_range_end - vm.va_range_split) >> vm.big_page_size_bits)};
-    vm.big_page_allocator = std::make_unique<VM::Allocator>(start_big_pages, end_big_pages);
+    vm.big_page_allocator.emplace(start_big_pages, end_big_pages);
 
     gmmu = std::make_shared<Tegra::MemoryManager>(system, max_big_page_bits, vm.va_range_split,
                                                   vm.big_page_size_bits, VM::PAGE_SIZE_BITS);
@@ -188,8 +189,8 @@ NvResult nvhost_as_gpu::AllocateSpace(IoctlAllocSpace& params) {
     }
 
     allocation_map[params.offset] = {
-        .size = size,
         .mappings{},
+        .size = size,
         .page_size = params.page_size,
         .sparse = (params.flags & MappingFlags::Sparse) != MappingFlags::None,
         .big_pages = params.page_size != VM::YUZU_PAGESIZE,
@@ -199,71 +200,52 @@ NvResult nvhost_as_gpu::AllocateSpace(IoctlAllocSpace& params) {
 }
 
 void nvhost_as_gpu::FreeMappingLocked(u64 offset) {
-    auto mapping{mapping_map.at(offset)};
-
-    if (!mapping->fixed) {
-        auto& allocator{mapping->big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
-        u32 page_size_bits{mapping->big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
-        u32 page_size{mapping->big_page ? vm.big_page_size : VM::YUZU_PAGESIZE};
-        u64 aligned_size{Common::AlignUp(mapping->size, page_size)};
-
-        allocator.Free(static_cast<u32>(mapping->offset >> page_size_bits),
-                       static_cast<u32>(aligned_size >> page_size_bits));
+    auto const it = mapping_map.find(offset);
+    auto const mapping = it->second;
+    if (!mapping.fixed) {
+        auto& allocator{mapping.big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
+        u32 page_size_bits{mapping.big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
+        u32 page_size{mapping.big_page ? vm.big_page_size : VM::YUZU_PAGESIZE};
+        u64 aligned_size{Common::AlignUp(mapping.size, page_size)};
+        allocator.Free(u32(mapping.offset >> page_size_bits), u32(aligned_size >> page_size_bits));
     }
-
-    nvmap.UnpinHandle(mapping->handle);
-
+    nvmap.UnpinHandle(mapping.handle);
     // Sparse mappings shouldn't be fully unmapped, just returned to their sparse state
     // Only FreeSpace can unmap them fully
-    if (mapping->sparse_alloc) {
-        gmmu->MapSparse(offset, mapping->size, mapping->big_page);
+    if (mapping.sparse_alloc) {
+        gmmu->MapSparse(offset, mapping.size, mapping.big_page);
     } else {
-        gmmu->Unmap(offset, mapping->size);
+        gmmu->Unmap(offset, mapping.size);
     }
-
-    mapping_map.erase(offset);
+    mapping_map.erase(it);
 }
 
 NvResult nvhost_as_gpu::FreeSpace(IoctlFreeSpace& params) {
-    LOG_DEBUG(Service_NVDRV, "called, offset={:X}, pages={:X}, page_size={:X}", params.offset,
-              params.pages, params.page_size);
-
+    LOG_DEBUG(Service_NVDRV, "called, offset={:X}, pages={:X}, page_size={:X}", params.offset, params.pages, params.page_size);
     std::scoped_lock lock(mutex);
-
     if (!vm.initialised) {
         return NvResult::BadValue;
     }
-
-    try {
-        auto allocation{allocation_map[params.offset]};
-
-        if (allocation.page_size != params.page_size ||
-            allocation.size != (static_cast<u64>(params.pages) * params.page_size)) {
+    if (auto const it = allocation_map.find(params.offset); it != allocation_map.end()) {
+        auto const allocation = it->second;
+        if (allocation.page_size != params.page_size || allocation.size != (u64(params.pages) * params.page_size))
             return NvResult::BadValue;
-        }
 
-        for (const auto& mapping : allocation.mappings) {
-            FreeMappingLocked(mapping->offset);
-        }
+        for (const auto mapping_offset : allocation.mappings)
+            FreeMappingLocked(mapping_offset);
 
         // Unset sparse flag if required
-        if (allocation.sparse) {
+        if (allocation.sparse)
             gmmu->Unmap(params.offset, allocation.size);
-        }
 
-        auto& allocator{params.page_size == VM::YUZU_PAGESIZE ? *vm.small_page_allocator
-                                                              : *vm.big_page_allocator};
-        u32 page_size_bits{params.page_size == VM::YUZU_PAGESIZE ? VM::PAGE_SIZE_BITS
-                                                                 : vm.big_page_size_bits};
+        auto& allocator{params.page_size == VM::YUZU_PAGESIZE ? *vm.small_page_allocator : *vm.big_page_allocator};
+        u32 page_size_bits{params.page_size == VM::YUZU_PAGESIZE ? VM::PAGE_SIZE_BITS : vm.big_page_size_bits};
 
-        allocator.Free(static_cast<u32>(params.offset >> page_size_bits),
-                       static_cast<u32>(allocation.size >> page_size_bits));
+        allocator.Free(u32(params.offset >> page_size_bits), u32(allocation.size >> page_size_bits));
         allocation_map.erase(params.offset);
-    } catch (const std::out_of_range&) {
-        return NvResult::BadValue;
+        return NvResult::Success;
     }
-
-    return NvResult::Success;
+    return NvResult::BadValue;
 }
 
 NvResult nvhost_as_gpu::Remap(std::span<IoctlRemapEntry> entries) {
@@ -327,26 +309,18 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
 
     // Remaps a subregion of an existing mapping to a different PA
     if ((params.flags & MappingFlags::Remap) != MappingFlags::None) {
-        try {
-            auto mapping{mapping_map.at(params.offset)};
-
-            if (mapping->size < params.mapping_size) {
-                LOG_WARNING(Service_NVDRV,
-                            "Cannot remap a partially mapped GPU address space region: {:#X}",
-                            params.offset);
+        if (auto const it = mapping_map.find(params.offset); it != mapping_map.end()) {
+            auto const mapping = it->second;
+            if (mapping.size < params.mapping_size) {
+                LOG_WARNING(Service_NVDRV, "Cannot remap a partially mapped GPU address space region: {:#X}", params.offset);
                 return NvResult::BadValue;
             }
-
-            u64 gpu_address{static_cast<u64>(params.offset + params.buffer_offset)};
-            VAddr device_address{mapping->ptr + params.buffer_offset};
-
-            gmmu->Map(gpu_address, device_address, params.mapping_size,
-                      static_cast<Tegra::PTEKind>(params.kind), mapping->big_page);
-
+            u64 gpu_address = u64(params.offset + params.buffer_offset);
+            VAddr device_address{mapping.ptr + params.buffer_offset};
+            gmmu->Map(gpu_address, device_address, params.mapping_size, Tegra::PTEKind(params.kind), mapping.big_page);
             return NvResult::Success;
-        } catch (const std::out_of_range&) {
-            LOG_WARNING(Service_NVDRV, "Cannot remap an unmapped GPU address space region: {:#X}",
-                        params.offset);
+        } else {
+            LOG_WARNING(Service_NVDRV, "Cannot remap an unmapped GPU address space region: {:#X}", params.offset);
             return NvResult::BadValue;
         }
     }
@@ -356,8 +330,7 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         return NvResult::BadValue;
     }
 
-    DAddr device_address{
-        static_cast<DAddr>(nvmap.PinHandle(params.handle, false) + params.buffer_offset)};
+    DAddr device_address = DAddr(nvmap.PinHandle(params.handle, false) + params.buffer_offset);
     u64 size{params.mapping_size ? params.mapping_size : handle->orig_size};
 
     bool big_page{[&]() {
@@ -381,32 +354,22 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         }
 
         const bool use_big_pages = alloc->second.big_pages && big_page;
-        gmmu->Map(params.offset, device_address, size, static_cast<Tegra::PTEKind>(params.kind),
-                  use_big_pages);
+        gmmu->Map(params.offset, device_address, size, static_cast<Tegra::PTEKind>(params.kind), use_big_pages);
 
-        auto mapping{std::make_shared<Mapping>(params.handle, device_address, params.offset, size,
-                                               true, use_big_pages, alloc->second.sparse)};
-        alloc->second.mappings.push_back(mapping);
-        mapping_map[params.offset] = mapping;
+        alloc->second.mappings.push_back(params.offset);
+        mapping_map.insert_or_assign(params.offset, Mapping(params.handle, device_address, params.offset, size, true, use_big_pages, alloc->second.sparse));
     } else {
         auto& allocator{big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
         u32 page_size{big_page ? vm.big_page_size : VM::YUZU_PAGESIZE};
         u32 page_size_bits{big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
 
-        params.offset = static_cast<u64>(allocator.Allocate(
-                            static_cast<u32>(Common::AlignUp(size, page_size) >> page_size_bits)))
-                        << page_size_bits;
+        params.offset = u64(allocator.Allocate(u32(Common::AlignUp(size, page_size) >> page_size_bits))) << page_size_bits;
         if (!params.offset) {
             ASSERT_MSG(false, "Failed to allocate free space in the GPU AS!");
             return NvResult::InsufficientMemory;
         }
-
-        gmmu->Map(params.offset, device_address, Common::AlignUp(size, page_size),
-                  static_cast<Tegra::PTEKind>(params.kind), big_page);
-
-        auto mapping{std::make_shared<Mapping>(params.handle, device_address, params.offset, size,
-                                               false, big_page, false)};
-        mapping_map[params.offset] = mapping;
+        gmmu->Map(params.offset, device_address, Common::AlignUp(size, page_size), Tegra::PTEKind(params.kind), big_page);
+        mapping_map.insert_or_assign(params.offset, Mapping(params.handle, device_address, params.offset, size, false, big_page, false));
     }
 
     map_buffer_offsets.insert(params.offset);
@@ -415,37 +378,32 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
 }
 
 NvResult nvhost_as_gpu::UnmapBuffer(IoctlUnmapBuffer& params) {
-    if (map_buffer_offsets.find(params.offset) != map_buffer_offsets.end()) {
+    std::scoped_lock lock(mutex);
+    if (auto const offset_it = map_buffer_offsets.find(params.offset); offset_it != map_buffer_offsets.end()) {
         LOG_DEBUG(Service_NVDRV, "called, offset={:#X}", params.offset);
-
-        std::scoped_lock lock(mutex);
-
         if (!vm.initialised) {
             return NvResult::BadValue;
         }
 
-        auto mapping{mapping_map.at(params.offset)};
-
-        if (!mapping->fixed) {
-            auto& allocator{mapping->big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
-            u32 page_size_bits{mapping->big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
-
-            allocator.Free(static_cast<u32>(mapping->offset >> page_size_bits),
-                           static_cast<u32>(mapping->size >> page_size_bits));
+        auto const it = mapping_map.find(params.offset);
+        auto const mapping = it->second;
+        if (!mapping.fixed) {
+            auto& allocator{mapping.big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
+            u32 page_size_bits{mapping.big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
+            allocator.Free(u32(mapping.offset >> page_size_bits), u32(mapping.size >> page_size_bits));
         }
 
         // Sparse mappings shouldn't be fully unmapped, just returned to their sparse state
         // Only FreeSpace can unmap them fully
-        if (mapping->sparse_alloc) {
-            gmmu->MapSparse(params.offset, mapping->size, mapping->big_page);
+        if (mapping.sparse_alloc) {
+            gmmu->MapSparse(params.offset, mapping.size, mapping.big_page);
         } else {
-            gmmu->Unmap(params.offset, mapping->size);
+            gmmu->Unmap(params.offset, mapping.size);
         }
 
-        nvmap.UnpinHandle(mapping->handle);
-
-        mapping_map.erase(params.offset);
-        map_buffer_offsets.erase(params.offset);
+        nvmap.UnpinHandle(mapping.handle);
+        mapping_map.erase(it);
+        map_buffer_offsets.erase(offset_it);
     }
     return NvResult::Success;
 }
@@ -478,8 +436,7 @@ void nvhost_as_gpu::GetVARegionsImpl(IoctlGetVaRegions& params) {
 }
 
 NvResult nvhost_as_gpu::GetVARegions1(IoctlGetVaRegions& params) {
-    LOG_DEBUG(Service_NVDRV, "called, buf_addr={:X}, buf_size={:X}", params.buf_addr,
-              params.buf_size);
+    LOG_DEBUG(Service_NVDRV, "called, buf_addr={:X}, buf_size={:X}", params.buf_addr, params.buf_size);
 
     std::scoped_lock lock(mutex);
 

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.h

@@ -165,35 +165,36 @@ private:
     NvCore::NvMap& nvmap;
 
     struct Mapping {
-        NvCore::NvMap::Handle::Id handle;
         DAddr ptr;
         u64 offset;
         u64 size;
-        bool fixed;
-        bool big_page; // Only valid if fixed == false
-        bool sparse_alloc;
+        NvCore::NvMap::Handle::Id handle;
+        bool fixed : 1;
+        bool big_page : 1; // Only valid if fixed == false
+        bool sparse_alloc : 1;
 
-        Mapping(NvCore::NvMap::Handle::Id handle_, DAddr ptr_, u64 offset_, u64 size_, bool fixed_,
-                bool big_page_, bool sparse_alloc_)
-            : handle(handle_), ptr(ptr_), offset(offset_), size(size_), fixed(fixed_),
-              big_page(big_page_), sparse_alloc(sparse_alloc_) {}
+        Mapping(NvCore::NvMap::Handle::Id handle_, DAddr ptr_, u64 offset_, u64 size_, bool fixed_, bool big_page_, bool sparse_alloc_)
+            : ptr(ptr_), offset(offset_), size(size_), handle(handle_)
+            , fixed(fixed_), big_page(big_page_), sparse_alloc(sparse_alloc_)
+        {}
     };
 
     struct Allocation {
+        std::vector<u64> mappings;
         u64 size;
-        std::list<std::shared_ptr<Mapping>> mappings;
         u32 page_size;
         bool sparse;
         bool big_pages;
     };
 
-    std::map<u64, std::shared_ptr<Mapping>>
-        mapping_map; //!< This maps the base addresses of mapped buffers to their total sizes and
-                     //!< mapping type, this is needed as what was originally a single buffer may
-                     //!< have been split into multiple GPU side buffers with the remap flag.
-    std::map<u64, Allocation> allocation_map; //!< Holds allocations created by AllocSpace from
-                                              //!< which fixed buffers can be mapped into
-    std::mutex mutex;                         //!< Locks all AS operations
+    //!< This maps the base addresses of mapped buffers to their total sizes and
+    //!< mapping type, this is needed as what was originally a single buffer may
+    //!< have been split into multiple GPU side buffers with the remap flag.
+    std::map<u64, Mapping> mapping_map;
+    //!< Holds allocations created by AllocSpace from
+    //!< which fixed buffers can be mapped into
+    std::map<u64, Allocation> allocation_map;
+    std::mutex mutex; //!< Locks all AS operations
 
     struct VM {
         static constexpr u32 YUZU_PAGESIZE{0x1000};
@@ -213,9 +214,8 @@ private:
 
         using Allocator = Common::FlatAllocator<u32, 0, 32>;
 
-        std::unique_ptr<Allocator> big_page_allocator;
-        std::shared_ptr<Allocator>
-            small_page_allocator; //! Shared as this is also used by nvhost::GpuChannel
+        std::optional<Allocator> big_page_allocator;
+        std::optional<Allocator> small_page_allocator; //! Shared as this is also used by nvhost::GpuChannel
 
         bool initialised{};
     } vm;

src/core/loader/deconstructed_rom_directory.cpp

@@ -228,9 +228,8 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     code_size += patch_ctx.GetTotalPatchSize();
 
     // TODO: this is bad form of ASLR, it sucks
-    size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
-        ? ::Settings::values.rng_seed.GetValue()
-        : Common::Random::Random64(0)) * 0x734287f27) & 0xfff000;
+    std::uintptr_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
+        ? ::Settings::values.rng_seed.GetValue() : Common::Random::Random64(0)) << 12) & 0xfff000;
 
     // Setup the process code layout
     if (process.LoadFromMetadata(metadata, code_size, fastmem_base, aslr_offset, is_hbl).IsError()) {

src/core/loader/kip.cpp

@@ -89,9 +89,8 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
     codeset.DataSegment().size += kip->GetBSSSize();
 
     // TODO: this is bad form of ASLR, it sucks
-    size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
-        ? ::Settings::values.rng_seed.GetValue()
-        : Common::Random::Random64(0)) * 0x734287f27) & 0xfff000;
+    std::uintptr_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
+        ? ::Settings::values.rng_seed.GetValue() : Common::Random::Random64(0)) << 12) & 0xfff000;
 
     // Setup the process code layout
     if (process.LoadFromMetadata(FileSys::ProgramMetadata::GetDefault(), codeset.memory.size(), 0, aslr_offset, false).IsError()) {

src/core/loader/nro.cpp

@@ -242,9 +242,8 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     }();
 
     // TODO: this is bad form of ASLR, it sucks
-    size_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
-        ? ::Settings::values.rng_seed.GetValue()
-        : Common::Random::Random64(0)) * 0x734287f27) & 0xfff000;
+    std::uintptr_t aslr_offset = ((::Settings::values.rng_seed_enabled.GetValue()
+        ? ::Settings::values.rng_seed.GetValue() : Common::Random::Random64(0)) << 12) & 0xfff000;
 
     // Setup the process code layout
     if (process

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector.cpp

@@ -866,10 +866,10 @@ void EmitIR<IR::Opcode::VectorMaxS32>(oaknut::CodeGenerator& code, EmitContext&
 
 template<>
 void EmitIR<IR::Opcode::VectorMaxS64>(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Inst* inst) {
-    (void)code;
-    (void)ctx;
-    (void)inst;
-    UNREACHABLE();
+    EmitThreeOp(code, ctx, inst, [&](auto& Qresult, auto& Qa, auto& Qb) {
+        code.CMGT(Qresult->D2(), Qa->D2(), Qb->D2());
+        code.BSL(Qresult->B16(), Qa->B16(), Qb->B16());
+    });
 }
 
 template<>
@@ -889,10 +889,10 @@ void EmitIR<IR::Opcode::VectorMaxU32>(oaknut::CodeGenerator& code, EmitContext&
 
 template<>
 void EmitIR<IR::Opcode::VectorMaxU64>(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Inst* inst) {
-    (void)code;
-    (void)ctx;
-    (void)inst;
-    UNREACHABLE();
+    EmitThreeOp(code, ctx, inst, [&](auto& Qresult, auto& Qa, auto& Qb) {
+        code.CMHI(Qresult->D2(), Qa->D2(), Qb->D2());
+        code.BSL(Qresult->B16(), Qa->B16(), Qb->B16());
+    });
 }
 
 template<>
@@ -912,10 +912,10 @@ void EmitIR<IR::Opcode::VectorMinS32>(oaknut::CodeGenerator& code, EmitContext&
 
 template<>
 void EmitIR<IR::Opcode::VectorMinS64>(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Inst* inst) {
-    (void)code;
-    (void)ctx;
-    (void)inst;
-    UNREACHABLE();
+    EmitThreeOp(code, ctx, inst, [&](auto& Qresult, auto& Qa, auto& Qb) {
+        code.CMGT(Qresult->D2(), Qb->D2(), Qa->D2());
+        code.BSL(Qresult->B16(), Qa->B16(), Qb->B16());
+    });
 }
 
 template<>
@@ -935,10 +935,10 @@ void EmitIR<IR::Opcode::VectorMinU32>(oaknut::CodeGenerator& code, EmitContext&
 
 template<>
 void EmitIR<IR::Opcode::VectorMinU64>(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Inst* inst) {
-    (void)code;
-    (void)ctx;
-    (void)inst;
-    UNREACHABLE();
+    EmitThreeOp(code, ctx, inst, [&](auto& Qresult, auto& Qa, auto& Qb) {
+        code.CMHI(Qresult->D2(), Qb->D2(), Qa->D2());
+        code.BSL(Qresult->B16(), Qa->B16(), Qb->B16());
+    });
 }
 
 template<>

src/dynarmic/src/dynarmic/frontend/A64/translate/impl/a64_branch.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 /* This file is part of the dynarmic project.
@@ -39,7 +39,7 @@ bool TranslatorVisitor::BL(Imm<26> imm26) {
     ir.PushRSB(ir.current_location->AdvancePC(4));
 
     const u64 target = ir.PC() + offset;
-    ir.SetTerm(IR::Term::LinkBlock{ir.current_location->SetPC(target)});
+    ir.SetTerm(IR::Term::LinkBlockFast{ir.current_location->SetPC(target)});
     return false;
 }
 

src/frontend_common/update_checker.cpp

@@ -5,146 +5,45 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#ifdef NIGHTLY_BUILD
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
+#endif
 
 #include <fmt/format.h>
-#include "common/logging.h"
+#include "common/net/net.h"
 #include "common/scm_rev.h"
 #include "update_checker.h"
 
-#include "common/httplib.h"
+#include "common/logging.h"
 
-#ifdef YUZU_BUNDLED_OPENSSL
-#include <openssl/cert.h>
-#endif
+std::optional<Common::Net::Release> UpdateChecker::GetUpdate() {
+    const auto latest = Common::Net::GetLatestRelease();
+    if (!latest) return std::nullopt;
 
-#include <nlohmann/json.hpp>
-#include <optional>
-#include <string>
+    LOG_INFO(Frontend, "Received update {}", latest->title);
 
-std::optional<std::string> UpdateChecker::GetResponse(std::string url, std::string path)
-{
-    try {
-        constexpr std::size_t timeout_seconds = 15;
+#ifdef NIGHTLY_BUILD
+    std::vector<std::string> result;
 
-        std::unique_ptr<httplib::Client> client = std::make_unique<httplib::Client>(url);
-        client->set_connection_timeout(timeout_seconds);
-        client->set_read_timeout(timeout_seconds);
-        client->set_write_timeout(timeout_seconds);
-
-#ifdef YUZU_BUNDLED_OPENSSL
-        client->load_ca_cert_store(kCert, sizeof(kCert));
-#endif
-
-        if (client == nullptr) {
-            LOG_ERROR(Frontend, "Invalid URL {}{}", url, path);
-            return {};
-        }
-
-        httplib::Request request{
-            .method = "GET",
-            .path = path,
-        };
-
-        client->set_follow_location(true);
-        httplib::Result result = client->send(request);
-
-        if (!result) {
-            LOG_ERROR(Frontend, "GET to {}{} returned null", url, path);
-            return {};
-        }
-
-        const auto &response = result.value();
-        if (response.status >= 400) {
-            LOG_ERROR(Frontend,
-                      "GET to {}{} returned error status code: {}",
-                      url,
-                      path,
-                      response.status);
-            return {};
-        }
-        if (!response.headers.contains("content-type")) {
-            LOG_ERROR(Frontend, "GET to {}{} returned no content", url, path);
-            return {};
-        }
-
-        return response.body;
-    } catch (std::exception &e) {
-        LOG_ERROR(Frontend,
-                  "GET to {}{} failed during update check: {}",
-                  url,
-                  path,
-                  e.what());
+    boost::split(result, latest->tag, boost::is_any_of("."));
+    if (result.size() != 2)
         return std::nullopt;
-    }
-}
 
-std::optional<UpdateChecker::Update> UpdateChecker::GetLatestRelease() {
-#ifdef YUZU_BUNDLED_OPENSSL
-    const auto update_check_url = fmt::format("https://{}", Common::g_build_auto_update_api);
+    const std::string tag = result[1];
+
+    boost::split(result, std::string{Common::g_build_version}, boost::is_any_of("-"));
+    if (result.empty())
+        return std::nullopt;
+
+    const std::string build = result[0];
 #else
-    const auto update_check_url = std::string{Common::g_build_auto_update_api};
+    const std::string tag = latest->tag;
+    const std::string build = Common::g_build_version;
 #endif
 
-    auto update_check_path = std::string{Common::g_build_auto_update_api_path};
-    try {
-        const auto response = UpdateChecker::GetResponse(update_check_url, update_check_path);
+    if (tag != build)
+        return latest;
 
-        if (!response)
-            return {};
-
-        const std::string latest_tag = nlohmann::json::parse(response.value()).at("tag_name");
-        const std::string latest_name = nlohmann::json::parse(response.value()).at("name");
-
-        return Update{latest_tag, latest_name};
-    } catch (nlohmann::detail::out_of_range&) {
-        LOG_ERROR(Frontend,
-                  "Parsing JSON response from {}{} failed during update check: "
-                  "nlohmann::detail::out_of_range",
-                  update_check_url,
-                  update_check_path);
-        return {};
-    } catch (nlohmann::detail::type_error&) {
-        LOG_ERROR(Frontend,
-                  "Parsing JSON response from {}{} failed during update check: "
-                  "nlohmann::detail::type_error",
-                  update_check_url,
-                  update_check_path);
-        return {};
-    }
-}
-
-std::optional<UpdateChecker::Update> UpdateChecker::GetUpdate() {
-    const std::optional<UpdateChecker::Update> latest_release_tag =
-        UpdateChecker::GetLatestRelease();
-
-    if (!latest_release_tag)
-        goto empty;
-
-    {
-        std::string tag, build;
-        if (Common::g_is_nightly_build) {
-            std::vector<std::string> result;
-
-            boost::split(result, latest_release_tag->tag, boost::is_any_of("."));
-            if (result.size() != 2)
-                goto empty;
-            tag = result[1];
-
-            boost::split(result, std::string{Common::g_build_version}, boost::is_any_of("-"));
-            if (result.empty())
-                goto empty;
-            build = result[0];
-        } else {
-            tag = latest_release_tag->tag;
-            build = Common::g_build_version;
-        }
-
-        if (tag != build)
-            return latest_release_tag.value();
-    }
-
-empty:
     return std::nullopt;
 }

src/frontend_common/update_checker.h

@@ -8,16 +8,10 @@
 #pragma once
 
 #include <optional>
-#include <string>
+#include "common/net/net.h"
 
 namespace UpdateChecker {
 
-typedef struct {
-    std::string tag;
-    std::string name;
-} Update;
+std::optional<Common::Net::Release> GetUpdate();
 
-std::optional<std::string> GetResponse(std::string url, std::string path);
-std::optional<Update> GetLatestRelease();
-std::optional<Update> GetUpdate();
 } // namespace UpdateChecker

src/hid_core/resources/npad/npad.cpp

@@ -157,11 +157,14 @@ void NPad::ControllerUpdate(Core::HID::ControllerTriggerType type, std::size_t c
             if (!controller.device->IsConnected()) {
                 return;
             }
-            auto* shared_memory = controller.shared_memory;
-            const auto& battery_level = controller.device->GetBattery();
-            shared_memory->battery_level_dual = battery_level.dual.battery_level;
-            shared_memory->battery_level_left = battery_level.left.battery_level;
-            shared_memory->battery_level_right = battery_level.right.battery_level;
+            if (auto* shared_memory = controller.shared_memory; shared_memory) {
+                const auto& battery_level = controller.device->GetBattery();
+                shared_memory->battery_level_dual = battery_level.dual.battery_level;
+                shared_memory->battery_level_left = battery_level.left.battery_level;
+                shared_memory->battery_level_right = battery_level.right.battery_level;
+            } else {
+                LOG_WARNING(Service_HID, "shared_memory is null {}", controller_idx);
+            }
             break;
         }
         default:
@@ -180,6 +183,10 @@ void NPad::InitNewlyAddedController(u64 aruid, Core::HID::NpadIdType npad_id) {
     const auto& body_colors = controller.device->GetColors();
     const auto& battery_level = controller.device->GetBattery();
     auto* shared_memory = controller.shared_memory;
+    if (!shared_memory) {
+        LOG_WARNING(Service_HID, "shared_memory is null for npad_id={}", npad_id);
+        return;
+    }
     if (controller_type == Core::HID::NpadStyleIndex::None) {
         npad_resource.SignalStyleSetUpdateEvent(aruid, npad_id);
         return;
@@ -801,7 +808,7 @@ Result NPad::DisconnectNpad(u64 aruid, Core::HID::NpadIdType npad_id) {
 
     auto* shared_memory = controller.shared_memory;
     if (!shared_memory) {
-        LOG_WARNING(Service_HID, "DisconnectNpad: shared_memory is null for npad_id={}", npad_id);
+        LOG_WARNING(Service_HID, "shared_memory is null for npad_id={}", npad_id);
         return ResultSuccess;
     }
     // Don't reset shared_memory->assignment_mode this value is persistent
@@ -1195,11 +1202,10 @@ const Core::HID::SixAxisSensorProperties& NPad::GetSixaxisProperties(
 
 AppletDetailedUiType NPad::GetAppletDetailedUiType(Core::HID::NpadIdType npad_id) {
     const auto aruid = applet_resource_holder.applet_resource->GetActiveAruid();
-    const auto& shared_memory = GetControllerFromNpadIdType(aruid, npad_id).shared_memory;
-
+    const auto* shared_memory = GetControllerFromNpadIdType(aruid, npad_id).shared_memory;
     return {
         .ui_variant = 0,
-        .footer = shared_memory->applet_footer_type,
+        .footer = shared_memory ? shared_memory->applet_footer_type : AppletFooterUiType::None,
     };
 }
 

src/qt_common/config/shared_translation.cpp

@@ -162,19 +162,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("Stretches the renderer to fit the specified aspect ratio.\nMost games only support "
               "16:9, so modifications are required to get other ratios.\nAlso controls the "
               "aspect ratio of captured screenshots."));
-    INSERT(Settings,
-           format_reinterpretation,
-           tr("Format Reinterpretation:"),
-           tr("Reinterprets certain texture formats for accuracy rendering.\nMay cause "
-              "graphical issues in some games."));
-    INSERT(Settings,
-           force_identity_swizzle,
-           tr("Force Identity Swizzle"),
-           tr("Forces identity component swizzle for storage and input attachment images. "
-              "Required by Vulkan spec. Disable only for debugging driver issues."));
-    INSERT(Settings,
-           use_disk_shader_cache,
-           tr("Use persistent pipeline cache"),
+    INSERT(Settings, use_disk_shader_cache, tr("Use persistent pipeline cache"),
            tr("Allows saving shaders to storage for faster loading on following game "
               "boots.\nDisabling it is only intended for debugging."));
     INSERT(Settings, use_asynchronous_gpu_emulation, tr("Use asynchronous GPU emulation"),
@@ -692,13 +680,6 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
                               PAIR(GameListMode, TreeView, tr("Tree View")),
                               PAIR(GameListMode, GridView, tr("Grid View")),
                           }});
-    translations->insert({Settings::EnumMetadata<Settings::FormatReinterpretation>::Index(),
-                          {
-                              PAIR(FormatReinterpretation, Disabled, tr("Disabled")),
-                              PAIR(FormatReinterpretation, R32UintToR32Sfloat, tr("R32 Uint to R32 Float")),
-                              PAIR(FormatReinterpretation, R32SintToR32Uint, tr("R32 Sint to R32 Uint")),
-                              PAIR(FormatReinterpretation, R32SfloatToR32Sint, tr("R32 Float to R32 Sint")),
-                          }});
 
 #undef PAIR
 #undef CTX_PAIR

src/qt_common/config/shared_translation.h

@@ -55,17 +55,6 @@ static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map
     {Settings::ScalingFilter::Mmpx, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "MMPX"))},
 };
 
-static const std::map<Settings::FormatReinterpretation, QString> format_reinterpretation_texts_map = {
-    {Settings::FormatReinterpretation::Disabled,
-     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Disabled"))},
-    {Settings::FormatReinterpretation::R32UintToR32Sfloat,
-     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "R32 Uint to R32 Float"))},
-    {Settings::FormatReinterpretation::R32SintToR32Uint,
-     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "R32 Sint to R32 Uint"))},
-    {Settings::FormatReinterpretation::R32SfloatToR32Sint,
-     QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "R32 Float to R32 Sint"))},
-};
-
 static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map = {
     {Settings::ConsoleMode::Docked, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Docked"))},
     {Settings::ConsoleMode::Handheld, QStringLiteral(QT_TRANSLATE_NOOP("MainWindow", "Handheld"))},

src/shader_recompiler/backend/glsl/glsl_emit_context.cpp

@@ -382,14 +382,13 @@ void EmitContext::SetupExtensions() {
     if (info.uses_int64 && profile.support_int64) {
         header += "#extension GL_ARB_gpu_shader_int64 : enable\n";
     }
-    if (info.uses_int64_bit_atomics && profile.support_gl_shader_atomic_int64) {
+    if (info.uses_int64_bit_atomics) {
         header += "#extension GL_NV_shader_atomic_int64 : enable\n";
     }
-    if (info.uses_atomic_f32_add && profile.support_gl_shader_atomic_float) {
+    if (info.uses_atomic_f32_add) {
         header += "#extension GL_NV_shader_atomic_float : enable\n";
     }
-    if ((info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max) &&
-        profile.support_gl_shader_atomic_fp16_vector) {
+    if (info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max) {
         header += "#extension GL_NV_shader_atomic_fp16_vector : enable\n";
     }
     if (info.uses_fp16) {

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -332,35 +332,19 @@ void DefineEntryPoint(const IR::Program& program, EmitContext& ctx, Id main) {
 void SetupDenormControl(const Profile& profile, const IR::Program& program, EmitContext& ctx,
                         Id main_func) {
     const Info& info{program.info};
-
-    // User-forced behavior overrides (Android Eden Veil/Extensions)
-    // When force flags are active, they take precedence over shader-declared behavior
-    const bool force_flush = profile.force_fp32_denorm_flush;
-    const bool force_preserve = profile.force_fp32_denorm_preserve;
-
-    if (force_flush && force_preserve) {
-        LOG_WARNING(Shader_SPIRV, "Both FTZ and Preserve forced simultaneously - FTZ takes precedence");
-    }
-
     if (info.uses_fp32_denorms_flush && info.uses_fp32_denorms_preserve) {
         LOG_DEBUG(Shader_SPIRV, "Fp32 denorm flush and preserve on the same shader");
-    } else if (force_flush || info.uses_fp32_denorms_flush) {
+    } else if (info.uses_fp32_denorms_flush) {
         if (profile.support_fp32_denorm_flush) {
             ctx.AddCapability(spv::Capability::DenormFlushToZero);
             ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 32U);
-            if (force_flush) {
-                LOG_DEBUG(Shader_SPIRV, "Fp32 DenormFlushToZero FORCED by user setting");
-            }
         } else {
             // Drivers will most likely flush denorms by default, no need to warn
         }
-    } else if (force_preserve || info.uses_fp32_denorms_preserve) {
+    } else if (info.uses_fp32_denorms_preserve) {
         if (profile.support_fp32_denorm_preserve) {
             ctx.AddCapability(spv::Capability::DenormPreserve);
             ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormPreserve, 32U);
-            if (force_preserve) {
-                LOG_DEBUG(Shader_SPIRV, "Fp32 DenormPreserve FORCED by user setting");
-            }
         } else {
             LOG_DEBUG(Shader_SPIRV, "Fp32 denorm preserve used in shader without host support");
         }
@@ -393,24 +377,13 @@ void SetupSignedNanCapabilities(const Profile& profile, const IR::Program& progr
     if (profile.has_broken_fp16_float_controls && program.info.uses_fp16) {
         return;
     }
-
-    // User-forced behavior (Android Eden Veil/Extensions)
-    const bool force_signed_zero_inf_nan = profile.force_fp32_signed_zero_inf_nan;
-
     if (program.info.uses_fp16 && profile.support_fp16_signed_zero_nan_preserve) {
         ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
         ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 16U);
     }
-    if (force_signed_zero_inf_nan || profile.support_fp32_signed_zero_nan_preserve) {
-        if (profile.support_fp32_signed_zero_nan_preserve) {
-            ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
-            ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 32U);
-            if (force_signed_zero_inf_nan) {
-                LOG_DEBUG(Shader_SPIRV, "Fp32 SignedZeroInfNanPreserve FORCED by user setting");
-            }
-        } else if (force_signed_zero_inf_nan) {
-            LOG_WARNING(Shader_SPIRV, "SignedZeroInfNanPreserve forced but driver doesn't support it");
-        }
+    if (profile.support_fp32_signed_zero_nan_preserve) {
+        ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);
+        ctx.AddExecutionMode(main_func, spv::ExecutionMode::SignedZeroInfNanPreserve, 32U);
     }
     if (program.info.uses_fp64 && profile.support_fp64_signed_zero_nan_preserve) {
         ctx.AddCapability(spv::Capability::SignedZeroInfNanPreserve);

src/shader_recompiler/backend/spirv/emit_spirv_image.cpp

@@ -332,23 +332,13 @@ void AddOffsetToCoordinates(EmitContext& ctx, const IR::TextureInstInfo& info, I
         return;
     }
 
-    // Mobile GPUs: 1D textures emulated as 2D with height=1
-    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
-
     Id result_type{};
     switch (info.type) {
     case TextureType::Buffer:
+    case TextureType::Color1D: {
         result_type = ctx.U32[1];
         break;
-    case TextureType::Color1D:
-        if (emulate_1d) {
-            // Treat as 2D: offset needs Y component
-            offset = ctx.OpCompositeConstruct(ctx.U32[2], offset, ctx.u32_zero_value);
-            result_type = ctx.U32[2];
-        } else {
-            result_type = ctx.U32[1];
-        }
-        break;
+    }
     case TextureType::ColorArray1D:
         offset = ctx.OpCompositeConstruct(ctx.U32[2], offset, ctx.u32_zero_value);
         [[fallthrough]];
@@ -372,40 +362,6 @@ void AddOffsetToCoordinates(EmitContext& ctx, const IR::TextureInstInfo& info, I
     }
     coords = ctx.OpIAdd(result_type, coords, offset);
 }
-
-// Helper: Convert 1D coordinates to 2D when emulating 1D textures on mobile GPUs
-[[nodiscard]] Id AdjustCoordinatesForEmulation(EmitContext& ctx, const IR::TextureInstInfo& info,
-                                               Id coords) {
-    if (!ctx.profile.needs_1d_texture_emulation) {
-        return coords;
-    }
-
-    switch (info.type) {
-    case TextureType::Color1D: {
-        // Convert scalar → vec2(x, 0.0)
-        return ctx.OpCompositeConstruct(ctx.F32[2], coords, ctx.f32_zero_value);
-    }
-    case TextureType::ColorArray1D: {
-        // Convert vec2(x, layer) → vec3(x, 0.0, layer)
-        // ColorArray1D coords are always vec2 in IR
-        const Id x = ctx.OpCompositeExtract(ctx.F32[1], coords, 0);
-        const Id layer = ctx.OpCompositeExtract(ctx.F32[1], coords, 1);
-        return ctx.OpCompositeConstruct(ctx.F32[3], x, ctx.f32_zero_value, layer);
-    }
-    case TextureType::Color2D:
-    case TextureType::ColorArray2D:
-    case TextureType::Color3D:
-    case TextureType::ColorCube:
-    case TextureType::ColorArrayCube:
-    case TextureType::Buffer:
-    case TextureType::Color2DRect:
-        // No adjustment needed for non-1D textures
-        return coords;
-    }
-
-    return coords; // Unreachable, but silences -Werror=return-type
-}
-
 } // Anonymous namespace
 
 Id EmitBindlessImageSampleImplicitLod(EmitContext&) {
@@ -507,7 +463,6 @@ Id EmitBoundImageWrite(EmitContext&) {
 Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                               Id bias_lc, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     if (ctx.stage == Stage::Fragment) {
         const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                      bias_lc, offset);
@@ -529,7 +484,6 @@ Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                               Id lod, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const ImageOperands operands(ctx, false, true, false, lod, offset);
 
     Id result = Emit(&EmitContext::OpImageSparseSampleExplicitLod,
@@ -546,7 +500,6 @@ Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value&
 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                   Id coords, Id dref, Id bias_lc, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     if (ctx.stage == Stage::Fragment) {
         const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                      bias_lc, offset);
@@ -568,7 +521,6 @@ Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
                                   Id coords, Id dref, Id lod, const IR::Value& offset) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const ImageOperands operands(ctx, false, true, false, lod, offset);
     return Emit(&EmitContext::OpImageSparseSampleDrefExplicitLod,
                 &EmitContext::OpImageSampleDrefExplicitLod, ctx, inst, ctx.F32[1],
@@ -578,7 +530,6 @@ Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                    const IR::Value& offset, const IR::Value& offset2) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const ImageOperands operands(ctx, offset, offset2);
     if (ctx.profile.need_gather_subpixel_offset) {
         coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
@@ -591,7 +542,6 @@ Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id
 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                        const IR::Value& offset, const IR::Value& offset2, Id dref) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const ImageOperands operands(ctx, offset, offset2);
     if (ctx.profile.need_gather_subpixel_offset) {
         coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
@@ -604,7 +554,6 @@ Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
 Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset,
                   Id lod, Id ms) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     AddOffsetToCoordinates(ctx, info, coords, offset);
     if (info.type == TextureType::Buffer) {
         lod = Id{};
@@ -631,20 +580,9 @@ Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& i
         return uses_lod ? ctx.OpImageQuerySizeLod(type, image, lod)
                         : ctx.OpImageQuerySize(type, image);
     }};
-
-    // Mobile GPUs: 1D textures emulated as 2D, query returns vec2 instead of scalar
-    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
-
     switch (info.type) {
     case TextureType::Color1D:
-        if (emulate_1d) {
-            // Query as 2D, extract only X component for 1D size
-            const Id size_2d = query(ctx.U32[2]);
-            const Id width = ctx.OpCompositeExtract(ctx.U32[1], size_2d, 0);
-            return ctx.OpCompositeConstruct(ctx.U32[4], width, zero, zero, mips());
-        } else {
-            return ctx.OpCompositeConstruct(ctx.U32[4], query(ctx.U32[1]), zero, zero, mips());
-        }
+        return ctx.OpCompositeConstruct(ctx.U32[4], query(ctx.U32[1]), zero, zero, mips());
     case TextureType::ColorArray1D:
     case TextureType::Color2D:
     case TextureType::ColorCube:
@@ -662,7 +600,6 @@ Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& i
 
 Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const Id zero{ctx.f32_zero_value};
     const Id sampler{Texture(ctx, info, index)};
     return ctx.OpCompositeConstruct(ctx.F32[4], ctx.OpImageQueryLod(ctx.F32[2], sampler, coords),
@@ -672,7 +609,6 @@ Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I
 Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                      Id derivatives, const IR::Value& offset, Id lod_clamp) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const auto operands = info.num_derivatives == 3
                               ? ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                               ctx.Def(offset), {}, lod_clamp)
@@ -685,7 +621,6 @@ Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I
 
 Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     if (info.image_format == ImageFormat::Typeless && !ctx.profile.support_typeless_image_loads) {
         LOG_WARNING(Shader_SPIRV, "Typeless image read not supported by host");
         return ctx.ConstantNull(ctx.U32[4]);
@@ -702,7 +637,6 @@ Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id co
 
 void EmitImageWrite(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id color) {
     const auto info{inst->Flags<IR::TextureInstInfo>()};
-    coords = AdjustCoordinatesForEmulation(ctx, info, coords);
     const auto [image, is_integer] = Image(ctx, index, info);
     if (!is_integer) {
         color = ctx.OpBitcast(ctx.F32[4], color);

src/shader_recompiler/backend/spirv/emit_spirv_memory.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -33,24 +33,11 @@ Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
     const Id type{ctx.F32[1]};
     const bool depth{desc.is_depth};
     const bool ms{desc.is_multisample};
-
-    // Mobile GPUs lack Sampled1D SPIR-V capability - emulate 1D as 2D with array layer
-    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
-
-    // Debug log for 1D emulation
-    if (desc.type == TextureType::Color1D || desc.type == TextureType::ColorArray1D) {
-        LOG_WARNING(Shader_SPIRV, "ImageType(texture): Creating {} texture, emulate_1d={}",
-                    desc.type == TextureType::Color1D ? "Color1D" : "ColorArray1D",
-                    emulate_1d);
-    }
-
     switch (desc.type) {
     case TextureType::Color1D:
-        return emulate_1d ? ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, false, 1, format)
-                          : ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
     case TextureType::ColorArray1D:
-        return emulate_1d ? ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, false, 1, format)
-                          : ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
     case TextureType::Color2D:
     case TextureType::Color2DRect:
         return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, ms, 1, format);
@@ -92,22 +79,11 @@ spv::ImageFormat GetImageFormat(ImageFormat format) {
 
 Id ImageType(EmitContext& ctx, const ImageDescriptor& desc, Id sampled_type) {
     const spv::ImageFormat format{GetImageFormat(desc.format)};
-    const bool emulate_1d = ctx.profile.needs_1d_texture_emulation;
-
-    // Debug log for 1D emulation
-    if (desc.type == TextureType::Color1D || desc.type == TextureType::ColorArray1D) {
-        LOG_WARNING(Shader_SPIRV, "ImageType: Creating {} image, emulate_1d={}",
-                    desc.type == TextureType::Color1D ? "Color1D" : "ColorArray1D",
-                    emulate_1d);
-    }
-
     switch (desc.type) {
     case TextureType::Color1D:
-        return emulate_1d ? ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, false, false, 2, format)
-                          : ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, false, false, 2, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, false, false, 2, format);
     case TextureType::ColorArray1D:
-        return emulate_1d ? ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, true, false, 2, format)
-                          : ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, true, false, 2, format);
+        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, false, true, false, 2, format);
     case TextureType::Color2D:
         return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, false, false, false, 2, format);
     case TextureType::ColorArray2D:
@@ -1468,8 +1444,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
         subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
         subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
-
-        // Vulkan spec: Fragment shader Input variables with integer/float type must have Flat decoration
         if (stage == Stage::Fragment) {
             Decorate(subgroup_mask_eq, spv::Decoration::Flat);
             Decorate(subgroup_mask_lt, spv::Decoration::Flat);

src/shader_recompiler/ir_opt/global_memory_to_storage_buffer_pass.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -296,14 +293,6 @@ std::optional<LowAddrInfo> TrackLowAddress(IR::Inst* inst) {
     }
     // This address is expected to either be a PackUint2x32, a IAdd64, or a CompositeConstructU32x2
     IR::Inst* addr_inst{addr.InstRecursive()};
-    // Unwrap Identity ops introduced by lowerings (e.g., PackUint2x32 -> Identity)
-    while (addr_inst->GetOpcode() == IR::Opcode::Identity) {
-        const IR::Value id_arg{addr_inst->Arg(0)};
-        if (id_arg.IsImmediate()) {
-            return std::nullopt;
-        }
-        addr_inst = id_arg.InstRecursive();
-    }
     s32 imm_offset{0};
     if (addr_inst->GetOpcode() == IR::Opcode::IAdd64) {
         // If it's an IAdd64, get the immediate offset it is applying and grab the address
@@ -319,14 +308,6 @@ std::optional<LowAddrInfo> TrackLowAddress(IR::Inst* inst) {
             return std::nullopt;
         }
         addr_inst = iadd_addr.InstRecursive();
-        // Unwrap Identity again if present after folding IAdd64
-        while (addr_inst->GetOpcode() == IR::Opcode::Identity) {
-            const IR::Value id_arg{addr_inst->Arg(0)};
-            if (id_arg.IsImmediate()) {
-                return std::nullopt;
-            }
-            addr_inst = id_arg.InstRecursive();
-        }
     }
     // With IAdd64 handled, now PackUint2x32 is expected
     if (addr_inst->GetOpcode() == IR::Opcode::PackUint2x32) {
@@ -336,14 +317,6 @@ std::optional<LowAddrInfo> TrackLowAddress(IR::Inst* inst) {
             return std::nullopt;
         }
         addr_inst = vector.InstRecursive();
-        // Unwrap Identity that may replace PackUint2x32
-        while (addr_inst->GetOpcode() == IR::Opcode::Identity) {
-            const IR::Value id_arg{addr_inst->Arg(0)};
-            if (id_arg.IsImmediate()) {
-                return std::nullopt;
-            }
-            addr_inst = id_arg.InstRecursive();
-        }
     }
     // The vector is expected to be a CompositeConstructU32x2
     if (addr_inst->GetOpcode() != IR::Opcode::CompositeConstructU32x2) {

src/shader_recompiler/profile.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -28,14 +25,6 @@ struct Profile {
     bool support_fp16_signed_zero_nan_preserve{};
     bool support_fp32_signed_zero_nan_preserve{};
     bool support_fp64_signed_zero_nan_preserve{};
-
-    // User-forced float behavior overrides (Android Eden Veil/Extensions)
-    // When shader_float_controls_force_enable is true, these override shader-declared behavior
-    bool force_fp32_denorm_flush{};           // Force FTZ for all FP32 ops
-    bool force_fp32_denorm_preserve{};        // Force denorm preservation for all FP32 ops
-    bool force_fp32_rte_rounding{};           // Force Round-To-Even for all FP32 ops
-    bool force_fp32_signed_zero_inf_nan{};    // Force signed zero/inf/nan preservation
-
     bool support_explicit_workgroup_layout{};
     bool support_vote{};
     bool support_viewport_index_layer_non_geometry{};
@@ -49,9 +38,6 @@ struct Profile {
     bool support_gl_nv_gpu_shader_5{};
     bool support_gl_amd_gpu_shader_half_float{};
     bool support_gl_texture_shadow_lod{};
-    bool support_gl_shader_atomic_float{};
-    bool support_gl_shader_atomic_fp16_vector{};
-    bool support_gl_shader_atomic_int64{};
     bool support_gl_warp_intrinsics{};
     bool support_gl_variable_aoffi{};
     bool support_gl_sparse_textures{};
@@ -95,8 +81,6 @@ struct Profile {
     bool ignore_nan_fp_comparisons{};
     /// Some drivers have broken support for OpVectorExtractDynamic on subgroup mask inputs
     bool has_broken_spirv_subgroup_mask_vector_extract_dynamic{};
-    /// Mobile GPUs lack Sampled1D capability - need to emulate 1D textures as 2D with height=1
-    bool needs_1d_texture_emulation{};
 
     u32 gl_max_compute_smem_size{};
 

src/shader_recompiler/shader_info.h

@@ -133,7 +133,7 @@ enum class TexturePixelFormat {
     ASTC_2D_8X6_SRGB,
     ASTC_2D_6X5_UNORM,
     ASTC_2D_6X5_SRGB,
-
+    E5B9G9R9_FLOAT,
     D32_FLOAT,
     D16_UNORM,
     X8_D24_UNORM,

src/video_core/CMakeLists.txt

@@ -8,7 +8,7 @@ add_subdirectory(host_shaders)
 add_subdirectory(gpu_logging)
 
 if(LIBVA_FOUND)
-    set_source_files_properties(host1x/ffmpeg/ffmpeg.cpp
+    set_source_files_properties(host1x/ffmpeg.cpp
         PROPERTIES COMPILE_DEFINITIONS LIBVA_FOUND=1)
     list(APPEND FFmpeg_LIBRARIES ${LIBVA_LIBRARIES})
 endif()
@@ -44,7 +44,6 @@ add_library(video_core STATIC
     engines/sw_blitter/converter.h
     engines/const_buffer_info.h
     engines/draw_manager.cpp
-    engines/draw_manager.h
     engines/engine_interface.h
     engines/engine_upload.cpp
     engines/engine_upload.h
@@ -72,9 +71,9 @@ add_library(video_core STATIC
     host1x/codecs/vp8.h
     host1x/codecs/vp9.cpp
     host1x/codecs/vp9.h
-    host1x/codecs/vp9_types.h
-    host1x/ffmpeg/ffmpeg.cpp
-    host1x/ffmpeg/ffmpeg.h
+    host1x/codec_types.h
+    host1x/ffmpeg.cpp
+    host1x/ffmpeg.h
     host1x/control.cpp
     host1x/control.h
     host1x/gpu_device_memory_manager.cpp

src/video_core/buffer_cache/buffer_cache.h

@@ -356,7 +356,7 @@ void BufferCache<P>::BindHostGeometryBuffers(bool is_indexed) {
     if (is_indexed) {
         BindHostIndexBuffer();
     } else if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+        const auto& draw_state = maxwell3d->draw_manager.draw_state;
         if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
             draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
             runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
@@ -740,30 +740,25 @@ void BufferCache<P>::BindHostIndexBuffer() {
     TouchBuffer(buffer, channel_state->index_buffer.buffer_id);
     const u32 offset = buffer.Offset(channel_state->index_buffer.device_addr);
     const u32 size = channel_state->index_buffer.size;
-    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
-    if (!draw_state.inline_index_draw_indexes.empty()) [[unlikely]] {
+    const auto& draw_state = maxwell3d->draw_manager.draw_state;
+    if (draw_state.inline_index_draw_indexes.empty()) {
+        SynchronizeBuffer(buffer, channel_state->index_buffer.device_addr, size);
+    } else {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
             auto upload_staging = runtime.UploadStagingBuffer(size);
-            std::array<BufferCopy, 1> copies{
-                {BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
-            std::memcpy(upload_staging.mapped_span.data(),
-                        draw_state.inline_index_draw_indexes.data(), size);
+            std::array<BufferCopy, 1> copies{{BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
+            std::memcpy(upload_staging.mapped_span.data(), draw_state.inline_index_draw_indexes.data(), size);
             runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true);
         } else {
             buffer.ImmediateUpload(0, draw_state.inline_index_draw_indexes);
         }
-    } else {
-        SynchronizeBuffer(buffer, channel_state->index_buffer.device_addr, size);
     }
     if constexpr (HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const u32 new_offset =
-            offset + draw_state.index_buffer.first * draw_state.index_buffer.FormatSizeInBytes();
+        const u32 new_offset = offset + draw_state.index_buffer.first * draw_state.index_buffer.FormatSizeInBytes();
         runtime.BindIndexBuffer(buffer, new_offset, size);
     } else {
         buffer.MarkUsage(offset, size);
-        runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format,
-                                draw_state.index_buffer.first, draw_state.index_buffer.count,
-                                buffer, offset, size);
+        runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format, draw_state.index_buffer.first, draw_state.index_buffer.count, buffer, offset, size);
     }
 }
 
@@ -945,10 +940,9 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
             return alignment > 1 && (offset % alignment) != 0;
         }
     }();
-    const bool use_fast_buffer = needs_alignment_stream ||
-                                 (has_host_buffer &&
-                                  size <= channel_state->uniform_buffer_skip_cache_size &&
-                                  !memory_tracker.IsRegionGpuModified(device_addr, size));
+    const bool use_fast_buffer = needs_alignment_stream
+        || (has_host_buffer && size <= channel_state->uniform_buffer_skip_cache_size
+            && !memory_tracker.IsRegionGpuModified(device_addr, size));
     if (use_fast_buffer) {
         if constexpr (IS_OPENGL) {
             if (runtime.HasFastBufferSubData()) {
@@ -1229,7 +1223,7 @@ template <class P>
 void BufferCache<P>::UpdateIndexBuffer() {
     // We have to check for the dirty flags and index count
     // The index count is currently changed without updating the dirty flags
-    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+    const auto& draw_state = maxwell3d->draw_manager.draw_state;
     const auto& index_buffer_ref = draw_state.index_buffer;
     auto& flags = maxwell3d->dirty.flags;
     if (!flags[Dirty::IndexBuffer]) {

src/video_core/buffer_cache/buffer_cache_base.h

@@ -32,7 +32,7 @@
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/dirty_flags.h"
-#include "video_core/engines/draw_manager.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/memory_manager.h"
@@ -305,7 +305,7 @@ public:
     [[nodiscard]] bool IsRegionCpuModified(DAddr addr, size_t size);
 
     void SetDrawIndirect(
-        const Tegra::Engines::DrawManager::IndirectParams* current_draw_indirect_) {
+        const Tegra::Engines::Maxwell3D::DrawManager::IndirectParams* current_draw_indirect_) {
         current_draw_indirect = current_draw_indirect_;
     }
 
@@ -480,7 +480,7 @@ private:
 #endif
     DelayedDestructionRing<Buffer, TICKS_TO_DESTROY> delayed_destruction_ring;
 
-    const Tegra::Engines::DrawManager::IndirectParams* current_draw_indirect{};
+    const Tegra::Engines::Maxwell3D::DrawManager::IndirectParams* current_draw_indirect{};
 
     u32 last_index_count = 0;
 

src/video_core/cdma_pusher.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Ryujinx Team and Contributors
@@ -20,109 +20,101 @@
 namespace Tegra {
 
 CDmaPusher::CDmaPusher(Host1x::Host1x& host1x_, s32 id)
-    : host1x{host1x_}, memory_manager{host1x.GMMU()},
-      host_processor{std::make_unique<Host1x::Control>(host1x_)}, current_class{
-                                                                      static_cast<ChClassId>(id)} {
-    thread = std::jthread([this](std::stop_token stop_token) { ProcessEntries(stop_token); });
+    : host_processor(host1x_)
+    , host1x{host1x_}
+    , current_class{ChClassId(id)}
+{
+    thread = std::jthread([this](std::stop_token stop_token) {
+        Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+        ChCommandHeaderList command_list{host1x.System().ApplicationMemory(), 0, 0};
+        u32 count{};
+        u32 method_offset{};
+        u32 mask{};
+        bool incrementing{};
+        while (!stop_token.stop_requested()) {
+            {
+                std::unique_lock l{command_mutex};
+                command_cv.wait(l, stop_token, [this]() { return command_lists.size() > 0; });
+                if (stop_token.stop_requested()) {
+                    return;
+                }
+
+                command_list = std::move(command_lists.front());
+                command_lists.pop_front();
+            }
+
+            size_t i = 0;
+            for (const auto value : command_list) {
+                i++;
+                if (mask != 0) {
+                    const auto lbs = static_cast<u32>(std::countr_zero(mask));
+                    mask &= ~(1U << lbs);
+                    ExecuteCommand(method_offset + lbs, value.raw);
+                    continue;
+                } else if (count != 0) {
+                    --count;
+                    ExecuteCommand(method_offset, value.raw);
+                    if (incrementing) {
+                        ++method_offset;
+                    }
+                    continue;
+                }
+                const auto mode = value.submission_mode.Value();
+                switch (mode) {
+                case ChSubmissionMode::SetClass: {
+                    mask = value.value & 0x3f;
+                    method_offset = value.method_offset;
+                    current_class = ChClassId((value.value >> 6) & 0x3ff);
+                    break;
+                }
+                case ChSubmissionMode::Incrementing:
+                case ChSubmissionMode::NonIncrementing:
+                    count = value.value;
+                    method_offset = value.method_offset;
+                    incrementing = mode == ChSubmissionMode::Incrementing;
+                    break;
+                case ChSubmissionMode::Mask:
+                    mask = value.value;
+                    method_offset = value.method_offset;
+                    break;
+                case ChSubmissionMode::Immediate: {
+                    const u32 data = value.value & 0xfff;
+                    method_offset = value.method_offset;
+                    ExecuteCommand(method_offset, data);
+                    break;
+                }
+                default:
+                    LOG_ERROR(HW_GPU, "Bad command at index {} (bytes {:#X}), buffer size {}", i - 1, (i - 1) * sizeof(u32), command_list.size());
+                    UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!", u32(mode));
+                    break;
+                }
+            }
+        }
+    });
 }
 
 CDmaPusher::~CDmaPusher() = default;
 
-void CDmaPusher::ProcessEntries(std::stop_token stop_token) {
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
-    ChCommandHeaderList command_list{host1x.System().ApplicationMemory(), 0, 0};
-    u32 count{};
-    u32 method_offset{};
-    u32 mask{};
-    bool incrementing{};
-
-    while (!stop_token.stop_requested()) {
-        {
-            std::unique_lock l{command_mutex};
-            command_cv.wait(l, stop_token,
-                            [this]() { return command_lists.size() > 0; });
-            if (stop_token.stop_requested()) {
-                return;
-            }
-
-            command_list = std::move(command_lists.front());
-            command_lists.pop_front();
-        }
-
-        size_t i = 0;
-        for (const auto value : command_list) {
-            i++;
-            if (mask != 0) {
-                const auto lbs = static_cast<u32>(std::countr_zero(mask));
-                mask &= ~(1U << lbs);
-                ExecuteCommand(method_offset + lbs, value.raw);
-                continue;
-            } else if (count != 0) {
-                --count;
-                ExecuteCommand(method_offset, value.raw);
-                if (incrementing) {
-                    ++method_offset;
-                }
-                continue;
-            }
-            const auto mode = value.submission_mode.Value();
-            switch (mode) {
-            case ChSubmissionMode::SetClass: {
-                mask = value.value & 0x3f;
-                method_offset = value.method_offset;
-                current_class = static_cast<ChClassId>((value.value >> 6) & 0x3ff);
-                break;
-            }
-            case ChSubmissionMode::Incrementing:
-            case ChSubmissionMode::NonIncrementing:
-                count = value.value;
-                method_offset = value.method_offset;
-                incrementing = mode == ChSubmissionMode::Incrementing;
-                break;
-            case ChSubmissionMode::Mask:
-                mask = value.value;
-                method_offset = value.method_offset;
-                break;
-            case ChSubmissionMode::Immediate: {
-                const u32 data = value.value & 0xfff;
-                method_offset = value.method_offset;
-                ExecuteCommand(method_offset, data);
-                break;
-            }
-            default:
-                LOG_ERROR(HW_GPU, "Bad command at index {} (bytes {:#X}), buffer size {}", i - 1,
-                          (i - 1) * sizeof(u32), command_list.size());
-                UNIMPLEMENTED_MSG("ChSubmission mode {} is not implemented!",
-                                  static_cast<u32>(mode));
-                break;
-            }
-        }
-    }
-}
-
 void CDmaPusher::ExecuteCommand(u32 method, u32 arg) {
     switch (current_class) {
     case ChClassId::Control:
-        LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}",
-                  static_cast<u32>(current_class), method, arg);
-        host_processor->ProcessMethod(static_cast<Host1x::Control::Method>(method), arg);
+        LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}", u32(current_class), method, arg);
+        host_processor.ProcessMethod(Host1x::Control::Method(method), arg);
         break;
     default:
         thi_regs.reg_array[method] = arg;
         switch (static_cast<ThiMethod>(method)) {
         case ThiMethod::IncSyncpt: {
-            const auto syncpoint_id = static_cast<u32>(arg & 0xFF);
-            [[maybe_unused]] const auto cond = static_cast<u32>((arg >> 8) & 0xFF);
-            LOG_TRACE(Service_NVDRV, "Class {} IncSyncpt Method, syncpt {} cond {}",
-                      static_cast<u32>(current_class), syncpoint_id, cond);
+            const auto syncpoint_id = u32(arg & 0xFF);
+            [[maybe_unused]] const auto cond = u32((arg >> 8) & 0xFF);
+            LOG_TRACE(Service_NVDRV, "Class {} IncSyncpt Method, syncpt {} cond {}", u32(current_class), syncpoint_id, cond);
             auto& syncpoint_manager = host1x.GetSyncpointManager();
             syncpoint_manager.IncrementGuest(syncpoint_id);
             syncpoint_manager.IncrementHost(syncpoint_id);
             break;
         }
         case ThiMethod::SetMethod1:
-            LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}",
-                      static_cast<u32>(current_class), static_cast<u32>(thi_regs.method_0), arg);
+            LOG_TRACE(Service_NVDRV, "Class {} method {:#X} arg 0x{:X}", u32(current_class), u32(thi_regs.method_0), arg);
             ProcessMethod(thi_regs.method_0, arg);
             break;
         default:

src/video_core/cdma_pusher.h

@@ -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
 
@@ -15,11 +18,11 @@
 #include "common/common_types.h"
 #include "common/polyfill_thread.h"
 #include "core/memory.h"
+#include "video_core/host1x/control.h"
 
 namespace Tegra {
 
 namespace Host1x {
-class Control;
 class Host1x;
 class Nvdec;
 class SyncptIncrManager;
@@ -117,25 +120,19 @@ protected:
 
     virtual void ProcessMethod(u32 method, u32 arg) = 0;
 
-    Host1x::Host1x& host1x;
-    Tegra::MemoryManager& memory_manager;
-
 private:
-    /// Process the command entry
-    void ProcessEntries(std::stop_token stop_token);
-
     /// Invoke command class devices to execute the command based on the current state
     void ExecuteCommand(u32 state_offset, u32 data);
 
-    std::unique_ptr<Host1x::Control> host_processor;
-
-    std::mutex command_mutex;
-    std::condition_variable_any command_cv;
-    std::deque<ChCommandHeaderList> command_lists;
-    std::jthread thread;
-
+protected:
     ThiRegisters thi_regs{};
+    std::deque<ChCommandHeaderList> command_lists;
+    std::condition_variable_any command_cv;
+    Host1x::Control host_processor;
+    std::mutex command_mutex;
+    Host1x::Host1x& host1x;
     ChClassId current_class;
+    std::jthread thread;
 };
 
 } // namespace Tegra

src/video_core/compatible_formats.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -45,7 +42,7 @@ constexpr std::array VIEW_CLASS_32_BITS{
     PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT,     PixelFormat::R32_UINT,
     PixelFormat::R16G16_SINT,       PixelFormat::R32_SINT,        PixelFormat::A8B8G8R8_UNORM,
     PixelFormat::R16G16_UNORM,      PixelFormat::A8B8G8R8_SNORM,  PixelFormat::R16G16_SNORM,
-    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::B8G8R8A8_UNORM,
+    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::E5B9G9R9_FLOAT,  PixelFormat::B8G8R8A8_UNORM,
     PixelFormat::B8G8R8A8_SRGB,     PixelFormat::A8B8G8R8_UINT,   PixelFormat::A8B8G8R8_SINT,
     PixelFormat::A2B10G10R10_UINT,
 };
@@ -55,7 +52,7 @@ constexpr std::array VIEW_CLASS_32_BITS_NO_BGR{
     PixelFormat::A2B10G10R10_UNORM, PixelFormat::R16G16_UINT,      PixelFormat::R32_UINT,
     PixelFormat::R16G16_SINT,       PixelFormat::R32_SINT,         PixelFormat::A8B8G8R8_UNORM,
     PixelFormat::R16G16_UNORM,      PixelFormat::A8B8G8R8_SNORM,   PixelFormat::R16G16_SNORM,
-    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::A8B8G8R8_UINT,
+    PixelFormat::A8B8G8R8_SRGB,     PixelFormat::E5B9G9R9_FLOAT,   PixelFormat::A8B8G8R8_UINT,
     PixelFormat::A8B8G8R8_SINT,     PixelFormat::A2B10G10R10_UINT,
 };
 

src/video_core/engines/draw_manager.cpp

@@ -1,23 +1,24 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/settings.h"
 #include "video_core/dirty_flags.h"
-#include "video_core/engines/draw_manager.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_interface.h"
 
 namespace Tegra::Engines {
-DrawManager::DrawManager(Maxwell3D* maxwell3d_) : maxwell3d(maxwell3d_) {}
 
-void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
-    const auto& regs{maxwell3d->regs};
+void Maxwell3D::DrawManager::ProcessMethodCall(Maxwell3D& maxwell3d, u32 method, u32 argument) {
     switch (method) {
     case MAXWELL3D_REG_INDEX(clear_surface):
-        return Clear(1);
+        return Clear(maxwell3d, 1);
     case MAXWELL3D_REG_INDEX(draw.begin):
-        return DrawBegin();
+        return DrawBegin(maxwell3d);
     case MAXWELL3D_REG_INDEX(draw.end):
-        return DrawEnd();
+        return DrawEnd(maxwell3d);
     case MAXWELL3D_REG_INDEX(vertex_buffer.first):
     case MAXWELL3D_REG_INDEX(vertex_buffer.count):
     case MAXWELL3D_REG_INDEX(index_buffer.first):
@@ -33,33 +34,29 @@ void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
     case MAXWELL3D_REG_INDEX(index_buffer32_first):
     case MAXWELL3D_REG_INDEX(index_buffer16_first):
     case MAXWELL3D_REG_INDEX(index_buffer8_first):
-        return DrawIndexSmall(argument);
+        return DrawIndexSmall(maxwell3d, argument);
     case MAXWELL3D_REG_INDEX(draw_inline_index):
-        SetInlineIndexBuffer(argument);
+        SetInlineIndexBuffer(maxwell3d, argument);
         break;
     case MAXWELL3D_REG_INDEX(inline_index_2x16.even):
-        SetInlineIndexBuffer(regs.inline_index_2x16.even);
-        SetInlineIndexBuffer(regs.inline_index_2x16.odd);
+        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_2x16.even);
+        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_2x16.odd);
         break;
     case MAXWELL3D_REG_INDEX(inline_index_4x8.index0):
-        SetInlineIndexBuffer(regs.inline_index_4x8.index0);
-        SetInlineIndexBuffer(regs.inline_index_4x8.index1);
-        SetInlineIndexBuffer(regs.inline_index_4x8.index2);
-        SetInlineIndexBuffer(regs.inline_index_4x8.index3);
+        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index0);
+        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index1);
+        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index2);
+        SetInlineIndexBuffer(maxwell3d, maxwell3d.regs.inline_index_4x8.index3);
         break;
     case MAXWELL3D_REG_INDEX(vertex_array_instance_first):
-        DrawArrayInstanced(regs.vertex_array_instance_first.topology.Value(),
-                           regs.vertex_array_instance_first.start.Value(),
-                           regs.vertex_array_instance_first.count.Value(), false);
+        DrawArrayInstanced(maxwell3d, maxwell3d.regs.vertex_array_instance_first.topology.Value(), maxwell3d.regs.vertex_array_instance_first.start.Value(), maxwell3d.regs.vertex_array_instance_first.count.Value(), false);
         break;
     case MAXWELL3D_REG_INDEX(vertex_array_instance_subsequent): {
-        DrawArrayInstanced(regs.vertex_array_instance_subsequent.topology.Value(),
-                           regs.vertex_array_instance_subsequent.start.Value(),
-                           regs.vertex_array_instance_subsequent.count.Value(), true);
+        DrawArrayInstanced(maxwell3d, maxwell3d.regs.vertex_array_instance_subsequent.topology.Value(), maxwell3d.regs.vertex_array_instance_subsequent.start.Value(), maxwell3d.regs.vertex_array_instance_subsequent.count.Value(), true);
         break;
     }
     case MAXWELL3D_REG_INDEX(draw_texture.src_y0): {
-        DrawTexture();
+        DrawTexture(maxwell3d);
         break;
     }
     default:
@@ -67,101 +64,87 @@ void DrawManager::ProcessMethodCall(u32 method, u32 argument) {
     }
 }
 
-void DrawManager::Clear(u32 layer_count) {
-    if (maxwell3d->ShouldExecute()) {
-        maxwell3d->rasterizer->Clear(layer_count);
+void Maxwell3D::DrawManager::Clear(Maxwell3D& maxwell3d, u32 layer_count) {
+    if (maxwell3d.ShouldExecute()) {
+        maxwell3d.rasterizer->Clear(layer_count);
     }
 }
 
-void DrawManager::DrawDeferred() {
+void Maxwell3D::DrawManager::DrawDeferred(Maxwell3D& maxwell3d) {
     if (draw_state.draw_mode != DrawMode::Instance || draw_state.instance_count == 0) {
         return;
     }
-    DrawEnd(draw_state.instance_count + 1, true);
+    DrawEnd(maxwell3d, draw_state.instance_count + 1, true);
     draw_state.instance_count = 0;
 }
 
-void DrawManager::DrawArray(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
-                            u32 base_instance, u32 num_instances) {
+void Maxwell3D::DrawManager::DrawArray(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 vertex_first, u32 vertex_count, u32 base_instance, u32 num_instances) {
     draw_state.topology = topology;
     draw_state.vertex_buffer.first = vertex_first;
     draw_state.vertex_buffer.count = vertex_count;
     draw_state.base_instance = base_instance;
-    ProcessDraw(false, num_instances);
+    ProcessDraw(maxwell3d, false, num_instances);
 }
 
-void DrawManager::DrawArrayInstanced(PrimitiveTopology topology, u32 vertex_first, u32 vertex_count,
-                                     bool subsequent) {
+void Maxwell3D::DrawManager::DrawArrayInstanced(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 vertex_first, u32 vertex_count, bool subsequent) {
     draw_state.topology = topology;
     draw_state.vertex_buffer.first = vertex_first;
     draw_state.vertex_buffer.count = vertex_count;
-
     if (!subsequent) {
         draw_state.instance_count = 1;
     }
-
     draw_state.base_instance = draw_state.instance_count - 1;
     draw_state.draw_mode = DrawMode::Instance;
     draw_state.instance_count++;
-    ProcessDraw(false, 1);
+    ProcessDraw(maxwell3d, false, 1);
 }
 
-void DrawManager::DrawIndex(PrimitiveTopology topology, u32 index_first, u32 index_count,
-                            u32 base_index, u32 base_instance, u32 num_instances) {
-    const auto& regs{maxwell3d->regs};
+void Maxwell3D::DrawManager::DrawIndex(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count, u32 base_index, u32 base_instance, u32 num_instances) {
     draw_state.topology = topology;
-    draw_state.index_buffer = regs.index_buffer;
+    draw_state.index_buffer = maxwell3d.regs.index_buffer;
     draw_state.index_buffer.first = index_first;
     draw_state.index_buffer.count = index_count;
     draw_state.base_index = base_index;
     draw_state.base_instance = base_instance;
-    ProcessDraw(true, num_instances);
+    ProcessDraw(maxwell3d, true, num_instances);
 }
 
-void DrawManager::DrawArrayIndirect(PrimitiveTopology topology) {
+void Maxwell3D::DrawManager::DrawArrayIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology) {
     draw_state.topology = topology;
-
-    ProcessDrawIndirect();
+    ProcessDrawIndirect(maxwell3d);
 }
 
-void DrawManager::DrawIndexedIndirect(PrimitiveTopology topology, u32 index_first,
-                                      u32 index_count) {
-    const auto& regs{maxwell3d->regs};
+void Maxwell3D::DrawManager::DrawIndexedIndirect(Maxwell3D& maxwell3d, Maxwell3D::Regs::PrimitiveTopology topology, u32 index_first, u32 index_count) {
     draw_state.topology = topology;
-    draw_state.index_buffer = regs.index_buffer;
+    draw_state.index_buffer = maxwell3d.regs.index_buffer;
     draw_state.index_buffer.first = index_first;
     draw_state.index_buffer.count = index_count;
-
-    ProcessDrawIndirect();
+    ProcessDrawIndirect(maxwell3d);
 }
 
-void DrawManager::SetInlineIndexBuffer(u32 index) {
-    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>(index & 0x000000ff));
-    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x0000ff00) >> 8));
-    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0x00ff0000) >> 16));
-    draw_state.inline_index_draw_indexes.push_back(static_cast<u8>((index & 0xff000000) >> 24));
+void Maxwell3D::DrawManager::SetInlineIndexBuffer(Maxwell3D& maxwell3d, u32 index) {
+    draw_state.inline_index_draw_indexes.push_back(u8(index & 0x000000ff));
+    draw_state.inline_index_draw_indexes.push_back(u8((index & 0x0000ff00) >> 8));
+    draw_state.inline_index_draw_indexes.push_back(u8((index & 0x00ff0000) >> 16));
+    draw_state.inline_index_draw_indexes.push_back(u8((index & 0xff000000) >> 24));
     draw_state.draw_mode = DrawMode::InlineIndex;
 }
 
-void DrawManager::DrawBegin() {
-    const auto& regs{maxwell3d->regs};
-    auto reset_instance_count = regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First;
-    auto increment_instance_count =
-        regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent;
+void Maxwell3D::DrawManager::DrawBegin(Maxwell3D& maxwell3d) {
+    auto reset_instance_count = maxwell3d.regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First;
+    auto increment_instance_count = maxwell3d.regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent;
     if (reset_instance_count) {
-        DrawDeferred();
+        DrawDeferred(maxwell3d);
         draw_state.instance_count = 0;
         draw_state.draw_mode = DrawMode::General;
     } else if (increment_instance_count) {
         draw_state.instance_count++;
         draw_state.draw_mode = DrawMode::Instance;
     }
-
-    draw_state.topology = regs.draw.topology;
+    draw_state.topology = maxwell3d.regs.draw.topology;
 }
 
-void DrawManager::DrawEnd(u32 instance_count, bool force_draw) {
-    const auto& regs{maxwell3d->regs};
+void Maxwell3D::DrawManager::DrawEnd(Maxwell3D& maxwell3d, u32 instance_count, bool force_draw) {
     switch (draw_state.draw_mode) {
     case DrawMode::Instance:
         if (!force_draw) {
@@ -169,119 +152,100 @@ void DrawManager::DrawEnd(u32 instance_count, bool force_draw) {
         }
         [[fallthrough]];
     case DrawMode::General:
-        draw_state.base_instance = regs.global_base_instance_index;
-        draw_state.base_index = regs.global_base_vertex_index;
+        draw_state.base_instance = maxwell3d.regs.global_base_instance_index;
+        draw_state.base_index = maxwell3d.regs.global_base_vertex_index;
         if (draw_state.draw_indexed) {
-            draw_state.index_buffer = regs.index_buffer;
-            ProcessDraw(true, instance_count);
+            draw_state.index_buffer = maxwell3d.regs.index_buffer;
+            ProcessDraw(maxwell3d, true, instance_count);
         } else {
-            draw_state.vertex_buffer = regs.vertex_buffer;
-            ProcessDraw(false, instance_count);
+            draw_state.vertex_buffer = maxwell3d.regs.vertex_buffer;
+            ProcessDraw(maxwell3d, false, instance_count);
         }
         draw_state.draw_indexed = false;
         break;
     case DrawMode::InlineIndex:
-        draw_state.base_instance = regs.global_base_instance_index;
-        draw_state.base_index = regs.global_base_vertex_index;
-        draw_state.index_buffer = regs.index_buffer;
-        draw_state.index_buffer.count =
-            static_cast<u32>(draw_state.inline_index_draw_indexes.size() / 4);
+        draw_state.base_instance = maxwell3d.regs.global_base_instance_index;
+        draw_state.base_index = maxwell3d.regs.global_base_vertex_index;
+        draw_state.index_buffer = maxwell3d.regs.index_buffer;
+        draw_state.index_buffer.count = u32(draw_state.inline_index_draw_indexes.size() / 4);
         draw_state.index_buffer.format = Maxwell3D::Regs::IndexFormat::UnsignedInt;
-        maxwell3d->dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-        ProcessDraw(true, instance_count);
+        maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        ProcessDraw(maxwell3d, true, instance_count);
         draw_state.inline_index_draw_indexes.clear();
         break;
     }
 }
 
-void DrawManager::DrawIndexSmall(u32 argument) {
-    const auto& regs{maxwell3d->regs};
-    IndexBufferSmall index_small_params{argument};
-    draw_state.base_instance = regs.global_base_instance_index;
-    draw_state.base_index = regs.global_base_vertex_index;
-    draw_state.index_buffer = regs.index_buffer;
+void Maxwell3D::DrawManager::DrawIndexSmall(Maxwell3D& maxwell3d, u32 argument) {
+    Maxwell3D::Regs::IndexBufferSmall index_small_params{argument};
+    draw_state.base_instance = maxwell3d.regs.global_base_instance_index;
+    draw_state.base_index = maxwell3d.regs.global_base_vertex_index;
+    draw_state.index_buffer = maxwell3d.regs.index_buffer;
     draw_state.index_buffer.first = index_small_params.first;
     draw_state.index_buffer.count = index_small_params.count;
     draw_state.topology = index_small_params.topology;
-    maxwell3d->dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
-    ProcessDraw(true, 1);
+    maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+    ProcessDraw(maxwell3d, true, 1);
 }
 
-void DrawManager::DrawTexture() {
-    const auto& regs{maxwell3d->regs};
-    draw_texture_state.dst_x0 = static_cast<float>(regs.draw_texture.dst_x0) / 4096.f;
-    draw_texture_state.dst_y0 = static_cast<float>(regs.draw_texture.dst_y0) / 4096.f;
-    const auto dst_width = static_cast<float>(regs.draw_texture.dst_width) / 4096.f;
-    const auto dst_height = static_cast<float>(regs.draw_texture.dst_height) / 4096.f;
-    const bool lower_left{regs.window_origin.mode !=
-                          Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
+void Maxwell3D::DrawManager::DrawTexture(Maxwell3D& maxwell3d) {
+    draw_texture_state.dst_x0 = f32(maxwell3d.regs.draw_texture.dst_x0) / 4096.f;
+    draw_texture_state.dst_y0 = f32(maxwell3d.regs.draw_texture.dst_y0) / 4096.f;
+    const auto dst_width = f32(maxwell3d.regs.draw_texture.dst_width) / 4096.f;
+    const auto dst_height = f32(maxwell3d.regs.draw_texture.dst_height) / 4096.f;
+    const bool lower_left{maxwell3d.regs.window_origin.mode != Maxwell3D::Regs::WindowOrigin::Mode::UpperLeft};
     if (lower_left) {
-        draw_texture_state.dst_y0 =
-            static_cast<f32>(regs.surface_clip.height) - draw_texture_state.dst_y0;
+        draw_texture_state.dst_y0 = f32(maxwell3d.regs.surface_clip.height) - draw_texture_state.dst_y0;
     }
     draw_texture_state.dst_x1 = draw_texture_state.dst_x0 + dst_width;
     draw_texture_state.dst_y1 = draw_texture_state.dst_y0 + dst_height;
-    draw_texture_state.src_x0 = static_cast<float>(regs.draw_texture.src_x0) / 4096.f;
-    draw_texture_state.src_y0 = static_cast<float>(regs.draw_texture.src_y0) / 4096.f;
-    draw_texture_state.src_x1 =
-        (static_cast<float>(regs.draw_texture.dx_du) / 4294967296.f) * dst_width +
-        draw_texture_state.src_x0;
-    draw_texture_state.src_y1 =
-        (static_cast<float>(regs.draw_texture.dy_dv) / 4294967296.f) * dst_height +
-        draw_texture_state.src_y0;
-    draw_texture_state.src_sampler = regs.draw_texture.src_sampler;
-    draw_texture_state.src_texture = regs.draw_texture.src_texture;
-    maxwell3d->rasterizer->DrawTexture();
+    draw_texture_state.src_x0 = f32(maxwell3d.regs.draw_texture.src_x0) / 4096.f;
+    draw_texture_state.src_y0 = f32(maxwell3d.regs.draw_texture.src_y0) / 4096.f;
+    draw_texture_state.src_x1 = (f32(maxwell3d.regs.draw_texture.dx_du) / 4294967296.f) * dst_width + draw_texture_state.src_x0;
+    draw_texture_state.src_y1 = (f32(maxwell3d.regs.draw_texture.dy_dv) / 4294967296.f) * dst_height + draw_texture_state.src_y0;
+    draw_texture_state.src_sampler = maxwell3d.regs.draw_texture.src_sampler;
+    draw_texture_state.src_texture = maxwell3d.regs.draw_texture.src_texture;
+    maxwell3d.rasterizer->DrawTexture();
 }
 
-void DrawManager::UpdateTopology() {
-    const auto& regs{maxwell3d->regs};
-    switch (regs.primitive_topology_control) {
-    case PrimitiveTopologyControl::UseInBeginMethods:
+void Maxwell3D::DrawManager::UpdateTopology(Maxwell3D& maxwell3d) {
+    switch (maxwell3d.regs.primitive_topology_control) {
+    case Maxwell3D::Regs::PrimitiveTopologyControl::UseInBeginMethods:
         break;
-    case PrimitiveTopologyControl::UseSeparateState:
-        switch (regs.topology_override) {
-        case PrimitiveTopologyOverride::None:
+    case Maxwell3D::Regs::PrimitiveTopologyControl::UseSeparateState:
+        switch (maxwell3d.regs.topology_override) {
+        case Maxwell3D::Regs::PrimitiveTopologyOverride::None:
             break;
-        case PrimitiveTopologyOverride::Points:
-            draw_state.topology = PrimitiveTopology::Points;
+        case Maxwell3D::Regs::PrimitiveTopologyOverride::Points:
+            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology::Points;
             break;
-        case PrimitiveTopologyOverride::Lines:
-            draw_state.topology = PrimitiveTopology::Lines;
+        case Maxwell3D::Regs::PrimitiveTopologyOverride::Lines:
+            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology::Lines;
             break;
-        case PrimitiveTopologyOverride::LineStrip:
-            draw_state.topology = PrimitiveTopology::LineStrip;
+        case Maxwell3D::Regs::PrimitiveTopologyOverride::LineStrip:
+            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology::LineStrip;
             break;
         default:
-            draw_state.topology = static_cast<PrimitiveTopology>(regs.topology_override);
+            draw_state.topology = Maxwell3D::Regs::PrimitiveTopology(maxwell3d.regs.topology_override);
             break;
         }
         break;
     }
 }
 
-void DrawManager::ProcessDraw(bool draw_indexed, u32 instance_count) {
-    LOG_TRACE(HW_GPU, "called, topology={}, count={}", draw_state.topology,
-              draw_indexed ? draw_state.index_buffer.count : draw_state.vertex_buffer.count);
-
-    UpdateTopology();
-
-    if (maxwell3d->ShouldExecute()) {
-        maxwell3d->rasterizer->Draw(draw_indexed, instance_count);
+void Maxwell3D::DrawManager::ProcessDraw(Maxwell3D& maxwell3d, bool draw_indexed, u32 instance_count) {
+    LOG_TRACE(HW_GPU, "called, topology={}, count={}", draw_state.topology, draw_indexed ? draw_state.index_buffer.count : draw_state.vertex_buffer.count);
+    UpdateTopology(maxwell3d);
+    if (maxwell3d.ShouldExecute()) {
+        maxwell3d.rasterizer->Draw(draw_indexed, instance_count);
     }
 }
 
-void DrawManager::ProcessDrawIndirect() {
-    LOG_TRACE(
-        HW_GPU,
-        "called, topology={}, is_indexed={}, includes_count={}, buffer_size={}, max_draw_count={}",
-        draw_state.topology, indirect_state.is_indexed, indirect_state.include_count,
-        indirect_state.buffer_size, indirect_state.max_draw_counts);
-
-    UpdateTopology();
-
-    if (maxwell3d->ShouldExecute()) {
-        maxwell3d->rasterizer->DrawIndirect();
+void Maxwell3D::DrawManager::ProcessDrawIndirect(Maxwell3D& maxwell3d) {
+    LOG_TRACE(HW_GPU, "called, topology={}, is_indexed={}, includes_count={}, buffer_size={}, max_draw_count={}", draw_state.topology, indirect_state.is_indexed, indirect_state.include_count, indirect_state.buffer_size, indirect_state.max_draw_counts);
+    UpdateTopology(maxwell3d);
+    if (maxwell3d.ShouldExecute()) {
+        maxwell3d.rasterizer->DrawIndirect();
     }
 }
 } // namespace Tegra::Engines