[fs] temporarely disable nca verification (#298)

This adds a passthrough to basically disable nca verification for newer NCAs, this fixes (tested) Pokemon 4.0.0 update and other newer SDK games and updates (as reported on the discord)

This is implemented as toggle that is default enabled, this needs proper implementation in the future.

Co-authored-by: crueter <crueter@eden-emu.dev>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/298
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: crueter <crueter@eden-emu.dev>
Co-authored-by: Maufeat <sahyno1996@gmail.com>
Co-committed-by: Maufeat <sahyno1996@gmail.com>

.ci/linux/eden.dwfsprof

@@ -1,6 +1,6 @@
 AppRun
 eden.desktop
-org.eden_emu.eden.desktop
+dev.eden_emu.eden.desktop
 shared/bin/eden
 shared/lib/lib.path
 shared/lib/ld-linux-x86-64.so.2

.ci/linux/package.sh

@@ -59,15 +59,15 @@ VERSION="$(echo "$EDEN_TAG")"
 mkdir -p ./AppDir
 cd ./AppDir
 
-cp ../dist/org.eden_emu.eden.desktop .
-cp ../dist/org.eden_emu.eden.svg .
+cp ../dist/dev.eden_emu.eden.desktop .
+cp ../dist/dev.eden_emu.eden.svg .
 
-ln -sf ./org.eden_emu.eden.svg ./.DirIcon
+ln -sf ./dev.eden_emu.eden.svg ./.DirIcon
 
 UPINFO='gh-releases-zsync|eden-emulator|Releases|latest|*.AppImage.zsync'
 
 if [ "$DEVEL" = 'true' ]; then
-	sed -i 's|Name=Eden|Name=Eden Nightly|' ./org.eden_emu.eden.desktop
+	sed -i 's|Name=Eden|Name=Eden Nightly|' ./dev.eden_emu.eden.desktop
  	UPINFO="$(echo "$UPINFO" | sed 's|Releases|nightly|')"
 fi
 

.ci/update-icons.sh

@@ -6,7 +6,7 @@
 which png2icns || [ which yay && yay libicns ] || exit
 which magick || exit
 
-export EDEN_SVG_ICO="dist/org.eden_emu.eden.svg"
+export EDEN_SVG_ICO="dist/dev.eden_emu.eden.svg"
 svgo --multipass $EDEN_SVG_ICO
 
 magick -density 256x256 -background transparent $EDEN_SVG_ICO \

.gitignore

@@ -52,3 +52,4 @@ Thumbs.db
 eden-windows-msvc
 artifacts
 *.AppImage*
+/install*

.patch/unordered-dense/0001-cmake.patch

@@ -0,0 +1,22 @@
+From e59d30b7b12e1d04cc2fc9c6219e35bda447c17e Mon Sep 17 00:00:00 2001
+From: Lizzie <159065448+Lizzie841@users.noreply.github.com>
+Date: Fri, 16 May 2025 04:12:13 +0100
+Subject: [PATCH] Update CMakeLists.txt
+
+---
+ CMakeLists.txt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index b5f4c4f..c5c6f31 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -24,7 +24,7 @@ target_include_directories(
+ 
+ target_compile_features(unordered_dense INTERFACE cxx_std_17)
+ 
+-if(_unordered_dense_is_toplevel_project)
++if(_unordered_dense_is_toplevel_project OR UNORDERED_DENSE_INSTALL)
+     # locations are provided by GNUInstallDirs
+     install(
+         TARGETS unordered_dense

CMakeLists.txt

@@ -44,24 +44,18 @@ if (PLATFORM_FREEBSD)
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -L/usr/local/lib")
 endif()
 
-# Check if SDL2::SDL2 target exists; if not, create an alias
-if (TARGET SDL2::SDL2-static)
-    add_library(SDL2::SDL2 ALIAS SDL2::SDL2-static)
-elseif (TARGET SDL2::SDL2-shared)
-    add_library(SDL2::SDL2 ALIAS SDL2::SDL2-shared)
-endif()
-
 # Set bundled sdl2/qt as dependent options.
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
-option(ENABLE_SDL2 "Enable the SDL2 frontend" ON)
-CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON "ENABLE_SDL2;MSVC" OFF)
+CMAKE_DEPENDENT_OPTION(ENABLE_SDL2 "Enable the SDL2 frontend" ON "NOT ANDROID" OFF)
+
+set(EXT_DEFAULT ON)
 
 if (PLATFORM_FREEBSD)
-    CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" OFF "ENABLE_SDL2;NOT MSVC" OFF)
-else()
-    CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)
+    set(EXT_DEFAULT OFF)
 endif()
 
+CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ${EXT_DEFAULT} "ENABLE_SDL2;NOT MSVC" OFF)
+
 cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "NOT ANDROID" OFF)
 
 option(ENABLE_OPENGL "Enable OpenGL" ON)
@@ -78,29 +72,10 @@ option(YUZU_USE_CPM "Use CPM to fetch Eden dependencies if needed" ON)
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 option(ENABLE_WIFI_SCAN "Enable WiFi scanning" OFF)
 
-if (PLATFORM_FREEBSD)
-    option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" OFF)
-else()
-    option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ON)
-endif()
-
-if (PLATFORM_FREEBSD)
-    option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" OFF)
-else()
-    option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
-endif()
-
-if (PLATFORM_FREEBSD)
-    option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" OFF)
-else()
-    option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" ON)
-endif()
-
-if (PLATFORM_FREEBSD)
-    option(YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS "Use SPIRV-Tools from externals" OFF)
-else()
-    option(YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS "Use SPIRV-Tools from externals" ON)
-endif()
+option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ${EXT_DEFAULT})
+option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ${EXT_DEFAULT})
+option(YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES "Use Vulkan-Utility-Libraries from externals" ${EXT_DEFAULT})
+option(YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS "Use SPIRV-Tools from externals" ${EXT_DEFAULT})
 
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)
 
@@ -116,17 +91,15 @@ option(ENABLE_MICROPROFILE "Enables microprofile capabilities" OFF)
 
 option(YUZU_TESTS "Compile tests" "${BUILD_TESTING}")
 
-if (PLATFORM_FREEBSD)
-    option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" OFF)
-else()
-    option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)
-endif()
+option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ${EXT_DEFAULT})
 
 option(YUZU_DOWNLOAD_ANDROID_VVL "Download validation layer binary for android" ON)
 
 option(FORCE_DOWNLOAD_WIN_BUNDLES "Forcefully download bundled Windows dependencies (useful for CI)" OFF)
 
-option(FORCE_DOWNLOAD_OPENSSL "Forcefully download all bundled OpenSSL builds (useful for CI)" OFF)
+if (YUZU_USE_CPM AND ENABLE_SDL2)
+    option(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 build" "${MSVC}")
+endif()
 
 CMAKE_DEPENDENT_OPTION(YUZU_ROOM "Enable dedicated room functionality" ON "NOT ANDROID" OFF)
 
@@ -136,11 +109,7 @@ CMAKE_DEPENDENT_OPTION(YUZU_CMD "Compile the eden-cli executable" ON "NOT ANDROI
 
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile crash dump (Minidump) support" OFF "WIN32 OR LINUX" OFF)
 
-if (PLATFORM_FREEBSD)
-    option(YUZU_CHECK_SUBMODULES "Check if submodules are present" OFF)
-else()
-    option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)
-endif()
+option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ${EXT_DEFAULT})
 
 option(YUZU_ENABLE_LTO "Enable link-time optimization" OFF)
 
@@ -169,6 +138,10 @@ endif()
 
 option(ENABLE_OPENSSL "Enable OpenSSL backend for ISslConnection" ${DEFAULT_ENABLE_OPENSSL})
 
+if (ENABLE_OPENSSL)
+    CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_OPENSSL "Download bundled OpenSSL build" "${MSVC}" "NOT ANDROID" ON)
+endif()
+
 if (ANDROID AND YUZU_DOWNLOAD_ANDROID_VVL)
     set(vvl_version "sdk-1.3.261.1")
     set(vvl_zip_file "${CMAKE_BINARY_DIR}/externals/vvl-android.zip")
@@ -201,12 +174,12 @@ if (YUZU_USE_PRECOMPILED_HEADERS)
         set(YUZU_USE_PRECOMPILED_HEADERS OFF CACHE BOOL "" FORCE)
     endif()
 endif()
+
 if (YUZU_USE_PRECOMPILED_HEADERS)
     message(STATUS "Using Precompiled Headers.")
     set(CMAKE_PCH_INSTANTIATE_TEMPLATES ON)
 endif()
 
-
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -267,20 +240,24 @@ endfunction()
 if(EXISTS ${PROJECT_SOURCE_DIR}/.gitmodules AND YUZU_CHECK_SUBMODULES)
     check_submodules_present()
 endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.qrc
     ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.qrc
     COPYONLY)
+
 if (EXISTS ${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json)
     configure_file("${PROJECT_SOURCE_DIR}/dist/compatibility_list/compatibility_list.json"
         "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json"
         COPYONLY)
 endif()
+
 if (ENABLE_COMPATIBILITY_LIST_DOWNLOAD AND NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     message(STATUS "Downloading compatibility list for yuzu...")
     file(DOWNLOAD
         https://api.yuzu-emu.org/gamedb/
         "${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json" SHOW_PROGRESS)
 endif()
+
 if (NOT EXISTS ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json)
     file(WRITE ${PROJECT_BINARY_DIR}/dist/compatibility_list/compatibility_list.json "")
 endif()
@@ -324,13 +301,20 @@ if (NOT DEFINED ARCHITECTURE)
     set(ARCHITECTURE_GENERIC 1)
     add_definitions(-DARCHITECTURE_GENERIC=1)
 endif()
+
 message(STATUS "Target architecture: ${ARCHITECTURE}")
 
+if (MSVC AND ARCHITECTURE_x86)
+    message(FATAL_ERROR "Attempting to build with the x86 environment is not supported. \
+        This can typically happen if you used the Developer Command Prompt from the start menu;\
+        instead, run vcvars64.bat directly, located at C:/Program Files/Microsoft Visual Studio/2022/Community/VC/Auxiliary/Build/vcvars64.bat")
+endif()
+
 if (UNIX)
     add_definitions(-DYUZU_UNIX=1)
 endif()
 
-if (ARCHITECTURE_arm64 AND (ANDROID OR APPLE OR PLATFORM_LINUX))
+if (ARCHITECTURE_arm64 AND (ANDROID OR PLATFORM_LINUX))
     set(HAS_NCE 1)
     add_definitions(-DHAS_NCE=1)
 endif()
@@ -388,6 +372,15 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 
 include(CPMUtil)
 
+# openssl funniness
+if (ENABLE_OPENSSL)
+    if (YUZU_USE_BUNDLED_OPENSSL)
+        AddJsonPackage(openssl)
+    endif()
+
+    find_package(OpenSSL 1.1.1 REQUIRED)
+endif()
+
 if (YUZU_USE_CPM)
     message(STATUS "Fetching needed dependencies with CPM")
 
@@ -396,200 +389,9 @@ if (YUZU_USE_CPM)
 
     # TODO(crueter): renderdoc?
 
-    # openssl funniness
-    if (ENABLE_OPENSSL)
-        set(SSL_VERSION 3.5.2)
-
-        if ((MSVC AND ARCHITECTURE_x86_64) OR FORCE_DOWNLOAD_OPENSSL)
-            set(ARTIFACT openssl-windows-amd64-${SSL_VERSION}.tar.zst)
-            set(KEY windows-amd64)
-
-            if (MSVC AND ARCHITECTURE_x86_64)
-                set(DOWNLOAD_ONLY OFF)
-                set(BUILD_SHARED_LIBS OFF)
-            else()
-                set(DOWNLOAD_ONLY ON)
-            endif()
-
-            AddPackage(
-                NAME OpenSSL-windows-amd64
-                REPO crueter/OpenSSL-CI
-                TAG v${SSL_VERSION}
-                VERSION ${SSL_VERSION}
-                ARTIFACT ${ARTIFACT}
-
-                KEY ${KEY}
-                HASH_SUFFIX sha512sum
-                BUNDLED_PACKAGE ON
-                DOWNLOAD_ONLY ${DOWNLOAD_ONLY}
-            )
-
-            if (NOT DOWNLOAD_ONLY)
-                set(OPENSSL_DIR ${OpenSSL-windows-amd64_SOURCE_DIR})
-            endif()
-            message("OPENSSL ${DOWNLOAD_ONLY} ${OPENSSL_DIR}")
-
-        endif()
-
-        if ((MSVC AND ARCHITECTURE_arm64) OR FORCE_DOWNLOAD_OPENSSL)
-            set(ARTIFACT openssl-windows-arm64-${SSL_VERSION}.tar.zst)
-            set(KEY windows-arm64)
-
-            if (MSVC AND ARCHITECTURE_arm64)
-                set(DOWNLOAD_ONLY OFF)
-                set(BUILD_SHARED_LIBS OFF)
-            else()
-                set(DOWNLOAD_ONLY ON)
-            endif()
-
-            AddPackage(
-                NAME OpenSSL-windows-arm64
-                REPO crueter/OpenSSL-CI
-                TAG v${SSL_VERSION}
-                VERSION ${SSL_VERSION}
-                ARTIFACT ${ARTIFACT}
-
-                KEY ${KEY}
-                HASH_SUFFIX sha512sum
-                BUNDLED_PACKAGE ON
-                DOWNLOAD_ONLY ${DOWNLOAD_ONLY}
-            )
-
-            if (NOT DOWNLOAD_ONLY)
-                set(OPENSSL_DIR ${OpenSSL-windows-arm64_SOURCE_DIR})
-            endif()
-        endif()
-
-        if (ANDROID OR FORCE_DOWNLOAD_OPENSSL)
-            if (ANDROID)
-                set(DOWNLOAD_ONLY OFF)
-                set(BUILD_SHARED_LIBS OFF)
-            else()
-                set(DOWNLOAD_ONLY ON)
-            endif()
-
-            AddPackage(
-                NAME OpenSSL-android
-                REPO crueter/OpenSSL-CI
-                TAG v${SSL_VERSION}
-                VERSION ${SSL_VERSION}
-                ARTIFACT openssl-android-${SSL_VERSION}.tar.zst
-
-                KEY android
-                HASH_SUFFIX sha512sum
-                BUNDLED_PACKAGE ON
-                DOWNLOAD_ONLY ${DOWNLOAD_ONLY}
-            )
-
-            if (NOT DOWNLOAD_ONLY)
-                set(OPENSSL_DIR ${OpenSSL-android_SOURCE_DIR})
-            endif()
-        endif()
-
-        if(PLATFORM_SUN OR FORCE_DOWNLOAD_OPENSSL)
-            if (PLATFORM_SUN)
-                set(DOWNLOAD_ONLY OFF)
-                set(BUILD_SHARED_LIBS OFF)
-            else()
-                set(DOWNLOAD_ONLY ON)
-            endif()
-
-            AddPackage(
-                NAME OpenSSL-solaris
-                REPO crueter/OpenSSL-CI
-                TAG v${SSL_VERSION}
-                VERSION ${SSL_VERSION}
-                ARTIFACT openssl-solaris-${SSL_VERSION}.tar.zst
-
-                KEY solaris
-                HASH_SUFFIX sha512sum
-                BUNDLED_PACKAGE ON
-                DOWNLOAD_ONLY ${DOWNLOAD_ONLY}
-            )
-
-            if (NOT DOWNLOAD_ONLY)
-                set(OPENSSL_DIR ${OpenSSL-solaris_SOURCE_DIR})
-            endif()
-        endif()
-
-        if(PLATFORM_FREEBSD OR FORCE_DOWNLOAD_OPENSSL)
-            if (PLATFORM_FREEBSD)
-                set(DOWNLOAD_ONLY OFF)
-                set(BUILD_SHARED_LIBS OFF)
-            else()
-                set(DOWNLOAD_ONLY ON)
-            endif()
-
-            AddPackage(
-                NAME OpenSSL-freebsd
-                REPO crueter/OpenSSL-CI
-                TAG v${SSL_VERSION}
-                VERSION ${SSL_VERSION}
-                ARTIFACT openssl-freebsd-${SSL_VERSION}.tar.zst
-
-                KEY freebsd
-                HASH_SUFFIX sha512sum
-                BUNDLED_PACKAGE ON
-                DOWNLOAD_ONLY ${DOWNLOAD_ONLY}
-            )
-
-            if (NOT DOWNLOAD_ONLY)
-                set(OPENSSL_DIR ${OpenSSL-freebsd_SOURCE_DIR})
-            endif()
-        endif()
-
-        if(PLATFORM_LINUX OR FORCE_DOWNLOAD_OPENSSL)
-            if (PLATFORM_LINUX)
-                set(DOWNLOAD_ONLY OFF)
-                set(BUILD_SHARED_LIBS OFF)
-            else()
-                set(DOWNLOAD_ONLY ON)
-            endif()
-
-            AddPackage(
-                NAME OpenSSL-linux
-                REPO crueter/OpenSSL-CI
-                TAG v${SSL_VERSION}
-                VERSION ${SSL_VERSION}
-                ARTIFACT openssl-linux-${SSL_VERSION}.tar.zst
-
-                KEY linux
-                HASH_SUFFIX sha512sum
-                BUNDLED_PACKAGE ON
-                DOWNLOAD_ONLY ${DOWNLOAD_ONLY}
-            )
-
-            if (NOT DOWNLOAD_ONLY)
-                set(OPENSSL_DIR ${OpenSSL-linux_SOURCE_DIR})
-            endif()
-        endif()
-
-        if (DEFINED OPENSSL_DIR)
-            include(${OPENSSL_DIR}/openssl.cmake)
-
-            # Overrides find package
-            CPMAddPackage(
-                NAME OpenSSL
-                SOURCE_DIR ${OPENSSL_DIR}
-            )
-        else()
-            find_package(OpenSSL 1.1.1 REQUIRED)
-        endif()
-    endif()
-
     # boost
     set(BOOST_INCLUDE_LIBRARIES algorithm icl pool container heap asio headers process filesystem crc variant)
-    AddPackage(
-        NAME Boost
-        REPO boostorg/boost
-        TAG boost-1.88.0
-        ARTIFACT boost-1.88.0-cmake.7z
-
-        HASH e5b049e5b61964480ca816395f63f95621e66cb9bcf616a8b10e441e0e69f129e22443acb11e77bc1e8170f8e4171b9b7719891efc43699782bfcd4b3a365f01
-
-        GIT_VERSION 1.88.0
-        VERSION 1.57
-    )
+    AddJsonPackage(boost)
 
     # really annoying thing where boost::headers doesn't work with cpm
     # TODO(crueter) investigate
@@ -604,6 +406,12 @@ if (YUZU_USE_CPM)
 
         if (NOT MSVC)
             # boost sucks
+            # Solaris (and probably other NIXes) need explicit pthread definition
+            if (PLATFORM_SUN)
+                set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads")
+                set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthreads")
+            endif()
+
             target_compile_options(boost_heap INTERFACE -Wno-shadow)
             target_compile_options(boost_icl INTERFACE -Wno-shadow)
             target_compile_options(boost_asio INTERFACE -Wno-conversion -Wno-implicit-fallthrough)
@@ -611,144 +419,46 @@ if (YUZU_USE_CPM)
     endif()
 
     # fmt
-    AddPackage(
-        NAME fmt
-        REPO fmtlib/fmt
-        SHA 40626af88b
-        HASH d59f06c24339f223de4ec2afeba1c67b5835a0f350a1ffa86242a72fc3e616a6b8b21798355428d4200c75287308b66634619ffa0b52ba5bd74cc01772ea1a8a
-        VERSION 8
-        OPTIONS
-            "FMT_INSTALL OFF"
-    )
+    AddJsonPackage(fmt)
 
     # lz4
-    AddPackage(
-        NAME lz4
-        REPO lz4/lz4
-        SHA ebb370ca83
-        HASH 43600e87b35256005c0f2498fa56a77de6783937ba4cfce38c099f27c03188d097863e8a50c5779ca0a7c63c29c4f7ed0ae526ec798c1fd2e3736861b62e0a37
-        SOURCE_SUBDIR build/cmake
-    )
+    AddJsonPackage(lz4)
 
     if (lz4_ADDED)
         add_library(lz4::lz4 ALIAS lz4_static)
     endif()
 
     # nlohmann
-    AddPackage(
-        NAME nlohmann_json
-        REPO nlohmann/json
-        SHA 55f93686c0
-        HASH b739749b066800e21154506ea150d2c5cbce8a45344177f46f884547a1399d26753166fd0df8135269ce28cf223552b1b65cd625b88c844d54753f2434900486
-        VERSION 3.8
-    )
+    AddJsonPackage(nlohmann)
 
     # zlib
-    AddPackage(
-        NAME ZLIB
-        REPO madler/zlib
-        SHA 51b7f2abda
-        HASH 16eaf1f3752489d12fd9ce30f7b5f7cbd5cb8ff53d617005a9847ae72d937f65e01e68be747f62d7ac19fd0c9aeba9956e60f16d6b465c5fdc2f3d08b4db2e6c
-        VERSION 1.2
-        OPTIONS
-            "ZLIB_BUILD_SHARED OFF"
-            "ZLIB_INSTALL OFF"
-        EXCLUDE_FROM_ALL ON
-    )
+    AddJsonPackage(zlib)
 
     if (ZLIB_ADDED)
         add_library(ZLIB::ZLIB ALIAS zlibstatic)
     endif()
 
     # zstd
-    AddPackage(
-        NAME zstd
-        REPO facebook/zstd
-        SHA f8745da6ff
-        HASH 3037007f990040fe32573b46f9bef8762fd5dbeeb07ffffcbfeba51ec98167edae39bb9c87f9299efcd61c4e467c5e84f7c19f0df7799bc1fc04864a278792ee
-        VERSION 1.5
-        SOURCE_SUBDIR build/cmake
-        OPTIONS
-            "ZSTD_BUILD_SHARED OFF"
-        EXCLUDE_FROM_ALL ON
-    )
+    AddJsonPackage(zstd)
+
+    if (zstd_ADDED)
+        add_library(zstd::zstd ALIAS libzstd_static)
+    endif()
 
     # Catch2
     if (YUZU_TESTS OR DYNARMIC_TESTS)
-        AddPackage(
-            NAME Catch2
-            REPO catchorg/Catch2
-            SHA 644821ce28
-            HASH f8795f98acf2c02c0db8e734cc866d5caebab4b4a306e93598b97cb3c0c728dafe8283dce27ffe8d42460e5ae7302f3f32e7e274a7f991b73511ac88eef21b1f
-            VERSION 3.0.1
-        )
+        AddJsonPackage(catch2)
     endif()
 
     # ENet
-    AddPackage(
-        NAME enet
-        REPO lsalzman/enet
-        SHA 2662c0de09
-        VERSION 1.3
-        HASH 3de1beb4fa3d6b1e03eda8dd1e7580694f854af3ed3975dcdabfdcdf76b97f322b9734d35ea7f185855bb490d957842b938b26da4dd2dfded509390f8d2794dd
-        FIND_PACKAGE_ARGUMENTS "MODULE"
-    )
+    AddJsonPackage(enet)
 
     if (enet_ADDED)
         target_include_directories(enet INTERFACE ${enet_SOURCE_DIR}/include)
     endif()
 
     # Opus
-    AddPackage(
-        NAME Opus
-        VERSION 1.3
-        REPO "xiph/opus"
-        SHA 5ded705cf4
-        HASH 0dc89e58ddda1f3bc6a7037963994770c5806c10e66f5cc55c59286fc76d0544fe4eca7626772b888fd719f434bc8a92f792bdb350c807968b2ac14cfc04b203
-        FIND_PACKAGE_ARGUMENTS "MODULE"
-        OPTIONS
-            "OPUS_BUILD_TESTING OFF"
-            "OPUS_BUILD_PROGRAMS OFF"
-            "OPUS_INSTALL_PKG_CONFIG_MODULE OFF"
-            "OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF"
-    )
-
-    if(ENABLE_CUBEB)
-        AddPackage(
-            NAME cubeb
-            REPO "mozilla/cubeb"
-            SHA fa02160712
-            HASH 82d808356752e4064de48c8fecbe7856715ade1e76b53937116bf07129fc1cc5b3de5e4b408de3cd000187ba8dc32ca4109661cb7e0355a52e54bd81b9be1c61
-            FIND_PACKAGE_ARGUMENTS "CONFIG" # not sure this works outside of gentoo
-            OPTIONS
-                "USE_SANITIZERS OFF"
-                "BUILD_TESTS OFF"
-                "BUILD_TOOLS OFF"
-                "BUNDLE_SPEEX ON"
-        )
-
-        if (cubeb_ADDED)
-            if (NOT MSVC)
-                if (TARGET speex)
-                    target_compile_options(speex PRIVATE -Wno-sign-compare)
-                endif()
-
-                set_target_properties(cubeb PROPERTIES COMPILE_OPTIONS "")
-                target_compile_options(cubeb INTERFACE
-                    -Wno-implicit-const-int-float-conversion
-                    -Wno-shadow
-                    -Wno-missing-declarations
-                    -Wno-return-type
-                    -Wno-uninitialized
-                )
-            else()
-                target_compile_options(cubeb PRIVATE
-                    /wd4456
-                    /wd4458
-                )
-            endif()
-        endif()
-    endif()
+    AddJsonPackage(opus)
 else()
     # Enforce the search mode of non-required packages for better and shorter failure messages
     find_package(fmt 8 REQUIRED)
@@ -757,14 +467,10 @@ else()
     find_package(lz4 REQUIRED)
     find_package(RenderDoc MODULE)
     find_package(stb MODULE)
-    find_package(enet 1.3 MODULE)
-    find_package(Opus 1.3 MODULE)
+    find_package(enet 1.3 MODULE REQUIRED)
+    find_package(Opus 1.3 MODULE REQUIRED)
     find_package(ZLIB 1.2 REQUIRED)
-    find_package(zstd 1.5 REQUIRED)
-
-    if (ENABLE_CUBEB)
-        find_package(cubeb CONFIG)
-    endif()
+    find_package(zstd 1.5 REQUIRED MODULE)
 
     if (YUZU_TESTS)
         find_package(Catch2 3.0.1 REQUIRED)
@@ -780,13 +486,7 @@ else()
 endif()
 
 if(NOT TARGET Boost::headers)
-    AddPackage(
-        NAME boost_headers
-        REPO "boostorg/headers"
-        SHA 0456900fad
-        HASH 50cd75dcdfc5f082225cdace058f47b4fb114a47585f7aee1d22236a910a80b667186254c214fa2fcebac67ae6d37ba4b6e695e1faea8affd6fd42a03cf996e3
-        BUNDLED_PACKAGE ON
-    )
+    AddJsonPackage(boost_headers)
 endif()
 
 if (ENABLE_LIBUSB)
@@ -799,68 +499,78 @@ endif()
 
 # DiscordRPC
 if (USE_DISCORD_PRESENCE)
-    AddPackage(
-        NAME discord-rpc
-        REPO "discord/discord-rpc"
-        SHA 963aa9f3e5
-        HASH 386e1344e9a666d730f2d335ee3aef1fd05b1039febefd51aa751b705009cc764411397f3ca08dffd46205c72f75b235c870c737b2091a4ed0c3b061f5919bde
-        OPTIONS
-            "BUILD_EXAMPLES OFF"
-        PATCHES
-            ${CMAKE_SOURCE_DIR}/.patch/discord-rpc/0001-cmake-version.patch
-            ${CMAKE_SOURCE_DIR}/.patch/discord-rpc/0002-no-clang-format.patch
-            ${CMAKE_SOURCE_DIR}/.patch/discord-rpc/0003-fix-cpp17.patch
-        EXCLUDE_FROM_ALL ON
-    )
+    AddJsonPackage(discord-rpc)
 
     target_include_directories(discord-rpc INTERFACE ${discord-rpc_SOURCE_DIR}/include)
     add_library(DiscordRPC::discord-rpc ALIAS discord-rpc)
 endif()
 
 # SimpleIni
-AddPackage(
-    NAME SimpleIni
-    REPO brofield/simpleini
-    SHA 09c21bda1d
-    HASH 99779ca9b6e040d36558cadf484f9ffdab5b47bcc8fc72e4d33639d1d60c0ceb4410d335ba445d72a4324e455167fd6769d99b459943aa135bec085dff2d4b7c
-    EXCLUDE_FROM_ALL ON
-    FIND_PACKAGE_ARGUMENTS "MODULE"
-)
+AddJsonPackage(simpleini)
 
-# TODO(crueter): Work around this
-if (NOT YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS)
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(SPIRV-Tools REQUIRED SPIRV-Tools)
+# Most linux distros don't package cubeb, so enable regardless of cpm settings
+if(ENABLE_CUBEB)
+    AddJsonPackage(cubeb)
+
+    if (cubeb_ADDED)
+        if (NOT MSVC)
+            if (TARGET speex)
+                target_compile_options(speex PRIVATE -Wno-sign-compare)
+            endif()
+
+            set_target_properties(cubeb PROPERTIES COMPILE_OPTIONS "")
+            target_compile_options(cubeb INTERFACE
+                -Wno-implicit-const-int-float-conversion
+                -Wno-shadow
+                -Wno-missing-declarations
+                -Wno-return-type
+                -Wno-uninitialized
+            )
+        else()
+            target_compile_options(cubeb PRIVATE
+                /wd4456
+                /wd4458
+            )
+        endif()
+    endif()
 endif()
 
 # find SDL2 exports a bunch of variables that are needed, so its easier to do this outside of the YUZU_find_package
-# TODO(crueter): combine this all with CPM.
 if (ENABLE_SDL2)
-    if (YUZU_USE_BUNDLED_SDL2)
-        # Detect toolchain and platform
-        if ((MSVC_VERSION GREATER_EQUAL 1920) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.32.8")
-        else()
-            message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
-        endif()
-
-        if (DEFINED SDL2_VER)
-            download_bundled_external("sdl2/" ${SDL2_VER} "sdl2-bundled" SDL2_PREFIX 2.32.8)
-        endif()
-
-        set(SDL2_FOUND YES)
-        set(SDL2_INCLUDE_DIR "${SDL2_PREFIX}/include" CACHE PATH "Path to SDL2 headers")
-        set(SDL2_LIBRARY "${SDL2_PREFIX}/lib/x64/SDL2.lib" CACHE PATH "Path to SDL2 library")
-        set(SDL2_DLL_DIR "${SDL2_PREFIX}/lib/x64/" CACHE PATH "Path to SDL2.dll")
-
-        add_library(SDL2::SDL2 INTERFACE IMPORTED)
-        target_link_libraries(SDL2::SDL2 INTERFACE "${SDL2_LIBRARY}")
-        target_include_directories(SDL2::SDL2 INTERFACE "${SDL2_INCLUDE_DIR}")
-    elseif (YUZU_USE_EXTERNAL_SDL2)
+    if (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
-    else()
-        find_package(SDL2 2.26.4 REQUIRED)
+        if (NOT WIN32)
+            # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
+            # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
+            # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
+            # CPUinfo also required for SDL Audio, at least until 2.28.0 (see https://github.com/libsdl-org/SDL/issues/7809)
+            set(SDL_UNUSED_SUBSYSTEMS
+                File Filesystem
+                Locale Power Render)
+            foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
+              string(TOUPPER ${_SUB} _OPT)
+              set(SDL_${_OPT} OFF)
+            endforeach()
+
+            set(HIDAPI ON)
+        endif()
+
+        if (APPLE)
+            set(SDL_FILE ON)
+        endif()
+
+        if ("${YUZU_SYSTEM_PROFILE}" STREQUAL "steamdeck")
+            set(SDL_PIPEWIRE OFF) # build errors out with this on
+            AddJsonPackage("sdl2_steamdeck")
+        else()
+            AddJsonPackage("sdl2_generic")
+        endif()
+    elseif (YUZU_USE_BUNDLED_SDL2)
+        message(STATUS "Using bundled SDL2")
+        AddJsonPackage(sdl2)
     endif()
+
+    find_package(SDL2 2.26.4 REQUIRED)
 endif()
 
 # List of all FFmpeg components required
@@ -894,6 +604,7 @@ add_subdirectory(externals)
 find_package(VulkanHeaders)
 find_package(VulkanUtilityLibraries)
 find_package(VulkanMemoryAllocator)
+find_package(SPIRV-Tools)
 
 if (ENABLE_WEB_SERVICE)
     find_package(httplib)
@@ -903,7 +614,7 @@ if (ENABLE_WEB_SERVICE OR ENABLE_QT_UPDATE_CHECKER)
     find_package(cpp-jwt)
 endif()
 
-if (NOT YUZU_USE_BUNDLED_SDL2)
+if (ENABLE_SDL2)
     find_package(SDL2)
 endif()
 
@@ -925,7 +636,7 @@ if (ENABLE_QT)
     endif()
 
     if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-        find_package(Qt6 REQUIRED COMPONENTS DBus GuiPrivate)
+        find_package(Qt6 REQUIRED COMPONENTS DBus OPTIONAL_COMPONENTS GuiPrivate)
     elseif (UNIX AND NOT APPLE)
         find_package(Qt6 REQUIRED COMPONENTS DBus Gui)
     endif()
@@ -1147,14 +858,14 @@ endif()
 # https://specifications.freedesktop.org/shared-mime-info-spec/shared-mime-info-spec-latest.html
 # https://www.freedesktop.org/software/appstream/docs/
 if(ENABLE_QT AND UNIX AND NOT APPLE)
-    install(FILES "dist/org.eden_emu.eden.desktop"
+    install(FILES "dist/dev.eden_emu.eden.desktop"
         DESTINATION "share/applications")
-    install(FILES "dist/org.eden_emu.eden.svg"
+    install(FILES "dist/dev.eden_emu.eden.svg"
         DESTINATION "share/icons/hicolor/scalable/apps")
 
     # TODO: these files need to be updated.
-    install(FILES "dist/org.eden_emu.eden.xml"
+    install(FILES "dist/dev.eden_emu.eden.xml"
         DESTINATION "share/mime/packages")
-    install(FILES "dist/org.eden_emu.eden.metainfo.xml"
+    install(FILES "dist/dev.eden_emu.eden.metainfo.xml"
         DESTINATION "share/metainfo")
 endif()

CMakeModules/CPMUtil.cmake

@@ -1,28 +1,220 @@
 # SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+# SPDX-FileCopyrightText: Copyright 2025 crueter
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 # Created-By: crueter
 # Docs will come at a later date, mostly this is to just reduce boilerplate
 # and some cmake magic to allow for runtime viewing of dependency versions
 
-include(CMakeDependentOption)
+# Future crueter: Wow this was a lie and a half, at this point I might as well make my own CPN
+# haha just kidding... unless?
+
 if (MSVC OR ANDROID)
-    set(SYSTEM_DEFAULT OFF)
+    set(BUNDLED_DEFAULT OFF)
 else()
-    set(SYSTEM_DEFAULT ON)
+    set(BUNDLED_DEFAULT ON)
 endif()
 
-CMAKE_DEPENDENT_OPTION(CPMUTIL_DEFAULT_SYSTEM
-                       "Allow usage of system packages for CPM dependencies" ${SYSTEM_DEFAULT}
-                       "NOT ANDROID" OFF)
+option(CPMUTIL_FORCE_BUNDLED
+    "Force bundled packages for all CPM depdendencies" ${BUNDLED_DEFAULT})
+
+option(CPMUTIL_FORCE_SYSTEM
+    "Force system packages for all CPM dependencies (NOT RECOMMENDED)" OFF)
 
 cmake_minimum_required(VERSION 3.22)
 include(CPM)
 
+# TODO(crueter): Better solution for separate cpmfiles e.g. per-directory
+set(CPMUTIL_JSON_FILE "${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json" CACHE STRING "Location of cpmfile.json")
+
+if (EXISTS ${CPMUTIL_JSON_FILE})
+    file(READ ${CPMUTIL_JSON_FILE} CPMFILE_CONTENT)
+else()
+    message(WARNING "[CPMUtil] cpmfile ${CPMUTIL_JSON_FILE} does not exist, AddJsonPackage will be a no-op")
+endif()
+
+# utility
 function(cpm_utils_message level name message)
     message(${level} "[CPMUtil] ${name}: ${message}")
 endfunction()
 
+# utility
+function(array_to_list array length out)
+    math(EXPR range "${length} - 1")
+
+    foreach(IDX RANGE ${range})
+        string(JSON _element GET "${array}" "${IDX}")
+
+        list(APPEND NEW_LIST ${_element})
+    endforeach()
+
+    set("${out}" "${NEW_LIST}" PARENT_SCOPE)
+endfunction()
+
+# utility
+function(get_json_element object out member default)
+    string(JSON out_type ERROR_VARIABLE err TYPE "${object}" ${member})
+
+    if (err)
+        set("${out}" "${default}" PARENT_SCOPE)
+        return()
+    endif()
+
+    string(JSON outvar GET "${object}" ${member})
+
+    if (out_type STREQUAL "ARRAY")
+        string(JSON _len LENGTH "${object}" ${member})
+        # array_to_list("${outvar}" ${_len} outvar)
+        set("${out}_LENGTH" "${_len}" PARENT_SCOPE)
+    endif()
+
+    set("${out}" "${outvar}" PARENT_SCOPE)
+endfunction()
+
+# Kinda cancerous but whatever
+function(AddJsonPackage)
+    set(oneValueArgs
+        NAME
+
+        # these are overrides that can be generated at runtime, so can be defined separately from the json
+        DOWNLOAD_ONLY
+        SYSTEM_PACKAGE
+        BUNDLED_PACKAGE
+    )
+
+    set(multiValueArgs OPTIONS)
+
+    cmake_parse_arguments(JSON "" "${oneValueArgs}" "${multiValueArgs}"
+                          "${ARGN}")
+
+    list(LENGTH ARGN argnLength)
+    # single name argument
+    if(argnLength EQUAL 1)
+        set(JSON_NAME "${ARGV0}")
+    endif()
+
+    if (NOT DEFINED CPMFILE_CONTENT)
+        cpm_utils_message(WARNING ${name} "No cpmfile, AddJsonPackage is a no-op")
+        return()
+    endif()
+
+    if (NOT DEFINED JSON_NAME)
+        cpm_utils_message(FATAL_ERROR "json package" "No name specified")
+    endif()
+
+    string(JSON object ERROR_VARIABLE err GET "${CPMFILE_CONTENT}" "${JSON_NAME}")
+
+    if (err)
+        cpm_utils_message(FATAL_ERROR ${JSON_NAME} "Not found in cpmfile")
+    endif()
+
+    get_json_element("${object}" package package ${JSON_NAME})
+    get_json_element("${object}" repo repo "")
+    get_json_element("${object}" ci ci OFF)
+    get_json_element("${object}" version version "")
+
+    if (ci)
+        get_json_element("${object}" name name "${JSON_NAME}")
+        get_json_element("${object}" extension extension "tar.zst")
+        get_json_element("${object}" min_version min_version "")
+        get_json_element("${object}" cmake_filename cmake_filename "")
+        get_json_element("${object}" raw_disabled disabled_platforms "")
+
+        if (raw_disabled)
+            array_to_list("${raw_disabled}" ${raw_disabled_LENGTH} disabled_platforms)
+        else()
+            set(disabled_platforms "")
+        endif()
+
+        AddCIPackage(
+            VERSION ${version}
+            NAME ${name}
+            REPO ${repo}
+            PACKAGE ${package}
+            EXTENSION ${extension}
+            MIN_VERSION ${min_version}
+            DISABLED_PLATFORMS ${disabled_platforms}
+            CMAKE_FILENAME ${cmake_filename}
+        )
+        return()
+    endif()
+
+    get_json_element("${object}" hash hash "")
+    get_json_element("${object}" sha sha "")
+    get_json_element("${object}" url url "")
+    get_json_element("${object}" key key "")
+    get_json_element("${object}" tag tag "")
+    get_json_element("${object}" artifact artifact "")
+    get_json_element("${object}" git_version git_version "")
+    get_json_element("${object}" source_subdir source_subdir "")
+    get_json_element("${object}" bundled bundled "unset")
+    get_json_element("${object}" find_args find_args "")
+    get_json_element("${object}" raw_patches patches "")
+
+    # format patchdir
+    if (raw_patches)
+        math(EXPR range "${raw_patches_LENGTH} - 1")
+
+        foreach(IDX RANGE ${range})
+            string(JSON _patch GET "${raw_patches}" "${IDX}")
+
+            set(full_patch "${CMAKE_SOURCE_DIR}/.patch/${JSON_NAME}/${_patch}")
+            if (NOT EXISTS ${full_patch})
+                cpm_utils_message(FATAL_ERROR ${JSON_NAME} "specifies patch ${full_patch} which does not exist")
+            endif()
+
+            list(APPEND patches "${full_patch}")
+        endforeach()
+    endif()
+    # end format patchdir
+
+    # options
+    get_json_element("${object}" raw_options options "")
+
+    if (raw_options)
+        array_to_list("${raw_options}" ${raw_options_LENGTH} options)
+    endif()
+
+    set(options ${options} ${JSON_OPTIONS})
+
+    # end options
+
+    # system/bundled
+    if (bundled STREQUAL "unset" AND DEFINED JSON_BUNDLED_PACKAGE)
+        set(bundled ${JSON_BUNDLED_PACKAGE})
+    endif()
+
+    AddPackage(
+        NAME "${package}"
+        VERSION "${version}"
+        URL "${url}"
+        HASH "${hash}"
+        SHA "${sha}"
+        REPO "${repo}"
+        KEY "${key}"
+        PATCHES "${patches}"
+        OPTIONS "${options}"
+        FIND_PACKAGE_ARGUMENTS "${find_args}"
+        BUNDLED_PACKAGE "${bundled}"
+        SOURCE_SUBDIR "${source_subdir}"
+
+        GIT_VERSION ${git_version}
+        ARTIFACT ${artifact}
+        TAG ${tag}
+    )
+
+    # pass stuff to parent scope
+    set(${package}_ADDED "${${package}_ADDED}"
+        PARENT_SCOPE)
+    set(${package}_SOURCE_DIR "${${package}_SOURCE_DIR}"
+        PARENT_SCOPE)
+    set(${package}_BINARY_DIR "${${package}_BINARY_DIR}"
+        PARENT_SCOPE)
+
+endfunction()
+
 function(AddPackage)
     cpm_set_policies()
 
@@ -64,10 +256,8 @@ function(AddPackage)
         GIT_URL
 
         KEY
-        DOWNLOAD_ONLY
-        FIND_PACKAGE_ARGUMENTS
-        SYSTEM_PACKAGE
         BUNDLED_PACKAGE
+        FIND_PACKAGE_ARGUMENTS
     )
 
     set(multiValueArgs OPTIONS PATCHES)
@@ -79,6 +269,9 @@ function(AddPackage)
         cpm_utils_message(FATAL_ERROR "package" "No package name defined")
     endif()
 
+    option(${PKG_ARGS_NAME}_FORCE_SYSTEM "Force the system package for ${PKG_ARGS_NAME}")
+    option(${PKG_ARGS_NAME}_FORCE_BUNDLED "Force the bundled package for ${PKG_ARGS_NAME}")
+
     if (DEFINED PKG_ARGS_URL)
         set(pkg_url ${PKG_ARGS_URL})
 
@@ -124,9 +317,9 @@ function(AddPackage)
     cpm_utils_message(STATUS ${PKG_ARGS_NAME} "Download URL is ${pkg_url}")
 
     if (DEFINED PKG_ARGS_GIT_VERSION)
-        set(git_version ${PKG_ARGS_VERSION})
-    elseif(DEFINED PKG_ARGS_VERSION)
         set(git_version ${PKG_ARGS_GIT_VERSION})
+    elseif(DEFINED PKG_ARGS_VERSION)
+        set(git_version ${PKG_ARGS_VERSION})
     endif()
 
     if (NOT DEFINED PKG_ARGS_KEY)
@@ -178,25 +371,55 @@ function(AddPackage)
     if (DEFINED hash_url)
         set(outfile ${CMAKE_CURRENT_BINARY_DIR}/${PKG_ARGS_NAME}.hash)
 
-        file(DOWNLOAD ${hash_url} ${outfile})
-        file(READ ${outfile} pkg_hash_tmp)
-        file(REMOVE ${outfile})
+        # TODO(crueter): This is kind of a bad solution
+        # because "technically" the hash is invalidated each week
+        # but it works for now kjsdnfkjdnfjksdn
+        string(TOLOWER ${PKG_ARGS_NAME} lowername)
+        if (NOT EXISTS ${outfile} AND NOT EXISTS ${CPM_SOURCE_CACHE}/${lowername}/${pkg_key})
+            file(DOWNLOAD ${hash_url} ${outfile})
+        endif()
 
-        set(pkg_hash "${hash_algo}=${pkg_hash_tmp}")
+        if (EXISTS ${outfile})
+            file(READ ${outfile} pkg_hash_tmp)
+        endif()
+
+        if (DEFINED ${pkg_hash_tmp})
+            set(pkg_hash "${hash_algo}=${pkg_hash_tmp}")
+        endif()
     endif()
 
-    if (NOT CPMUTIL_DEFAULT_SYSTEM)
-        set(CPM_USE_LOCAL_PACKAGES OFF)
-    elseif (DEFINED PKG_ARGS_SYSTEM_PACKAGE)
-        set(CPM_USE_LOCAL_PACKAGES ${PKG_ARGS_SYSTEM_PACKAGE})
-    elseif (DEFINED PKG_ARGS_BUNDLED_PACKAGE)
+    macro(set_precedence local force)
+        set(CPM_USE_LOCAL_PACKAGES ${local})
+        set(CPM_LOCAL_PACKAGES_ONLY ${force})
+    endmacro()
+
+    #[[
+        Precedence:
+        - package_FORCE_SYSTEM
+        - package_FORCE_BUNDLED
+        - CPMUTIL_FORCE_SYSTEM
+        - CPMUTIL_FORCE_BUNDLED
+        - BUNDLED_PACKAGE
+        - default to allow local
+    ]]#
+    if (${PKG_ARGS_NAME}_FORCE_SYSTEM)
+        set_precedence(ON ON)
+    elseif (${PKG_ARGS_NAME}_FORCE_BUNDLED)
+        set_precedence(OFF OFF)
+    elseif (CPMUTIL_FORCE_SYSTEM)
+        set_precedence(ON ON)
+    elseif(CPMUTIL_FORCE_BUNDLED)
+        set_precedence(OFF OFF)
+    elseif (DEFINED PKG_ARGS_BUNDLED_PACKAGE AND NOT PKG_ARGS_BUNDLED_PACKAGE STREQUAL "unset")
         if (PKG_ARGS_BUNDLED_PACKAGE)
-            set(CPM_USE_LOCAL_PACKAGES OFF)
+            set(local OFF)
         else()
-            set(CPM_USE_LOCAL_PACKAGES ON)
+            set(local ON)
         endif()
+
+        set_precedence(${local} OFF)
     else()
-        set(CPM_USE_LOCAL_PACKAGES ON)
+        set_precedence(ON OFF)
     endif()
 
     CPMAddPackage(
@@ -210,6 +433,7 @@ function(AddPackage)
 
         OPTIONS ${PKG_ARGS_OPTIONS}
         PATCHES ${PKG_ARGS_PATCHES}
+        EXCLUDE_FROM_ALL ON
 
         ${PKG_ARGS_UNPARSED_ARGUMENTS}
     )
@@ -252,3 +476,116 @@ function(AddPackage)
         PARENT_SCOPE)
 
 endfunction()
+
+function(add_ci_package key)
+    set(ARTIFACT ${ARTIFACT_NAME}-${key}-${ARTIFACT_VERSION}.${ARTIFACT_EXT})
+
+    AddPackage(
+        NAME ${ARTIFACT_PACKAGE}
+        REPO ${ARTIFACT_REPO}
+        TAG v${ARTIFACT_VERSION}
+        VERSION ${ARTIFACT_VERSION}
+        ARTIFACT ${ARTIFACT}
+
+        KEY ${key}
+        HASH_SUFFIX sha512sum
+        BUNDLED_PACKAGE ON
+    )
+
+    set(ARTIFACT_DIR ${${ARTIFACT_PACKAGE}_SOURCE_DIR} PARENT_SCOPE)
+endfunction()
+
+# name is the artifact name, package is for find_package override
+function(AddCIPackage)
+    set(oneValueArgs
+        VERSION
+        NAME
+        REPO
+        PACKAGE
+        EXTENSION
+        MIN_VERSION
+        DISABLED_PLATFORMS
+        CMAKE_FILENAME
+    )
+
+    cmake_parse_arguments(PKG_ARGS "" "${oneValueArgs}" "" ${ARGN})
+
+    if(NOT DEFINED PKG_ARGS_VERSION)
+        message(FATAL_ERROR "[CPMUtil] VERSION is required")
+    endif()
+    if(NOT DEFINED PKG_ARGS_NAME)
+        message(FATAL_ERROR "[CPMUtil] NAME is required")
+    endif()
+    if(NOT DEFINED PKG_ARGS_REPO)
+        message(FATAL_ERROR "[CPMUtil] REPO is required")
+    endif()
+    if(NOT DEFINED PKG_ARGS_PACKAGE)
+        message(FATAL_ERROR "[CPMUtil] PACKAGE is required")
+    endif()
+
+    if (NOT DEFINED PKG_ARGS_CMAKE_FILENAME)
+        set(ARTIFACT_CMAKE ${PKG_ARGS_NAME})
+    else()
+        set(ARTIFACT_CMAKE ${PKG_ARGS_CMAKE_FILENAME})
+    endif()
+
+    if(NOT DEFINED PKG_ARGS_EXTENSION)
+        set(ARTIFACT_EXT "tar.zst")
+    else()
+        set(ARTIFACT_EXT ${PKG_ARGS_EXTENSION})
+    endif()
+
+    if (DEFINED PKG_ARGS_MIN_VERSION)
+        set(ARTIFACT_MIN_VERSION ${PKG_ARGS_MIN_VERSION})
+    endif()
+
+    if (DEFINED PKG_ARGS_DISABLED_PLATFORMS)
+        set(DISABLED_PLATFORMS ${PKG_ARGS_DISABLED_PLATFORMS})
+    endif()
+
+    # this is mildly annoying
+    set(ARTIFACT_VERSION ${PKG_ARGS_VERSION})
+    set(ARTIFACT_NAME ${PKG_ARGS_NAME})
+    set(ARTIFACT_REPO ${PKG_ARGS_REPO})
+    set(ARTIFACT_PACKAGE ${PKG_ARGS_PACKAGE})
+
+    if ((MSVC AND ARCHITECTURE_x86_64) AND NOT "windows-amd64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(windows-amd64)
+    endif()
+
+    if ((MSVC AND ARCHITECTURE_arm64) AND NOT "windows-arm64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(windows-arm64)
+    endif()
+
+    if (ANDROID AND NOT "android" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(android)
+    endif()
+
+    if(PLATFORM_SUN AND NOT "solaris" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(solaris)
+    endif()
+
+    if(PLATFORM_FREEBSD AND NOT "freebsd" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(freebsd)
+    endif()
+
+    if((PLATFORM_LINUX AND ARCHITECTURE_x86_64) AND NOT "linux" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(linux)
+    endif()
+
+    if((PLATFORM_LINUX AND ARCHITECTURE_arm64) AND NOT "linux-aarch64" IN_LIST DISABLED_PLATFORMS)
+        add_ci_package(linux-aarch64)
+    endif()
+
+    if (DEFINED ARTIFACT_DIR)
+        include(${ARTIFACT_DIR}/${ARTIFACT_CMAKE}.cmake)
+
+        set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_NAMES ${ARTIFACT_NAME})
+        set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_URLS "https://github.com/${ARTIFACT_REPO}") # TODO(crueter) other hosts?
+        set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS ${ARTIFACT_VERSION})
+
+        set(${ARTIFACT_PACKAGE}_ADDED TRUE PARENT_SCOPE)
+    else()
+        find_package(${ARTIFACT_PACKAGE} ${ARTIFACT_MIN_VERSION} REQUIRED)
+    endif()
+endfunction()

CMakeModules/DownloadExternals.cmake

@@ -29,6 +29,7 @@ function(download_bundled_external remote_path lib_name cpm_key prefix_var versi
     set(package_url "${package_base_url}${package_repo}")
     set(full_url ${package_url}${remote_path}${lib_name}${package_extension})
 
+    # TODO(crueter): DELETE THIS ENTIRELY, GLORY BE TO THE CI!
     AddPackage(
         NAME ${cpm_key}
         VERSION ${version}
@@ -49,9 +50,6 @@ function(download_win_archives)
 
     download_bundled_external("ffmpeg/" ${FFmpeg_EXT_NAME} "ffmpeg-bundled" "" 7.1.1)
 
-    # TODO(crueter): separate handling for arm64
-    set(SDL2_VER "SDL2-2.32.8")
-    download_bundled_external("sdl2/" ${SDL2_VER} "sdl2-bundled" "" 2.32.8)
     set(FORCE_WIN_ARCHIVES OFF)
 endfunction()
 

CMakeModules/FindSPIRV-Tools.cmake

@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+include(FindPackageHandleStandardArgs)
+
+find_package(PkgConfig QUIET)
+pkg_search_module(SPIRV-Tools QUIET IMPORTED_TARGET SPIRV-Tools)
+find_package_handle_standard_args(SPIRV-Tools
+    REQUIRED_VARS SPIRV-Tools_LINK_LIBRARIES
+    VERSION_VAR SPIRV-Tools_VERSION
+)
+
+if (SPIRV-Tools_FOUND AND NOT TARGET SPIRV-Tools::SPIRV-Tools)
+    if (TARGET SPIRV-Tools)
+        add_library(SPIRV-Tools::SPIRV-Tools ALIAS SPIRV-Tools)
+    else()
+        add_library(SPIRV-Tools::SPIRV-Tools ALIAS PkgConfig::SPIRV-Tools)
+    endif()
+endif()

CMakeModules/Findzstd.cmake

@@ -3,17 +3,12 @@
 
 include(FindPackageHandleStandardArgs)
 
-find_package(zstd QUIET CONFIG)
-if (zstd_CONSIDERED_CONFIGS)
-    find_package_handle_standard_args(zstd CONFIG_MODE)
-else()
-    find_package(PkgConfig QUIET)
-    pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
-    find_package_handle_standard_args(zstd
-        REQUIRED_VARS ZSTD_LINK_LIBRARIES
-        VERSION_VAR ZSTD_VERSION
-    )
-endif()
+find_package(PkgConfig QUIET)
+pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
+find_package_handle_standard_args(zstd
+    REQUIRED_VARS ZSTD_LINK_LIBRARIES
+    VERSION_VAR ZSTD_VERSION
+)
 
 if (zstd_FOUND AND NOT TARGET zstd::zstd)
     if (TARGET zstd::libzstd_shared)

cpmfile.json

@@ -0,0 +1,147 @@
+{
+    "openssl": {
+        "ci": true,
+        "package": "OpenSSL",
+        "name": "openssl",
+        "repo": "crueter-ci/OpenSSL",
+        "version": "3.5.2",
+        "min_version": "1.1.1"
+    },
+    "boost": {
+        "package": "Boost",
+        "repo": "boostorg/boost",
+        "tag": "boost-1.88.0",
+        "artifact": "boost-1.88.0-cmake.7z",
+        "hash": "e5b049e5b61964480ca816395f63f95621e66cb9bcf616a8b10e441e0e69f129e22443acb11e77bc1e8170f8e4171b9b7719891efc43699782bfcd4b3a365f01",
+        "git_version": "1.88.0",
+        "version": "1.57"
+    },
+    "fmt": {
+        "repo": "fmtlib/fmt",
+        "sha": "40626af88b",
+        "hash": "d59f06c24339f223de4ec2afeba1c67b5835a0f350a1ffa86242a72fc3e616a6b8b21798355428d4200c75287308b66634619ffa0b52ba5bd74cc01772ea1a8a",
+        "version": "8",
+        "options": [
+            "FMT_INSTALL OFF"
+        ]
+    },
+    "lz4": {
+        "name": "lz4",
+        "repo": "lz4/lz4",
+        "sha": "ebb370ca83",
+        "hash": "43600e87b35256005c0f2498fa56a77de6783937ba4cfce38c099f27c03188d097863e8a50c5779ca0a7c63c29c4f7ed0ae526ec798c1fd2e3736861b62e0a37",
+        "source_subdir": "build/cmake"
+    },
+    "nlohmann": {
+        "package": "nlohmann_json",
+        "repo": "nlohmann/json",
+        "sha": "55f93686c0",
+        "hash": "b739749b066800e21154506ea150d2c5cbce8a45344177f46f884547a1399d26753166fd0df8135269ce28cf223552b1b65cd625b88c844d54753f2434900486",
+        "version": "3.8"
+    },
+    "zlib": {
+        "package": "ZLIB",
+        "repo": "madler/zlib",
+        "sha": "51b7f2abda",
+        "hash": "16eaf1f3752489d12fd9ce30f7b5f7cbd5cb8ff53d617005a9847ae72d937f65e01e68be747f62d7ac19fd0c9aeba9956e60f16d6b465c5fdc2f3d08b4db2e6c",
+        "version": "1.2",
+        "options": [
+            "ZLIB_BUILD_SHARED OFF",
+            "ZLIB_INSTALL OFF"
+        ]
+    },
+    "zstd": {
+        "repo": "facebook/zstd",
+        "sha": "f8745da6ff",
+        "hash": "3037007f990040fe32573b46f9bef8762fd5dbeeb07ffffcbfeba51ec98167edae39bb9c87f9299efcd61c4e467c5e84f7c19f0df7799bc1fc04864a278792ee",
+        "version": "1.5",
+        "source_subdir": "build/cmake",
+        "find_args": "MODULE",
+        "options": [
+            "ZSTD_BUILD_SHARED OFF"
+        ]
+    },
+    "catch2": {
+        "package": "Catch2",
+        "repo": "catchorg/Catch2",
+        "sha": "644821ce28",
+        "hash": "f8795f98acf2c02c0db8e734cc866d5caebab4b4a306e93598b97cb3c0c728dafe8283dce27ffe8d42460e5ae7302f3f32e7e274a7f991b73511ac88eef21b1f",
+        "version": "3.0.1"
+    },
+    "enet": {
+        "repo": "lsalzman/enet",
+        "sha": "2662c0de09",
+        "hash": "3de1beb4fa3d6b1e03eda8dd1e7580694f854af3ed3975dcdabfdcdf76b97f322b9734d35ea7f185855bb490d957842b938b26da4dd2dfded509390f8d2794dd",
+        "version": "1.3",
+        "find_args": "MODULE"
+    },
+    "opus": {
+        "package": "Opus",
+        "repo": "xiph/opus",
+        "sha": "5ded705cf4",
+        "hash": "0dc89e58ddda1f3bc6a7037963994770c5806c10e66f5cc55c59286fc76d0544fe4eca7626772b888fd719f434bc8a92f792bdb350c807968b2ac14cfc04b203",
+        "version": "1.3",
+        "find_args": "MODULE",
+        "options": [
+            "OPUS_BUILD_TESTING OFF",
+            "OPUS_BUILD_PROGRAMS OFF",
+            "OPUS_INSTALL_PKG_CONFIG_MODULE OFF",
+            "OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF"
+        ]
+    },
+    "cubeb": {
+        "repo": "mozilla/cubeb",
+        "sha": "fa02160712",
+        "hash": "82d808356752e4064de48c8fecbe7856715ade1e76b53937116bf07129fc1cc5b3de5e4b408de3cd000187ba8dc32ca4109661cb7e0355a52e54bd81b9be1c61",
+        "find_args": "CONFIG",
+        "options": [
+            "USE_SANITIZERS OFF",
+            "BUILD_TESTS OFF",
+            "BUILD_TOOLS OFF",
+            "BUNDLE_SPEEX ON"
+        ]
+    },
+    "boost_headers": {
+        "repo": "boostorg/headers",
+        "sha": "0456900fad",
+        "hash": "50cd75dcdfc5f082225cdace058f47b4fb114a47585f7aee1d22236a910a80b667186254c214fa2fcebac67ae6d37ba4b6e695e1faea8affd6fd42a03cf996e3",
+        "bundled": true
+    },
+    "discord-rpc": {
+        "repo": "eden-emulator/discord-rpc",
+        "sha": "1cf7772bb6",
+        "hash": "e9b35e6f2c075823257bcd59f06fe7bb2ccce1976f44818d2e28810435ef79c712a3c4f20f40da41f691342a4058cf86b078eb7f9d9e4dae83c0547c21ec4f97"
+    },
+    "simpleini": {
+        "package": "SimpleIni",
+        "repo": "brofield/simpleini",
+        "sha": "09c21bda1d",
+        "hash": "99779ca9b6e040d36558cadf484f9ffdab5b47bcc8fc72e4d33639d1d60c0ceb4410d335ba445d72a4324e455167fd6769d99b459943aa135bec085dff2d4b7c",
+        "find_args": "MODULE"
+    },
+    "sdl2_generic": {
+        "package": "SDL2",
+        "repo": "libsdl-org/SDL",
+        "sha": "54772f345a",
+        "hash": "2a68a0e01c390043aa9d9df63d8a20a52076c88bb460ac4e0f33194ca7d9bc8fadbbcc04e7506872ac4b6354a73fbc267c036f82200da59465789b87c7d9e3a4",
+        "key": "generic",
+        "bundled": true
+    },
+    "sdl2_steamdeck": {
+        "package": "SDL2",
+        "repo": "libsdl-org/SDL",
+        "sha": "cc016b0046",
+        "hash": "34d5ef58da6a4f9efa6689c82f67badcbd741f5a4f562a9c2c30828fa839830fb07681c5dc6a7851520e261c8405a416ac0a2c2513b51984fb3b4fa4dcb3e20b",
+        "key": "steamdeck",
+        "bundled": true
+    },
+    "sdl2": {
+        "ci": true,
+        "package": "SDL2",
+        "name": "SDL2",
+        "repo": "crueter-ci/SDL2",
+        "version": "2.32.8",
+        "min_version": "2.26.4",
+        "cmake_filename": "sdl2"
+    }
+}

dist/dev.eden_emu.eden.desktop

@@ -10,7 +10,7 @@ Type=Application
 Name=Eden
 GenericName=Switch Emulator
 Comment=Nintendo Switch video game console emulator
-Icon=org.eden_emu.eden
+Icon=dev.eden_emu.eden
 TryExec=eden
 Exec=eden %f
 Categories=Game;Emulator;Qt;

dist/qt_themes/default/style.qss

@@ -95,6 +95,60 @@ QPushButton#button_reset_defaults {
     padding: 4px 8px;
 }
 
+/* QGroupBox --------------------------------------------------------------
+
+https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qgroupbox
+
+--------------------------------------------------------------------------- */
+QGroupBox {
+  border: 1px solid #32414B;
+  border-radius: 4px;
+  margin-top: 20px;
+  padding: 2px;
+}
+
+QGroupBox::title {
+  subcontrol-origin: margin;
+  subcontrol-position: top left;
+  padding-left: 3px;
+  padding-right: 5px;
+  padding-top: 2px;
+}
+
+QGroupBox::indicator {
+  margin-left: 2px;
+  height: 16px;
+  width: 16px;
+}
+
+QGroupBox::indicator:unchecked {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_unchecked.png");
+}
+
+QGroupBox::indicator:unchecked:hover, QGroupBox::indicator:unchecked:focus, QGroupBox::indicator:unchecked:pressed {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_unchecked_focus.png");
+}
+
+QGroupBox::indicator:unchecked:disabled {
+  image: url(":/qss_icons/rc/checkbox_unchecked_disabled.png");
+}
+
+QGroupBox::indicator:checked {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_checked.png");
+}
+
+QGroupBox::indicator:checked:hover, QGroupBox::indicator:checked:focus, QGroupBox::indicator:checked:pressed {
+  border: none;
+  image: url(":/qss_icons/rc/checkbox_checked_focus.png");
+}
+
+QGroupBox::indicator:checked:disabled {
+  image: url(":/qss_icons/rc/checkbox_checked_disabled.png");
+}
+
 QWidget#bottomPerGameInput,
 QWidget#topControllerApplet,
 QWidget#bottomControllerApplet,

dist/qt_themes/default_dark/style.qss

@@ -697,3 +697,29 @@ QDialog#QtSoftwareKeyboardDialog QPushButton#button_space:disabled,
 QDialog#QtSoftwareKeyboardDialog QPushButton#button_space_shift:disabled {
     image: url(:/overlay/osk_button_Y_disabled.png);
 }
+
+/* QGroupBox --------------------------------------------------------------
+
+https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qgroupbox
+
+--------------------------------------------------------------------------- */
+QGroupBox {
+  border: 1px solid #32414B;
+  border-radius: 4px;
+  margin-top: 22px;
+  padding: 2px;
+}
+
+QGroupBox::title {
+  subcontrol-origin: margin;
+  subcontrol-position: top left;
+  padding-left: 10px;
+  padding-right: 10px;
+  padding-top: 2px;
+}
+
+QGroupBox::indicator {
+  margin-left: 2px;
+  height: 16px;
+  width: 16px;
+}

dist/qt_themes/qdarkstyle/style.qss

@@ -307,7 +307,7 @@ QAbstractItemView QLineEdit {
 QGroupBox {
     border: 1px solid #54575B;
     border-radius: 2px;
-    margin-top: 12px;
+    margin-top: 20px;
     padding-top: 2px;
 }
 

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -235,10 +235,9 @@ https://doc.qt.io/qt-5/stylesheet-examples.html#customizing-qgroupbox
 
 --------------------------------------------------------------------------- */
 QGroupBox {
-  font-weight: bold;
   border: 1px solid #32414B;
   border-radius: 4px;
-  margin-top: 12px;
+  margin-top: 20px;
   padding: 2px;
 }
 

docs/CPM.md

@@ -0,0 +1,252 @@
+# CPM
+
+CPM (CMake Package Manager) is the preferred method of managing dependencies within Eden.
+
+Global Options:
+
+- `YUZU_USE_CPM` is set by default on MSVC and Android. Other platforms should use this if certain "required" system dependencies (e.g. OpenSSL) are broken or missing
+  * If this is `OFF`, required system dependencies will be searched via `find_package`, although certain externals use CPM regardless.
+- `CPMUTIL_FORCE_SYSTEM` (default `OFF`): Require all CPM dependencies to use system packages. NOT RECOMMENDED!
+  * Many packages, e.g. mcl, sirit, xbyak, discord-rpc, are not generally available as a system package.
+  * You may optionally override these (see CPMUtil section)
+- `CPMUTIL_FORCE_BUNDLED` (default `ON` on MSVC and Android, `OFF` elsewhere): Require all CPM dependencies to use bundled packages.
+
+## CPMUtil
+
+CPMUtil is a wrapper around CPM that aims to reduce boilerplate and add useful utility functions to make dependency management a piece of cake.
+
+### AddPackage
+
+`AddPackage` is the core of the CPMUtil wrapper, and is generally the lowest level you will need to go when dealing with dependencies.
+
+**Identification/Fetching**
+
+- `NAME` (required): The package name (must be the same as the `find_package` name if applicable)
+- `VERSION`: The minimum version of this package that can be used on the system
+- `GIT_VERSION`: The version found within git, only used for identification
+- `URL`: The URL to fetch.
+- `REPO`: The GitHub repo to use (`owner/repo`).
+  * Only GitHub is supported for now, though other platforms will see support at some point
+- `TAG`: The tag to fetch, if applicable.
+- `ARTIFACT`: The name of the artifact, if applicable.
+- `SHA`: Commit sha to fetch, if applicable.
+- `BRANCH`: Branch to fetch, if applicable.
+
+The following configurations are supported, in descending order of precedence:
+
+- `URL`: Bare URL download, useful for custom artifacts
+  * If this is set, `GIT_URL` or `REPO` should be set to allow the dependency viewer to link to the project's Git repository.
+  * If this is NOT set, `REPO` must be defined.
+- `REPO + TAG + ARTIFACT`: GitHub release artifact
+  * The final download URL will be `https://github.com/${REPO}/releases/download/${TAG}/${ARTIFACT}`
+  * Useful for prebuilt libraries and prefetched archives
+- `REPO + TAG`: GitHub tag archive
+  * The final download URL will be `https://github.com/${REPO}/archive/refs/tags/${TAG}.tar.gz`
+  * Useful for pinning to a specific tag, better for build identification
+- `REPO + SHA`: GitHub commit archive
+  * The final download URL will be `https://github.com/${REPO}/archive/${SHA}.zip`
+  * Useful for pinning to a specific commit
+- `REPO + BRANCH`: GitHub branch archive
+  * The final download URL will be `https://github.com/${REPO}/archive/refs/heads/${BRANCH}.zip`
+  * Generally not recommended unless the branch is frozen
+- `REPO`: GitHub master archive
+  * The final download URL will be `https://github.com/${REPO}/archive/refs/heads/master.zip`
+  * Generally not recommended unless the project is dead
+
+**Hashing**
+
+Hashing is used for verifying downloads. It's highly recommended to use these.
+
+- `HASH_ALGO` (default `SHA512`): Hash algorithm to use
+
+Hashing strategies, descending order of precedence:
+
+- `HASH`: Bare hash verification, useful for static downloads e.g. commit archives
+- `HASH_SUFFIX`: Download the hash as `${DOWNLOAD_URL}.${HASH_SUFFIX}`
+  * The downloaded hash *must* match the hash algorithm and contain nothing but the hash; no filenames or extra content.
+- `HASH_URL`: Download the hash from a separate URL
+
+**Additional Options**
+
+- `KEY`: Custom cache key to use (stored as `.cache/cpm/${packagename_lower}/${key}`)
+  * Default is based on, in descending order of precedence:
+    - First 4 characters of the sha
+    - `GIT_VERSION`, or `VERSION` if not specified
+    - Tag
+    - Otherwise, CPM defaults will be used. This is not recommended as it doesn't produce reproducible caches
+- `DOWNLOAD_ONLY`: Whether or not to configure the downloaded package via CMake
+  * Useful to turn `OFF` if the project doesn't use CMake
+- `SOURCE_SUBDIR`: Subdirectory of the project containing a CMakeLists.txt file
+- `FIND_PACKAGE_ARGUMENTS`: Arguments to pass to the `find_package` call
+- `BUNDLED_PACKAGE`: Set to `ON` to force the usage of a bundled package
+- `OPTIONS`: Options to pass to the configuration of the package
+- `PATCHES`: Patches to apply to the package, stored in `.patch/${packagename_lower}/0001-patch-name.patch` and so on
+- Other arguments can be passed to CPM as well
+
+**Extra Variables**
+
+For each added package, users may additionally force usage of the system/bundled package.
+
+- `${package}_FORCE_SYSTEM`: Require the package to be installed on the system
+- `${package}_FORCE_BUNDLED`: Force the package to be fetched and use the bundled version
+
+**Bundled/System Switching**
+
+Descending order of precedence:
+- If `${package}_FORCE_SYSTEM` is true, requires the package to be on the system
+- If `${package}_FORCE_BUNDLED` is true, forcefully uses the bundled package
+- If `CPMUTIL_FORCE_SYSTEM` is true, requires the package to be on the system
+- If `CPMUTIL_FORCE_BUNDLED` is true, forcefully uses the bundled package
+- If the `BUNDLED_PACKAGE` argument is true, forcefully uses the bundled package
+- Otherwise, CPM will search for the package first, and if not found, will use the bundled package
+
+**Identification**
+
+All dependencies must be identifiable in some way for usage in the dependency viewer. Lists are provided in descending order of precedence.
+
+URLs:
+
+- `GIT_URL`
+- `REPO` as a GitHub repository
+- `URL`
+
+Versions (bundled):
+
+- `SHA`
+- `GIT_VERSION`
+- `VERSION`
+- `TAG`
+- "unknown"
+
+If the package is a system package, AddPackage will attempt to determine the package version and append ` (system)` to the identifier. Otherwise, it will be marked as `unknown (system)`
+
+### AddCIPackage
+
+Adds a package that follows crueter's CI repository spec.
+
+- `VERSION` (required): The version to get (the tag will be `v${VERSION}`)
+- `NAME` (required): Name used within the artifacts
+- `REPO` (required): CI repository, e.g. `crueter-ci/OpenSSL`
+- `PACKAGE` (required): `find_package` package name
+- `EXTENSION`: Artifact extension (default `tar.zst`)
+- `MIN_VERSION`: Minimum version for `find_package`. Only used if platform does not support this package as a bundled artifact
+- `DISABLED_PLATFORMS`: List of platforms that lack artifacts for this package. One of:
+  * `windows-amd64`
+  * `windows-arm64`
+  * `android`
+  * `solaris`
+  * `freebsd`
+  * `linux`
+  * `linux-aarch64`
+- `CMAKE_FILENAME`: Custom CMake filename, relative to the package root (default `${PACKAGE_ROOT}/${NAME}.cmake`)
+
+### AddJsonPackage
+
+This is the recommended method of usage for CPMUtil. In each directory that utilizes `CPMUtil`, there must be a `cpmfile.json` that defines dependencies in a similar manner to the individual calls.
+
+The cpmfile is an object of objects, with each sub-object being named according to the package's identifier, e.g. `openssl`, which can then be fetched with `AddJsonPackage(<identifier>)`. Options are designed to map closely to the argument names, and are always strings unless otherwise specified.
+
+- `package` -> `NAME` (`PACKAGE` for CI), defaults to the object key
+- `repo` -> `REPO`
+- `version` -> `VERSION`
+- `ci` (bool)
+
+If `ci` is `false`:
+
+- `hash` -> `HASH`
+- `sha` -> `SHA`
+- `tag` -> `TAG`
+- `artifact` -> `ARTIFACT`
+- `git_version` -> `GIT_VERSION`
+- `source_subdir` -> `SOURCE_SUBDIR`
+- `bundled` -> `BUNDLED_PACKAGE`
+- `find_args` -> `FIND_PACKAGE_ARGUMENTS`
+- `patches` -> `PATCHES` (array)
+- `options` -> `OPTIONS` (array)
+
+Other arguments aren't currently supported. If you wish to add them, see the `AddJsonPackage` function in `CMakeModules/CPMUtil.cmake`.
+
+If `ci` is `true`:
+
+- `name` -> `NAME`, defaults to the object key
+- `extension` -> `EXTENSION`, defaults to `tar.zst`
+- `min_version` -> `MIN_VERSION`
+- `cmake_filename` -> `CMAKE_FILENAME`
+- `extension` -> `EXTENSION`
+
+### Examples
+
+In order: OpenSSL CI, Boost (tag + artifact), discord-rpc (sha + options + patches), Opus (options + find_args)
+
+```json
+{
+    "openssl": {
+        "ci": true,
+        "package": "OpenSSL",
+        "name": "openssl",
+        "repo": "crueter-ci/OpenSSL",
+        "version": "3.5.2",
+        "min_version": "1.1.1"
+    },
+    "boost": {
+        "package": "Boost",
+        "repo": "boostorg/boost",
+        "tag": "boost-1.88.0",
+        "artifact": "boost-1.88.0-cmake.7z",
+        "hash": "e5b049e5b61964480ca816395f63f95621e66cb9bcf616a8b10e441e0e69f129e22443acb11e77bc1e8170f8e4171b9b7719891efc43699782bfcd4b3a365f01",
+        "git_version": "1.88.0",
+        "version": "1.57"
+    },
+    "opus": {
+        "package": "Opus",
+        "repo": "xiph/opus",
+        "sha": "5ded705cf4",
+        "hash": "0dc89e58ddda1f3bc6a7037963994770c5806c10e66f5cc55c59286fc76d0544fe4eca7626772b888fd719f434bc8a92f792bdb350c807968b2ac14cfc04b203",
+        "version": "1.3",
+        "find_args": "MODULE",
+        "options": [
+            "OPUS_BUILD_TESTING OFF",
+            "OPUS_BUILD_PROGRAMS OFF",
+            "OPUS_INSTALL_PKG_CONFIG_MODULE OFF",
+            "OPUS_INSTALL_CMAKE_CONFIG_MODULE OFF"
+        ]
+    },
+    "discord-rpc": {
+        "repo": "discord/discord-rpc",
+        "sha": "963aa9f3e5",
+        "hash": "386e1344e9a666d730f2d335ee3aef1fd05b1039febefd51aa751b705009cc764411397f3ca08dffd46205c72f75b235c870c737b2091a4ed0c3b061f5919bde",
+        "options": [
+            "BUILD_EXAMPLES OFF"
+        ],
+        "patches": [
+            "0001-cmake-version.patch",
+            "0002-no-clang-format.patch",
+            "0003-fix-cpp17.patch"
+        ]
+    },
+}
+```
+
+### Inclusion
+
+To include CPMUtil:
+
+```cmake
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
+```
+
+You may omit the first line if you are not utilizing cpmfile.
+
+## Prefetching
+
+- To prefetch a CPM dependency (requires cpmfile):
+  * `tools/cpm-fetch.sh <packages>`
+- To prefetch all CPM dependencies:
+  * `tools/cpm-fetch-all.sh`
+
+Currently, `cpm-fetch.sh` defines the following directories for cpmfiles:
+
+`externals src/yuzu/externals externals/ffmpeg src/dynarmic/externals externals/nx_tzdb`
+
+Whenever you add a new cpmfile, update the script accordingly

docs/Development.md

@@ -1,11 +1,11 @@
 # Development
 
-* **Windows**: [Windows Building Guide](./docs/build/Windows.md)
-* **Linux**: [Linux Building Guide](./docs/build/Linux.md)
-* **Android**: [Android Building Guide](./docs/build/Android.md)
-* **Solaris**: [Solaris Building Guide](./docs/build/Solaris.md)
-* **FreeBSD**: [FreeBSD Building Guide](./docs/build/FreeBSD.md)
-* **macOS**: [macOS Building Guide](./docs/build/macOS.md)
+* **Windows**: [Windows Building Guide](./build/Windows.md)
+* **Linux**: [Linux Building Guide](./build/Linux.md)
+* **Android**: [Android Building Guide](./build/Android.md)
+* **Solaris**: [Solaris Building Guide](./build/Solaris.md)
+* **FreeBSD**: [FreeBSD Building Guide](./build/FreeBSD.md)
+* **macOS**: [macOS Building Guide](./build/macOS.md)
 
 # CPM
 
@@ -104,7 +104,7 @@ Then type `target remote localhost:1234` and type `c` (for continue) - and then
 
 ### gdb cheatsheet
 
-- `mo <cmd>`: Monitor commands, `get info`, `get fastmem` and `get mappings` are available.
+- `mo <cmd>`: Monitor commands, `get info`, `get fastmem` and `get mappings` are available. Type `mo help` for more info.
 - `detach`: Detach from remote (i.e restarting the emulator).
 - `c`: Continue
 - `p <expr>`: Print variable, `p/x <expr>` for hexadecimal.

docs/build/Linux.md

@@ -37,7 +37,7 @@ Dependencies are listed here as commands that can be copied/pasted. Of course, t
   - GCC 11 or later is required.
   
 - Ubuntu / Linux Mint / Debian:
-  - `sudo apt-get install autoconf cmake g++ gcc git glslang-tools libasound2 libboost-context-dev libglu1-mesa-dev libhidapi-dev libpulse-dev libtool libudev-dev libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xinerama0 libxcb-xkb1 libxext-dev libxkbcommon-x11-0 mesa-common-dev nasm ninja-build qt6-base-private-dev libmbedtls-dev catch2 libfmt-dev liblz4-dev nlohmann-json3-dev libzstd-dev libssl-dev libavfilter-dev libavcodec-dev libswscale-dev pkg-config zlib1g-dev`
+  - `sudo apt-get install autoconf cmake g++ gcc git glslang-tools libasound2 libboost-context-dev libglu1-mesa-dev libhidapi-dev libpulse-dev libtool libudev-dev libxcb-icccm4 libxcb-image0 libxcb-keysyms1 libxcb-render-util0 libxcb-xinerama0 libxcb-xkb1 libxext-dev libxkbcommon-x11-0 mesa-common-dev nasm ninja-build qt6-base-private-dev libmbedtls-dev catch2 libfmt-dev liblz4-dev nlohmann-json3-dev libzstd-dev libssl-dev libavfilter-dev libavcodec-dev libswscale-dev pkg-config zlib1g-dev libva-dev libvdpau-dev`
   - Ubuntu 22.04, Linux Mint 20, or Debian 12 or later is required.
   - Users need to manually specify building with QT Web Engine enabled.  This is done using the parameter `-DYUZU_USE_QT_WEB_ENGINE=ON` when running CMake.
   - Users need to manually disable building SDL2 from externals if they intend to use the version provided by their system by adding the parameters `-DYUZU_USE_EXTERNAL_SDL2=OFF`

externals/CMakeLists.txt

@@ -7,7 +7,8 @@
 # TODO(crueter): A lot of this should be moved to the root.
 # otherwise we have to do weird shenanigans with library linking and stuff
 
-# cpm
+# Explicitly include CPMUtil here since we have a separate cpmfile for externals
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
 include(CPMUtil)
 
 # Explicitly declare this option here to propagate to the oaknut CPM call
@@ -32,33 +33,16 @@ endif()
 
 # Xbyak (also used by Dynarmic, so needs to be added first)
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    if ("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
-        # Fix regset.h collisions
-        set(XBYAK_HASH 51f507b0b3)
-        set(XBYAK_SHA512SUM 4a29a3c2f97f7d5adf667a21a008be03c951fb6696b0d7ba27e7e4afa037bc76eb5e059bb84860e01baf741d4d3ac851b840cd54c99d038812fbe0f1fa6d38a4)
+    if (PLATFORM_SUN)
+        AddJsonPackage(xbyak_sun)
     else()
-        set(XBYAK_HASH 4e44f4614d)
-        set(XBYAK_SHA512SUM 5824e92159e07fa36a774aedd3b3ef3541d0241371d522cffa4ab3e1f215fa5097b1b77865b47b2481376c704fa079875557ea463ca63d0a7fd6a8a20a589e70)
+        AddJsonPackage(xbyak)
     endif()
-
-    AddPackage(
-        NAME xbyak
-        REPO "Lizzie841/xbyak"
-        SHA ${XBYAK_HASH}
-        HASH ${XBYAK_SHA512SUM}
-        BUNDLED_PACKAGE ON
-    )
 endif()
 
 # Oaknut (also used by Dynarmic, so needs to be added first)
 if (ARCHITECTURE_arm64 OR DYNARMIC_TESTS)
-    AddPackage(
-        NAME oaknut
-        VERSION 2.0.1
-        REPO "merryhime/oaknut"
-        SHA 94c726ce03
-        HASH d8d082242fa1881abce3c82f8dafa002c4e561e66a69e7fc038af67faa5eff2630f082d3d19579c88c4c9f9488e54552accc8cb90e7ce743efe043b6230c08ac
-    )
+    AddJsonPackage(oaknut)
 endif()
 
 # getopt
@@ -70,14 +54,7 @@ endif()
 add_subdirectory(glad)
 
 # mbedtls
-AddPackage(
-    NAME mbedtls
-    REPO "Mbed-TLS/mbedtls"
-    SHA "8c88150ca1"
-    HASH 769ad1e94c570671071e1f2a5c0f1027e0bf6bcdd1a80ea8ac970f2c86bc45ce4e31aa88d6d8110fc1bed1de81c48bc624df1b38a26f8b340a44e109d784a966
-    PATCHES
-        ${CMAKE_SOURCE_DIR}/.patch/mbedtls/0001-cmake-version.patch
-)
+AddJsonPackage(mbedtls)
 
 if (mbedtls_ADDED)
     target_include_directories(mbedtls PUBLIC ${mbedtls_SOURCE_DIR}/include)
@@ -94,69 +71,14 @@ if (ENABLE_LIBUSB AND NOT TARGET libusb::usb)
     add_subdirectory(libusb)
 endif()
 
-# SDL2
-if (NOT YUZU_USE_BUNDLED_SDL2)
-    if (NOT WIN32)
-        # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
-        # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
-        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
-        # CPUinfo also required for SDL Audio, at least until 2.28.0 (see https://github.com/libsdl-org/SDL/issues/7809)
-        set(SDL_UNUSED_SUBSYSTEMS
-            File Filesystem
-            Locale Power Render)
-        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
-          string(TOUPPER ${_SUB} _OPT)
-          set(SDL_${_OPT} OFF)
-        endforeach()
-
-        set(HIDAPI ON)
-    endif()
-    if (APPLE)
-        set(SDL_FILE ON)
-    endif()
-
-    if ("${YUZU_SYSTEM_PROFILE}" STREQUAL "steamdeck")
-        set(SDL_HASH cc016b0046)
-        set(SDL_PIPEWIRE OFF) # build errors out with this on
-        set(SDL_SHA512SUM 34d5ef58da6a4f9efa6689c82f67badcbd741f5a4f562a9c2c30828fa839830fb07681c5dc6a7851520e261c8405a416ac0a2c2513b51984fb3b4fa4dcb3e20b)
-    elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")
-        set(SDL_HASH d310b5679f)
-        set(SDL_SHA512SUM cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e)
-    else()
-        set(SDL_HASH 2e4c12cd2c)
-        set(SDL_SHA512SUM d95af47f469a312876f8ab361074a1e7b8083db19935a102d9c6e5887ace6008e64475a8c54b00164b40cad86492bb1b2366084efdd0b2555e5fea6d9c5da80e)
-    endif()
-
-    AddPackage(
-        NAME SDL2
-        REPO "libsdl-org/SDL"
-        SHA ${SDL_HASH}
-        HASH ${SDL_SHA512SUM}
-        KEY ${YUZU_SYSTEM_PROFILE}
-        BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_SDL2}
-    )
-endif()
-
 # Sirit
 # TODO(crueter): spirv-tools doesn't work w/ system
 set(SPIRV_WERROR OFF)
-AddPackage(
-    NAME SPIRV-Headers
-    REPO "KhronosGroup/SPIRV-Headers"
-    SHA 4e209d3d7e
-    HASH f48bbe18341ed55ea0fe280dbbbc0a44bf222278de6e716e143ca1e95ca320b06d4d23d6583fbf8d03e1428f3dac8fa00e5b82ddcd6b425e6236d85af09550a4
-)
+AddJsonPackage(spirv-headers)
 
-AddPackage(
-    NAME sirit
-    REPO "eden-emulator/sirit"
-    SHA db1f1e8ab5
-    HASH 73eb3a042848c63a10656545797e85f40d142009dfb7827384548a385e1e28e1ac72f42b25924ce530d58275f8638554281e884d72f9c7aaf4ed08690a414b05
-    OPTIONS
-        "SIRIT_USE_SYSTEM_SPIRV_HEADERS ON"
-)
+AddJsonPackage(sirit)
 
-if(MSVC AND USE_CCACHE AND TARGET sirit)
+if(MSVC AND USE_CCACHE AND sirit_ADDED)
     get_target_property(_opts sirit COMPILE_OPTIONS)
     list(FILTER _opts EXCLUDE REGEX "/Zi")
     list(APPEND _opts "/Z7")
@@ -165,35 +87,17 @@ endif()
 
 # httplib
 if (ENABLE_WEB_SERVICE OR ENABLE_QT_UPDATE_CHECKER)
-    AddPackage(
-        NAME httplib
-        REPO "yhirose/cpp-httplib"
-        SHA a609330e4c
-        HASH dd3fd0572f8367d8549e1319fd98368b3e75801a293b0c3ac9b4adb806473a4506a484b3d389dc5bee5acc460cb90af7a20e5df705a1696b56496b30b9ce7ed2
-        OPTIONS
-            "HTTPLIB_REQUIRE_OPENSSL ${ENABLE_OPENSSL}"
-    )
+    AddJsonPackage(httplib)
 endif()
 
 # cpp-jwt
 if (ENABLE_WEB_SERVICE)
-    AddPackage(
-        NAME cpp-jwt
-        VERSION 1.4
-        REPO "arun11299/cpp-jwt"
-        SHA a54fa08a3b
-        HASH a90f7e594ada0c7e49d5ff9211c71097534e7742a8e44bf0851b0362642a7271d53f5d83d04eeaae2bad17ef3f35e09e6818434d8eaefa038f3d1f7359d0969a
-        FIND_PACKAGE_ARGUMENTS "CONFIG"
-        OPTIONS
-            "CPP_JWT_BUILD_EXAMPLES OFF"
-            "CPP_JWT_BUILD_TESTS OFF"
-            "CPP_JWT_USE_VENDORED_NLOHMANN_JSON OFF"
-        PATCHES
-            ${CMAKE_SOURCE_DIR}/.patch/cpp-jwt/0001-no-install.patch
-            ${CMAKE_SOURCE_DIR}/.patch/cpp-jwt/0002-missing-decl.patch
-    )
+    AddJsonPackage(cpp-jwt)
 endif()
 
+# unordered_dense
+AddJsonPackage(unordered-dense)
+
 # FFMpeg
 if (YUZU_USE_BUNDLED_FFMPEG)
     add_subdirectory(ffmpeg)
@@ -207,47 +111,37 @@ endif()
 
 # TODO(crueter): Vk1.4 impl
 
-AddPackage(
-    NAME VulkanHeaders
-    VERSION 1.3.274
-    REPO "KhronosGroup/Vulkan-Headers"
-    SHA 89268a6d17
-    HASH 3ab349f74298ba72cafb8561015690c0674d428a09fb91ccd3cd3daca83650d190d46d33fd97b0a8fd4223fe6df2bcabae89136fbbf7c0bfeb8776f9448304c8
+AddJsonPackage(
+    NAME vulkan-headers
     BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_VULKAN_HEADERS}
 )
 
 # Vulkan-Utility-Libraries
-AddPackage(
-    NAME VulkanUtilityLibraries
-    REPO "KhronosGroup/Vulkan-Utility-Libraries"
-    SHA df2e358152
-    HASH 3e468c3d9ff93f6d418d71e5527abe0a12c8c7ab5b0b52278bbbee4d02bb87e99073906729b727e0147242b7e3fd5dedf68b803f1878cb4c0e4f730bc2238d79
+AddJsonPackage(
+    NAME vulkan-utility-libraries
     BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_VULKAN_UTILITY_LIBRARIES}
 )
 
-# SPIRV-Tools
-if (YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS)
-    AddPackage(
-        NAME SPIRV-Tools
-        REPO "KhronosGroup/SPIRV-Tools"
-        SHA 40eb301f32
-        HASH 58d0fb1047d69373cf24c73e6f78c73a72a6cca3b4df1d9f083b9dcc0962745ef154abf3dbe9b3623b835be20c6ec769431cf11733349f45e7568b3525f707aa
-        OPTIONS
-            "SPIRV_SKIP_EXECUTABLES ON"
-    )
+# SPIRV Tools
+AddJsonPackage(
+    NAME spirv-tools
+    BUNDLED_PACKAGE ${YUZU_USE_EXTERNAL_VULKAN_SPIRV_TOOLS}
+)
+
+if (SPIRV-Tools_ADDED)
+    add_library(SPIRV-Tools::SPIRV-Tools ALIAS SPIRV-Tools-static)
+    target_link_libraries(SPIRV-Tools-static PRIVATE SPIRV-Tools-opt SPIRV-Tools-link)
 endif()
 
 # TZDB (Time Zone Database)
 add_subdirectory(nx_tzdb)
 
 # VMA
-AddPackage(
-    NAME VulkanMemoryAllocator
-    REPO "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator"
-    SHA 1076b348ab
-    HASH a46b44e4286d08cffda058e856c47f44c7fed3da55fe9555976eb3907fdcc20ead0b1860b0c38319cda01dbf9b1aa5d4b4038c7f1f8fbd97283d837fa9af9772
-    FIND_PACKAGE_ARGUMENTS "CONFIG"
-)
+AddJsonPackage(vulkan-memory-allocator)
+
+if (VulkanMemoryAllocator_ADDED AND MSVC)
+    target_compile_options(VulkanMemoryAllocator INTERFACE /wd4189)
+endif()
 
 if (NOT TARGET LLVM::Demangle)
     add_library(demangle demangle/ItaniumDemangle.cpp)
@@ -277,17 +171,8 @@ if (NOT TARGET RenderDoc::API)
     add_library(RenderDoc::API ALIAS renderdoc)
 endif()
 
-if (ANDROID)
-    if (ARCHITECTURE_arm64)
-        AddPackage(
-            NAME libadrenotools
-            REPO "bylaws/libadrenotools"
-            SHA 8fae8ce254
-            HASH c74fa855f0edebbf25c9bce40b00966daa2447bfc5e15f0cf1a95f86cbf70fc6b02590707edbde16328a0a2a4fb9a1fc419d2dfc22a4a4150971be91892d4edb
-            PATCHES
-                ${CMAKE_SOURCE_DIR}/.patch/libadrenotools/0001-linkerns-cpm.patch
-        )
-    endif()
+if (ANDROID AND ARCHITECTURE_arm64)
+    AddJsonPackage(libadrenotools)
 endif()
 
 if (UNIX AND NOT APPLE AND NOT TARGET gamemode::headers)
@@ -310,6 +195,7 @@ if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
         _CRT_NONSTDC_NO_DEPRECATE
     )
 
+    # TODO
     AddPackage(
         NAME breakpad
         URL "google/breakpad"
@@ -410,13 +296,7 @@ endif()
 
 # oboe
 if (ANDROID)
-    AddPackage(
-        NAME oboe
-        REPO "google/oboe"
-        SHA 2bc873e53c
-        HASH 02329058a7f9cf7d5039afaae5ab170d9f42f60f4c01e21eaf4f46073886922b057a9ae30eeac040b3ac182f51b9c1bfe9fe1050a2c9f6ce567a1a9a0ec2c768
-        BUNDLED_PACKAGE ON
-    )
+    AddJsonPackage(oboe)
 
     add_library(oboe::oboe ALIAS oboe)
 endif()

externals/cpmfile.json

@@ -0,0 +1,122 @@
+{
+    "mbedtls": {
+        "repo": "Mbed-TLS/mbedtls",
+        "sha": "8c88150ca1",
+        "hash": "769ad1e94c570671071e1f2a5c0f1027e0bf6bcdd1a80ea8ac970f2c86bc45ce4e31aa88d6d8110fc1bed1de81c48bc624df1b38a26f8b340a44e109d784a966",
+        "patches": [
+            "0001-cmake-version.patch"
+        ]
+    },
+    "spirv-headers": {
+        "package": "SPIRV-Headers",
+        "repo": "KhronosGroup/SPIRV-Headers",
+        "sha": "4e209d3d7e",
+        "hash": "f48bbe18341ed55ea0fe280dbbbc0a44bf222278de6e716e143ca1e95ca320b06d4d23d6583fbf8d03e1428f3dac8fa00e5b82ddcd6b425e6236d85af09550a4"
+    },
+    "sirit": {
+        "repo": "eden-emulator/sirit",
+        "sha": "db1f1e8ab5",
+        "hash": "73eb3a042848c63a10656545797e85f40d142009dfb7827384548a385e1e28e1ac72f42b25924ce530d58275f8638554281e884d72f9c7aaf4ed08690a414b05",
+        "options": [
+            "SIRIT_USE_SYSTEM_SPIRV_HEADERS ON"
+        ]
+    },
+    "httplib": {
+        "repo": "yhirose/cpp-httplib",
+        "sha": "a609330e4c",
+        "hash": "dd3fd0572f8367d8549e1319fd98368b3e75801a293b0c3ac9b4adb806473a4506a484b3d389dc5bee5acc460cb90af7a20e5df705a1696b56496b30b9ce7ed2"
+    },
+    "cpp-jwt": {
+        "version": "1.4",
+        "repo": "arun11299/cpp-jwt",
+        "sha": "a54fa08a3b",
+        "hash": "a90f7e594ada0c7e49d5ff9211c71097534e7742a8e44bf0851b0362642a7271d53f5d83d04eeaae2bad17ef3f35e09e6818434d8eaefa038f3d1f7359d0969a",
+        "find_args": "CONFIG",
+        "options": [
+            "CPP_JWT_BUILD_EXAMPLES OFF",
+            "CPP_JWT_BUILD_TESTS OFF",
+            "CPP_JWT_USE_VENDORED_NLOHMANN_JSON OFF"
+        ],
+        "patches": [
+            "0001-no-install.patch",
+            "0002-missing-decl.patch"
+        ]
+    },
+    "vulkan-headers": {
+        "package": "VulkanHeaders",
+        "version": "1.3.274",
+        "repo": "KhronosGroup/Vulkan-Headers",
+        "sha": "89268a6d17",
+        "hash": "3ab349f74298ba72cafb8561015690c0674d428a09fb91ccd3cd3daca83650d190d46d33fd97b0a8fd4223fe6df2bcabae89136fbbf7c0bfeb8776f9448304c8"
+    },
+    "vulkan-utility-libraries": {
+        "package": "VulkanUtilityLibraries",
+        "repo": "KhronosGroup/Vulkan-Utility-Libraries",
+        "sha": "df2e358152",
+        "hash": "3e468c3d9ff93f6d418d71e5527abe0a12c8c7ab5b0b52278bbbee4d02bb87e99073906729b727e0147242b7e3fd5dedf68b803f1878cb4c0e4f730bc2238d79"
+    },
+    "vulkan-memory-allocator": {
+        "package": "VulkanMemoryAllocator",
+        "repo": "GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator",
+        "sha": "1076b348ab",
+        "hash": "a46b44e4286d08cffda058e856c47f44c7fed3da55fe9555976eb3907fdcc20ead0b1860b0c38319cda01dbf9b1aa5d4b4038c7f1f8fbd97283d837fa9af9772",
+        "find_args": "CONFIG"
+    },
+    "spirv-tools": {
+        "package": "SPIRV-Tools",
+        "repo": "KhronosGroup/SPIRV-Tools",
+        "sha": "40eb301f32",
+        "hash": "58d0fb1047d69373cf24c73e6f78c73a72a6cca3b4df1d9f083b9dcc0962745ef154abf3dbe9b3623b835be20c6ec769431cf11733349f45e7568b3525f707aa",
+        "find_args": "MODULE",
+        "options": [
+            "SPIRV_SKIP_EXECUTABLES ON"
+        ]
+    },
+    "xbyak_sun": {
+        "package": "xbyak",
+        "repo": "herumi/xbyak",
+        "sha": "9bb219333a",
+        "hash": "303165d45c8c19387ec49d9fda7d7a4e0d86d4c0153898c23f25ce2d58ece567f44c0bbbfe348239b933edb6e1a1e34f4bc1c0ab3a285bee5da0e548879387b0",
+        "bundled": true
+    },
+    "xbyak": {
+        "package": "xbyak",
+        "repo": "herumi/xbyak",
+        "sha": "4e44f4614d",
+        "hash": "5824e92159e07fa36a774aedd3b3ef3541d0241371d522cffa4ab3e1f215fa5097b1b77865b47b2481376c704fa079875557ea463ca63d0a7fd6a8a20a589e70",
+        "bundled": true
+    },
+    "oaknut": {
+        "version": "2.0.1",
+        "repo": "merryhime/oaknut",
+        "sha": "94c726ce03",
+        "hash": "d8d082242fa1881abce3c82f8dafa002c4e561e66a69e7fc038af67faa5eff2630f082d3d19579c88c4c9f9488e54552accc8cb90e7ce743efe043b6230c08ac"
+    },
+    "libadrenotools": {
+        "repo": "bylaws/libadrenotools",
+        "sha": "8fae8ce254",
+        "hash": "c74fa855f0edebbf25c9bce40b00966daa2447bfc5e15f0cf1a95f86cbf70fc6b02590707edbde16328a0a2a4fb9a1fc419d2dfc22a4a4150971be91892d4edb",
+        "patches": [
+            "0001-linkerns-cpm.patch"
+        ]
+    },
+    "oboe": {
+        "repo": "google/oboe",
+        "sha": "2bc873e53c",
+        "hash": "02329058a7f9cf7d5039afaae5ab170d9f42f60f4c01e21eaf4f46073886922b057a9ae30eeac040b3ac182f51b9c1bfe9fe1050a2c9f6ce567a1a9a0ec2c768",
+        "bundled": true
+    },
+    "unordered-dense": {
+        "package": "unordered_dense",
+        "repo": "martinus/unordered_dense",
+        "sha": "73f3cbb237",
+        "hash": "c08c03063938339d61392b687562909c1a92615b6ef39ec8df19ea472aa6b6478e70d7d5e33d4a27b5d23f7806daf57fe1bacb8124c8a945c918c7663a9e8532",
+        "find_args": "CONFIG",
+        "options": [
+            "UNORDERED_DENSE_INSTALL OFF"
+        ],
+        "patches": [
+            "0001-cmake.patch"
+        ]
+    }
+}

externals/ffmpeg/CMakeLists.txt

@@ -1,6 +1,10 @@
 # SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+# Explicitly include CPMUtil here since we have a separate cpmfile for ffmpeg
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
+
 if (NOT WIN32 AND NOT ANDROID)
     # Build FFmpeg from externals
     message(STATUS "Using FFmpeg from externals")
@@ -19,13 +23,7 @@ if (NOT WIN32 AND NOT ANDROID)
         message(FATAL_ERROR "Required program `autoconf` not found.")
     endif()
 
-    AddPackage(
-        NAME ffmpeg
-        REPO "FFmpeg/FFmpeg"
-        SHA c2184b65d2
-        HASH 2a89d664119debbb3c006ab1c48d5d7f26e889f4a65ad2e25c8b0503308295123d5a9c5c78bf683aef5ff09acef8c3fc2837f22d3e8c611528b933bf03bcdd97
-        SYSTEM_PACKAGE OFF
-    )
+    AddJsonPackage(ffmpeg)
 
     set(FFmpeg_PREFIX ${ffmpeg_SOURCE_DIR})
     set(FFmpeg_BUILD_DIR ${ffmpeg_BINARY_DIR})
@@ -65,32 +63,46 @@ if (NOT WIN32 AND NOT ANDROID)
     set(FFmpeg_HWACCEL_INCLUDE_DIRS)
     set(FFmpeg_HWACCEL_LDFLAGS)
 
+    if (NOT APPLE)
+        # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
+        if(PLATFORM_SUN)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                X11
+                "/usr/lib/xorg/amd64/libdrm.so")
+        else()
+            pkg_check_modules(LIBDRM libdrm REQUIRED)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                ${LIBDRM_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${LIBDRM_INCLUDE_DIRS})
+        endif()
+        list(APPEND FFmpeg_HWACCEL_FLAGS
+            --enable-libdrm)
+    endif()
+
     if(LIBVA_FOUND)
-        pkg_check_modules(LIBDRM libdrm REQUIRED)
         find_package(X11 REQUIRED)
         pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
         pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES
-            ${LIBDRM_LIBRARIES}
             ${X11_LIBRARIES}
             ${LIBVA-DRM_LIBRARIES}
             ${LIBVA-X11_LIBRARIES}
             ${LIBVA_LIBRARIES})
-        set(FFmpeg_HWACCEL_FLAGS
+        list(APPEND FFmpeg_HWACCEL_FLAGS
             --enable-hwaccel=h264_vaapi
             --enable-hwaccel=vp8_vaapi
-            --enable-hwaccel=vp9_vaapi
-            --enable-libdrm)
+            --enable-hwaccel=vp9_vaapi)
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-            ${LIBDRM_INCLUDE_DIRS}
             ${X11_INCLUDE_DIRS}
             ${LIBVA-DRM_INCLUDE_DIRS}
             ${LIBVA-X11_INCLUDE_DIRS}
             ${LIBVA_INCLUDE_DIRS}
         )
-        message(STATUS "VA-API found")
+        message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
     else()
-        set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+        message(WARNING "ffmpeg: libva-dev not found, disabling Video Aceleraion API (VA-API)...")
     endif()
 
     if (FFNVCODEC_FOUND)
@@ -105,7 +117,7 @@ if (NOT WIN32 AND NOT ANDROID)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${FFNVCODEC_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${FFNVCODEC_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${FFNVCODEC_LDFLAGS})
-        message(STATUS "ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
+        message(STATUS "ffmpeg: ffnvcodec libraries version ${FFNVCODEC_VERSION} found")
         # ffnvenc could load CUDA libraries at the runtime using dlopen/dlsym or LoadLibrary/GetProcAddress
         # here we handle the hard-linking senario where CUDA is linked during compilation
         if (CUDA_FOUND)
@@ -114,7 +126,7 @@ if (NOT WIN32 AND NOT ANDROID)
             list(APPEND FFmpeg_HWACCEL_LIBRARIES ${CUDA_LIBRARIES})
             list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${CUDA_INCLUDE_DIRS})
             list(APPEND FFmpeg_HWACCEL_LDFLAGS ${CUDA_LDFLAGS})
-            message(STATUS "CUDA libraries found, hard-linking will be performed")
+            message(STATUS "ffmpeg: CUDA libraries found, hard-linking will be performed")
         endif(CUDA_FOUND)
     endif()
 
@@ -127,9 +139,10 @@ if (NOT WIN32 AND NOT ANDROID)
         list(APPEND FFmpeg_HWACCEL_LIBRARIES ${VDPAU_LIBRARIES})
         list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS ${VDPAU_INCLUDE_DIRS})
         list(APPEND FFmpeg_HWACCEL_LDFLAGS ${VDPAU_LDFLAGS})
-        message(STATUS "vdpau libraries version ${VDPAU_VERSION} found")
+        message(STATUS "ffmpeg: vdpau libraries version ${VDPAU_VERSION} found")
     else()
         list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vdpau)
+        message(WARNING "ffmpeg: libvdpau-dev not found, disabling Video Decode and Presentation API for Unix (VDPAU)...")
     endif()
 
     find_program(BASH_PROGRAM bash REQUIRED)

externals/ffmpeg/cpmfile.json

@@ -0,0 +1,8 @@
+{
+    "ffmpeg": {
+        "repo": "FFmpeg/FFmpeg",
+        "sha": "c2184b65d2",
+        "hash": "2a89d664119debbb3c006ab1c48d5d7f26e889f4a65ad2e25c8b0503308295123d5a9c5c78bf683aef5ff09acef8c3fc2837f22d3e8c611528b933bf03bcdd97",
+        "bundled": true
+    }
+}

externals/nx_tzdb/CMakeLists.txt

@@ -1,6 +1,13 @@
+# SPDX-FileCopyrightText: 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
 # SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
+# Explicitly include CPMUtil here since we have a separate cpmfile for nx_tzdb
+set(CPMUTIL_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json)
+include(CPMUtil)
+
 set(NX_TZDB_INCLUDE_DIR "${CMAKE_CURRENT_BINARY_DIR}/include")
 
 add_library(nx_tzdb INTERFACE)
@@ -11,33 +18,38 @@ find_program(DATE_PROG date)
 
 set(CAN_BUILD_NX_TZDB true)
 
-if (NOT GIT)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (NOT GNU_MAKE)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (NOT DATE_PROG)
-    set(CAN_BUILD_NX_TZDB false)
-endif()
-if (CMAKE_SYSTEM_NAME STREQUAL "Windows" OR ANDROID)
+if (NOT (GIT AND GNU_MAKE AND DATE_PROG) OR CMAKE_SYSTEM_NAME STREQUAL "Windows" OR ANDROID)
     # tzdb_to_nx currently requires a posix-compliant host
     # MinGW and Android are handled here due to the executable format being different from the host system
     # TODO (lat9nq): cross-compiling support
+
     set(CAN_BUILD_NX_TZDB false)
 endif()
 
-set(NX_TZDB_VERSION "250725")
-set(NX_TZDB_ARCHIVE "${CPM_SOURCE_CACHE}/nx_tzdb/${NX_TZDB_VERSION}.zip")
+if (CAN_BUILD_NX_TZDB AND NOT YUZU_DOWNLOAD_TIME_ZONE_DATA)
+    message(FATAL_ERROR "Building tzdb is currently unsupported. Check back later.")
+    add_subdirectory(tzdb_to_nx)
+    add_dependencies(nx_tzdb x80e)
 
-set(NX_TZDB_ROMFS_DIR "${CPM_SOURCE_CACHE}/nx_tzdb/tz")
+    set(NX_TZDB_BASE_DIR "${NX_TZDB_DIR}")
+    set(NX_TZDB_TZ_DIR "${NX_TZDB_BASE_DIR}/zoneinfo")
+endif()
+
+# TODO(crueter): This is a terrible solution, but MSVC fails to link without it
+# Need to investigate further but I still can't reproduce...
+if (MSVC)
+    set(NX_TZDB_VERSION "250725")
+    set(NX_TZDB_ARCHIVE "${CPM_SOURCE_CACHE}/nx_tzdb/${NX_TZDB_VERSION}.zip")
+
+    set(NX_TZDB_BASE_DIR "${CPM_SOURCE_CACHE}/nx_tzdb/tz")
+    set(NX_TZDB_TZ_DIR "${NX_TZDB_BASE_DIR}/zoneinfo")
 
-if ((NOT CAN_BUILD_NX_TZDB OR YUZU_DOWNLOAD_TIME_ZONE_DATA) AND NOT EXISTS ${NX_TZDB_ROMFS_DIR})
     set(NX_TZDB_DOWNLOAD_URL "https://github.com/crueter/tzdb_to_nx/releases/download/${NX_TZDB_VERSION}/${NX_TZDB_VERSION}.zip")
 
     message(STATUS "Downloading time zone data from ${NX_TZDB_DOWNLOAD_URL}...")
     file(DOWNLOAD ${NX_TZDB_DOWNLOAD_URL} ${NX_TZDB_ARCHIVE}
         STATUS NX_TZDB_DOWNLOAD_STATUS)
+
     list(GET NX_TZDB_DOWNLOAD_STATUS 0 NX_TZDB_DOWNLOAD_STATUS_CODE)
     if (NOT NX_TZDB_DOWNLOAD_STATUS_CODE EQUAL 0)
         message(FATAL_ERROR "Time zone data download failed (status code ${NX_TZDB_DOWNLOAD_STATUS_CODE})")
@@ -47,13 +59,17 @@ if ((NOT CAN_BUILD_NX_TZDB OR YUZU_DOWNLOAD_TIME_ZONE_DATA) AND NOT EXISTS ${NX_
         INPUT
             ${NX_TZDB_ARCHIVE}
         DESTINATION
-            ${NX_TZDB_ROMFS_DIR})
-elseif (CAN_BUILD_NX_TZDB AND NOT YUZU_DOWNLOAD_TIME_ZONE_DATA)
-    # TODO(crueter): this sucked to do with cpm, see if i can get it to work again
-    add_subdirectory(tzdb_to_nx)
-    add_dependencies(nx_tzdb x80e)
+            ${NX_TZDB_BASE_DIR})
+else()
+    message(STATUS "Downloading time zone data...")
+    AddJsonPackage(tzdb)
 
-    set(NX_TZDB_ROMFS_DIR "${NX_TZDB_DIR}")
+    target_include_directories(nx_tzdb
+        INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include
+        INTERFACE ${NX_TZDB_INCLUDE_DIR})
+
+    set(NX_TZDB_BASE_DIR "${CPM_SOURCE_CACHE}/nx_tzdb")
+    set(NX_TZDB_TZ_DIR "${nx_tzdb_SOURCE_DIR}")
 endif()
 
 target_include_directories(nx_tzdb
@@ -78,25 +94,25 @@ function(CreateHeader ZONE_PATH HEADER_NAME)
     target_sources(nx_tzdb PRIVATE ${HEADER_PATH})
 endfunction()
 
-CreateHeader(${NX_TZDB_ROMFS_DIR} base)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo zoneinfo)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Africa africa)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America america)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Argentina america_argentina)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Indiana america_indiana)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/Kentucky america_kentucky)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/America/North_Dakota america_north_dakota)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Antarctica antarctica)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Arctic arctic)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Asia asia)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Atlantic atlantic)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Australia australia)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Brazil brazil)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Canada canada)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Chile chile)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Etc etc)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Europe europe)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Indian indian)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Mexico mexico)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/Pacific pacific)
-CreateHeader(${NX_TZDB_ROMFS_DIR}/zoneinfo/US us)
+CreateHeader(${NX_TZDB_BASE_DIR} base)
+CreateHeader(${NX_TZDB_TZ_DIR} zoneinfo)
+CreateHeader(${NX_TZDB_TZ_DIR}/Africa africa)
+CreateHeader(${NX_TZDB_TZ_DIR}/America america)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/Argentina america_argentina)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/Indiana america_indiana)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/Kentucky america_kentucky)
+CreateHeader(${NX_TZDB_TZ_DIR}/America/North_Dakota america_north_dakota)
+CreateHeader(${NX_TZDB_TZ_DIR}/Antarctica antarctica)
+CreateHeader(${NX_TZDB_TZ_DIR}/Arctic arctic)
+CreateHeader(${NX_TZDB_TZ_DIR}/Asia asia)
+CreateHeader(${NX_TZDB_TZ_DIR}/Atlantic atlantic)
+CreateHeader(${NX_TZDB_TZ_DIR}/Australia australia)
+CreateHeader(${NX_TZDB_TZ_DIR}/Brazil brazil)
+CreateHeader(${NX_TZDB_TZ_DIR}/Canada canada)
+CreateHeader(${NX_TZDB_TZ_DIR}/Chile chile)
+CreateHeader(${NX_TZDB_TZ_DIR}/Etc etc)
+CreateHeader(${NX_TZDB_TZ_DIR}/Europe europe)
+CreateHeader(${NX_TZDB_TZ_DIR}/Indian indian)
+CreateHeader(${NX_TZDB_TZ_DIR}/Mexico mexico)
+CreateHeader(${NX_TZDB_TZ_DIR}/Pacific pacific)
+CreateHeader(${NX_TZDB_TZ_DIR}/US us)

externals/nx_tzdb/cpmfile.json

@@ -0,0 +1,8 @@
+{
+    "tzdb": {
+        "package": "nx_tzdb",
+        "url": "https://github.com/crueter/tzdb_to_nx/releases/download/250725/250725.zip",
+        "hash": "8f60b4b29f285e39c0443f3d5572a73780f3dbfcfd5b35004451fadad77f3a215b2e2aa8d0fffe7e348e2a7b0660882b35228b6178dda8804a14ce44509fd2ca",
+        "version": "250725"
+    }
+}

src/android/app/build.gradle.kts

@@ -30,8 +30,8 @@ val autoVersion = (((System.currentTimeMillis() / 1000) - 1451606400) / 10).toIn
 android {
     namespace = "org.yuzu.yuzu_emu"
 
-    compileSdkVersion = "android-35"
-    ndkVersion = "26.1.10909125"
+    compileSdkVersion = "android-36"
+    ndkVersion = "28.2.13676358"
 
     buildFeatures {
         viewBinding = true
@@ -151,7 +151,7 @@ android {
             create("genshinSpoof") {
                 dimension = "version"
                 resValue("string", "app_name_suffixed", "Eden Optimised")
-                applicationId = "com.miHoYo.Yuanshen" 
+                applicationId = "com.miHoYo.Yuanshen"
             }
         }
     }
@@ -173,9 +173,13 @@ android {
                     "-DENABLE_OPENSSL=ON",
                     "-DANDROID_ARM_NEON=true", // cryptopp requires Neon to work
                     "-DYUZU_USE_CPM=ON",
+                    "-DCPMUTIL_FORCE_BUNDLED=ON",
                     "-DYUZU_USE_BUNDLED_FFMPEG=ON",
                     "-DYUZU_ENABLE_LTO=ON",
-                    "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+                    "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON",
+                    "-DBUILD_TESTING=OFF",
+                    "-DYUZU_TESTS=OFF",
+                    "-DDYNARMIC_TESTS=OFF"
                 )
 
                 abiFilters("arm64-v8a")

src/android/app/src/main/java/org/yuzu/yuzu_emu/adapters/GameAdapter.kt

@@ -36,6 +36,9 @@ import androidx.core.net.toUri
 import androidx.core.content.edit
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
 import org.yuzu.yuzu_emu.NativeLibrary
+import org.yuzu.yuzu_emu.features.settings.model.BooleanSetting
+import org.yuzu.yuzu_emu.features.settings.model.Settings
+import org.yuzu.yuzu_emu.utils.NativeConfig
 
 class GameAdapter(private val activity: AppCompatActivity) :
     AbstractDiffAdapter<Game, GameAdapter.GameViewHolder>(exact = false) {
@@ -229,6 +232,8 @@ class GameAdapter(private val activity: AppCompatActivity) :
                 binding.root.findNavController().navigate(action)
             }
 
+            val preferences = PreferenceManager.getDefaultSharedPreferences(YuzuApplication.appContext)
+
             if (NativeLibrary.gameRequiresFirmware(game.programId) && !NativeLibrary.isFirmwareAvailable()) {
                 MaterialAlertDialogBuilder(activity)
                     .setTitle(R.string.loader_requires_firmware)
@@ -243,6 +248,23 @@ class GameAdapter(private val activity: AppCompatActivity) :
                     }
                     .setNegativeButton(android.R.string.cancel) { _, _ -> }
                     .show()
+            } else if (BooleanSetting.DISABLE_NCA_VERIFICATION.getBoolean(false) && !preferences.getBoolean(
+                    Settings.PREF_HIDE_NCA_POPUP, false)) {
+                MaterialAlertDialogBuilder(activity)
+                    .setTitle(R.string.nca_verification_disabled)
+                    .setMessage(activity.getString(R.string.nca_verification_disabled_description))
+                    .setPositiveButton(android.R.string.ok) { _, _ ->
+                        launch()
+                    }
+                    .setNeutralButton(R.string.dont_show_again) { _, _ ->
+                        preferences.edit {
+                            putBoolean(Settings.PREF_HIDE_NCA_POPUP, true)
+                        }
+
+                        launch()
+                    }
+                    .setNegativeButton(android.R.string.cancel) { _, _ -> }
+                    .show()
             } else {
                 launch()
             }

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

@@ -18,6 +18,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     USE_FAST_CPU_TIME("use_fast_cpu_time"),
     USE_CUSTOM_CPU_TICKS("use_custom_cpu_ticks"),
     SKIP_CPU_INNER_INVALIDATION("skip_cpu_inner_invalidation"),
+    CPUOPT_UNSAFE_HOST_MMU("cpuopt_unsafe_host_mmu"),
     USE_DOCKED_MODE("use_docked_mode"),
     USE_AUTO_STUB("use_auto_stub"),
     RENDERER_USE_DISK_SHADER_CACHE("use_disk_shader_cache"),
@@ -34,6 +35,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_SAMPLE_SHADING("sample_shading"),
     PICTURE_IN_PICTURE("picture_in_picture"),
     USE_CUSTOM_RTC("custom_rtc_enabled"),
+    DISABLE_NCA_VERIFICATION("disable_nca_verification"),
     BLACK_BACKGROUNDS("black_backgrounds"),
     JOYSTICK_REL_CENTER("joystick_rel_center"),
     DPAD_SLIDE("dpad_slide"),
@@ -65,10 +67,11 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     SHOW_POWER_INFO("show_power_info"),
     SHOW_SHADERS_BUILDING("show_shaders_building"),
 
-    DEBUG_FLUSH_BY_LINE("flush_lines"),
+    DEBUG_FLUSH_BY_LINE("flush_line"),
     USE_LRU_CACHE("use_lru_cache");
 
     external fun isRaiiEnabled(): Boolean
+
 //  external fun isFrameSkippingEnabled(): Boolean
     external fun isFrameInterpolationEnabled(): Boolean
 

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

@@ -27,6 +27,7 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     RENDERER_SCREEN_LAYOUT("screen_layout"),
     RENDERER_ASPECT_RATIO("aspect_ratio"),
     RENDERER_OPTIMIZE_SPIRV_OUTPUT("optimize_spirv_output"),
+    DMA_ACCURACY("dma_accuracy"),
     AUDIO_OUTPUT_ENGINE("output_engine"),
     MAX_ANISOTROPY("max_anisotropy"),
     THEME("theme"),
@@ -58,7 +59,7 @@ enum class IntSetting(override val key: String) : AbstractIntSetting {
     OFFLINE_WEB_APPLET("offline_web_applet_mode"),
     LOGIN_SHARE_APPLET("login_share_applet_mode"),
     WIFI_WEB_AUTH_APPLET("wifi_web_auth_applet_mode"),
-    MY_PAGE_APPLET("my_page_applet_mode"),
+    MY_PAGE_APPLET("my_page_applet_mode")
     ;
 
     override fun getInt(needsGlobal: Boolean): Int = NativeConfig.getInt(key, needsGlobal)

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

@@ -37,6 +37,7 @@ object Settings {
     const val PREF_SHOULD_SHOW_PRE_ALPHA_WARNING = "ShouldShowPreAlphaWarning"
     const val PREF_SHOULD_SHOW_EDENS_VEIL_DIALOG = "ShouldShowEdensVeilDialog"
     const val PREF_MEMORY_WARNING_SHOWN = "MemoryWarningShown"
+    const val PREF_HIDE_NCA_POPUP = "HideNCAVerificationPopup"
     const val SECTION_STATS_OVERLAY = "Stats Overlay"
 
     // Deprecated input overlay preference keys

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

@@ -297,7 +297,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.use_custom_rtc_description
                 )
             )
-
+            put(
+                SwitchSetting(
+                    BooleanSetting.DISABLE_NCA_VERIFICATION,
+                    titleId = R.string.disable_nca_verification,
+                    descriptionId = R.string.disable_nca_verification_description
+                )
+            )
             put(
                 StringInputSetting(
                     StringSetting.WEB_TOKEN,
@@ -602,6 +608,15 @@ abstract class SettingsItem(
                     valuesId = R.array.optimizeSpirvOutputValues
                 )
             )
+            put(
+                SingleChoiceSetting(
+                    IntSetting.DMA_ACCURACY,
+                    titleId = R.string.dma_accuracy,
+                    descriptionId = R.string.dma_accuracy_description,
+                    choicesId = R.array.dmaAccuracyNames,
+                    valuesId = R.array.dmaAccuracyValues
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS,
@@ -664,6 +679,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.skip_cpu_inner_invalidation_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.CPUOPT_UNSAFE_HOST_MMU,
+                    titleId = R.string.cpuopt_unsafe_host_mmu,
+                    descriptionId = R.string.cpuopt_unsafe_host_mmu_description
+                )
+            )
             put(
                 SwitchSetting(
                     BooleanSetting.RENDERER_REACTIVE_FLUSHING,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -210,6 +210,7 @@ class SettingsFragmentPresenter(
             add(IntSetting.LANGUAGE_INDEX.key)
             add(BooleanSetting.USE_CUSTOM_RTC.key)
             add(LongSetting.CUSTOM_RTC.key)
+            add(BooleanSetting.DISABLE_NCA_VERIFICATION.key)
 
             add(HeaderSetting(R.string.network))
             add(StringSetting.WEB_TOKEN.key)
@@ -448,6 +449,7 @@ class SettingsFragmentPresenter(
             add(HeaderSetting(R.string.veil_renderer))
             add(BooleanSetting.ENABLE_RAII.key)
             add(BooleanSetting.RENDERER_EARLY_RELEASE_FENCES.key)
+            add(IntSetting.DMA_ACCURACY.key)
             add(BooleanSetting.BUFFER_REORDER_DISABLE.key)
             add(BooleanSetting.FRAME_INTERPOLATION.key)
             add(BooleanSetting.RENDERER_FAST_GPU.key)
@@ -465,6 +467,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.USE_CUSTOM_CPU_TICKS.key)
             add(IntSetting.CPU_TICKS.key)
             add(BooleanSetting.SKIP_CPU_INNER_INVALIDATION.key)
+            add(BooleanSetting.CPUOPT_UNSAFE_HOST_MMU.key)
             add(BooleanSetting.USE_LRU_CACHE.key)
             add(BooleanSetting.CORE_SYNC_CORE_SPEED.key)
             add(BooleanSetting.SYNC_MEMORY_OPERATIONS.key)

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/DriverFetcherFragment.kt

@@ -79,7 +79,7 @@ class DriverFetcherFragment : Fragment() {
         IntRange(600, 639) to "Mr. Purple EOL-24.3.4",
         IntRange(640, 699) to "Mr. Purple T19",
         IntRange(700, 710) to "KIMCHI 25.2.0_r5",
-        IntRange(711, 799) to "Mr. Purple T21",
+        IntRange(711, 799) to "Mr. Purple T22",
         IntRange(800, 899) to "GameHub Adreno 8xx",
         IntRange(900, Int.MAX_VALUE) to "Unsupported"
     )

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -174,7 +174,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             }
 
             game = gameToUse
-
         } catch (e: Exception) {
             Log.error("[EmulationFragment] Error during game setup: ${e.message}")
             Toast.makeText(
@@ -193,10 +192,14 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                     game?.let { gameInstance ->
                         val customConfigFile = SettingsFile.getCustomSettingsFile(gameInstance)
                         if (customConfigFile.exists()) {
-                            Log.info("[EmulationFragment] Found existing custom settings for ${gameInstance.title}, loading them")
+                            Log.info(
+                                "[EmulationFragment] Found existing custom settings for ${gameInstance.title}, loading them"
+                            )
                             SettingsFile.loadCustomConfig(gameInstance)
                         } else {
-                            Log.info("[EmulationFragment] No custom settings found for ${gameInstance.title}, using global settings")
+                            Log.info(
+                                "[EmulationFragment] No custom settings found for ${gameInstance.title}, using global settings"
+                            )
                             NativeConfig.reloadGlobalConfig()
                         }
                     } ?: run {
@@ -225,7 +228,9 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
             try {
                 NativeConfig.reloadGlobalConfig()
             } catch (fallbackException: Exception) {
-                Log.error("[EmulationFragment] Critical error: could not load global config: ${fallbackException.message}")
+                Log.error(
+                    "[EmulationFragment] Critical error: could not load global config: ${fallbackException.message}"
+                )
                 throw fallbackException
             }
         }
@@ -233,7 +238,6 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         emulationState = EmulationState(game!!.path) {
             return@EmulationState driverViewModel.isInteractionAllowed.value
         }
-
     }
 
     /**
@@ -333,10 +337,14 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
                         val customConfigFile = SettingsFile.getCustomSettingsFile(foundGame)
                         if (customConfigFile.exists()) {
-                            Log.info("[EmulationFragment] Found existing custom settings for ${foundGame.title}, loading them")
+                            Log.info(
+                                "[EmulationFragment] Found existing custom settings for ${foundGame.title}, loading them"
+                            )
                             SettingsFile.loadCustomConfig(foundGame)
                         } else {
-                            Log.info("[EmulationFragment] No custom settings found for ${foundGame.title}, using global settings")
+                            Log.info(
+                                "[EmulationFragment] No custom settings found for ${foundGame.title}, using global settings"
+                            )
                         }
 
                         Toast.makeText(
@@ -352,7 +360,9 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                         withContext(Dispatchers.Main) {
                             try {
                                 finishGameSetup()
-                                Log.info("[EmulationFragment] Game setup complete for intent launch")
+                                Log.info(
+                                    "[EmulationFragment] Game setup complete for intent launch"
+                                )
 
                                 if (_binding != null) {
                                     // Hide loading indicator immediately for intent launches
@@ -365,12 +375,16 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                                     binding.root.post {
                                         if (binding.surfaceEmulation.holder.surface?.isValid == true && !emulationStarted) {
                                             emulationStarted = true
-                                            emulationState.newSurface(binding.surfaceEmulation.holder.surface)
+                                            emulationState.newSurface(
+                                                binding.surfaceEmulation.holder.surface
+                                            )
                                         }
                                     }
                                 }
                             } catch (e: Exception) {
-                                Log.error("[EmulationFragment] Error in finishGameSetup: ${e.message}")
+                                Log.error(
+                                    "[EmulationFragment] Error in finishGameSetup: ${e.message}"
+                                )
                                 requireActivity().finish()
                                 return@withContext
                             }
@@ -477,7 +491,9 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
 
         if (game == null) {
-            Log.warning("[EmulationFragment] Game not yet initialized in onViewCreated - will be set up by async intent handler")
+            Log.warning(
+                "[EmulationFragment] Game not yet initialized in onViewCreated - will be set up by async intent handler"
+            )
             return
         }
 
@@ -493,6 +509,8 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         gpuModel = GpuDriverHelper.getGpuModel().toString()
         fwVersion = NativeLibrary.firmwareVersion()
 
+        updateQuickOverlayMenuEntry(BooleanSetting.SHOW_INPUT_OVERLAY.getBoolean())
+
         binding.surfaceEmulation.holder.addCallback(this)
         binding.doneControlConfig.setOnClickListener { stopConfiguringControls() }
 
@@ -514,6 +532,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                 binding.drawerLayout.setDrawerLockMode(DrawerLayout.LOCK_MODE_UNLOCKED)
                 binding.inGameMenu.requestFocus()
                 emulationViewModel.setDrawerOpen(true)
+                updateQuickOverlayMenuEntry(BooleanSetting.SHOW_INPUT_OVERLAY.getBoolean())
             }
 
             override fun onDrawerClosed(drawerView: View) {
@@ -555,25 +574,24 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                 R.id.menu_pause_emulation -> {
                     if (emulationState.isPaused) {
                         emulationState.run(false)
-                        it.title = resources.getString(R.string.emulation_pause)
-                        it.icon = ResourcesCompat.getDrawable(
-                            resources,
-                            R.drawable.ic_pause,
-                            requireContext().theme
-                        )
+                        updatePauseMenuEntry(false)
                     } else {
                         emulationState.pause()
-                        it.title = resources.getString(R.string.emulation_unpause)
-                        it.icon = ResourcesCompat.getDrawable(
-                            resources,
-                            R.drawable.ic_play,
-                            requireContext().theme
-                        )
+                        updatePauseMenuEntry(true)
                     }
                     binding.inGameMenu.requestFocus()
                     true
                 }
 
+                R.id.menu_quick_overlay -> {
+                    val newState = !BooleanSetting.SHOW_INPUT_OVERLAY.getBoolean()
+                    BooleanSetting.SHOW_INPUT_OVERLAY.setBoolean(newState)
+                    updateQuickOverlayMenuEntry(newState)
+                    binding.surfaceInputOverlay.refreshControls()
+                    NativeConfig.saveGlobalConfig()
+                    true
+                }
+
                 R.id.menu_settings -> {
                     val action = HomeNavigationDirections.actionGlobalSettingsActivity(
                         null,
@@ -828,9 +846,50 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
         }
     }
 
+    private fun updateQuickOverlayMenuEntry(isVisible: Boolean) {
+        val menu = binding.inGameMenu.menu
+        val item = menu.findItem(R.id.menu_quick_overlay)
+        if (isVisible) {
+            item.title = getString(R.string.emulation_hide_overlay)
+            item.icon = ResourcesCompat.getDrawable(
+                resources,
+                R.drawable.ic_controller_disconnected,
+                requireContext().theme
+            )
+        } else {
+            item.title = getString(R.string.emulation_show_overlay)
+            item.icon = ResourcesCompat.getDrawable(
+                resources,
+                R.drawable.ic_controller,
+                requireContext().theme
+            )
+        }
+    }
+
+    private fun updatePauseMenuEntry(isPaused: Boolean) {
+        val menu = binding.inGameMenu.menu
+        val pauseItem = menu.findItem(R.id.menu_pause_emulation)
+        if (isPaused) {
+            pauseItem.title = getString(R.string.emulation_unpause)
+            pauseItem.icon = ResourcesCompat.getDrawable(
+                resources,
+                R.drawable.ic_play,
+                requireContext().theme
+            )
+        } else {
+            pauseItem.title = getString(R.string.emulation_pause)
+            pauseItem.icon = ResourcesCompat.getDrawable(
+                resources,
+                R.drawable.ic_pause,
+                requireContext().theme
+            )
+        }
+    }
+
     override fun onPause() {
         if (emulationState.isRunning && emulationActivity?.isInPictureInPictureMode != true) {
             emulationState.pause()
+            updatePauseMenuEntry(true)
         }
         super.onPause()
     }
@@ -853,6 +912,10 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
         val socPosition = IntSetting.SOC_OVERLAY_POSITION.getInt()
         updateSocPosition(socPosition)
+
+        binding.inGameMenu.post {
+            emulationState?.isPaused?.let { updatePauseMenuEntry(it) }
+        }
     }
 
     private fun resetInputOverlay() {
@@ -1375,6 +1438,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
                 R.id.menu_show_overlay -> {
                     it.isChecked = !it.isChecked
                     BooleanSetting.SHOW_INPUT_OVERLAY.setBoolean(it.isChecked)
+                    updateQuickOverlayMenuEntry(it.isChecked)
                     binding.surfaceInputOverlay.refreshControls()
                     true
                 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/HomeViewModel.kt

@@ -31,9 +31,6 @@ class HomeViewModel : ViewModel() {
     private val _checkKeys = MutableStateFlow(false)
     val checkKeys = _checkKeys.asStateFlow()
 
-    private val _checkFirmware = MutableStateFlow(false)
-    val checkFirmware = _checkFirmware.asStateFlow()
-
     var navigatedToSetup = false
 
     fun setStatusBarShadeVisibility(visible: Boolean) {
@@ -66,8 +63,4 @@ class HomeViewModel : ViewModel() {
     fun setCheckKeys(value: Boolean) {
         _checkKeys.value = value
     }
-
-    fun setCheckFirmware(value: Boolean) {
-        _checkFirmware.value = value
-    }
 }

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

@@ -38,6 +38,7 @@ import org.yuzu.yuzu_emu.model.DriverViewModel
 import org.yuzu.yuzu_emu.model.GamesViewModel
 import org.yuzu.yuzu_emu.model.HomeViewModel
 import org.yuzu.yuzu_emu.model.InstallResult
+import android.os.Build
 import org.yuzu.yuzu_emu.model.TaskState
 import org.yuzu.yuzu_emu.model.TaskViewModel
 import org.yuzu.yuzu_emu.utils.*
@@ -47,6 +48,7 @@ import java.io.BufferedOutputStream
 import java.util.zip.ZipEntry
 import java.util.zip.ZipInputStream
 import androidx.core.content.edit
+import kotlin.text.compareTo
 
 class MainActivity : AppCompatActivity(), ThemeProvider {
     private lateinit var binding: ActivityMainBinding
@@ -110,6 +112,19 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
 
         binding = ActivityMainBinding.inflate(layoutInflater)
 
+        // Since Android 15, google automatically forces "games" to be 60 hrz
+        // This ensures the display's max refresh rate is actually used
+        display?.let {
+            val supportedModes = it.supportedModes
+            val maxRefreshRate = supportedModes.maxByOrNull { mode -> mode.refreshRate }
+
+            if (maxRefreshRate != null) {
+                val layoutParams = window.attributes
+                layoutParams.preferredDisplayModeId = maxRefreshRate.modeId
+                window.attributes = layoutParams
+            }
+        }
+
         setContentView(binding.root)
 
         checkAndRequestBluetoothPermissions()
@@ -127,16 +142,6 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             checkedDecryption = true
         }
 
-        if (!checkedFirmware) {
-            val firstTimeSetup = PreferenceManager.getDefaultSharedPreferences(applicationContext)
-                .getBoolean(Settings.PREF_FIRST_APP_LAUNCH, true)
-            if (!firstTimeSetup) {
-                checkFirmware()
-                showPreAlphaWarningDialog()
-            }
-            checkedFirmware = true
-        }
-
         WindowCompat.setDecorFitsSystemWindows(window, false)
         window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
 
@@ -183,13 +188,6 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             if (it) checkKeys()
         }
 
-        homeViewModel.checkFirmware.collect(
-            this,
-            resetState = { homeViewModel.setCheckFirmware(false) }
-        ) {
-            if (it) checkFirmware()
-        }
-
         setInsets()
     }
 
@@ -228,21 +226,6 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
             ).show(supportFragmentManager, MessageDialogFragment.TAG)
         }
     }
-
-    private fun checkFirmware() {
-        val resultCode: Int = NativeLibrary.verifyFirmware()
-        if (resultCode == 0) return
-
-        val resultString: String =
-            resources.getStringArray(R.array.verifyFirmwareResults)[resultCode]
-
-        MessageDialogFragment.newInstance(
-            titleId = R.string.firmware_invalid,
-            descriptionString = resultString,
-            helpLinkId = R.string.firmware_missing_help
-        ).show(supportFragmentManager, MessageDialogFragment.TAG)
-    }
-
     override fun onSaveInstanceState(outState: Bundle) {
         super.onSaveInstanceState(outState)
         outState.putBoolean(CHECKED_DECRYPTION, checkedDecryption)
@@ -419,7 +402,6 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     cacheFirmwareDir.copyRecursively(firmwarePath, true)
                     NativeLibrary.initializeSystem(true)
                     homeViewModel.setCheckKeys(true)
-                    homeViewModel.setCheckFirmware(true)
                     getString(R.string.save_file_imported_success)
                 }
             } catch (e: Exception) {
@@ -449,7 +431,6 @@ class MainActivity : AppCompatActivity(), ThemeProvider {
                     // Optionally reinitialize the system or perform other necessary steps
                     NativeLibrary.initializeSystem(true)
                     homeViewModel.setCheckKeys(true)
-                    homeViewModel.setCheckFirmware(true)
                     messageToShow = getString(R.string.firmware_uninstalled_success)
                 } else {
                     messageToShow = getString(R.string.firmware_uninstalled_failure)

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/CustomSettingsHandler.kt

@@ -18,6 +18,13 @@ import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 import android.net.Uri
 import org.yuzu.yuzu_emu.features.settings.utils.SettingsFile
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.yuzu.yuzu_emu.databinding.DialogProgressBinding
+import android.view.LayoutInflater
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.CoroutineScope
 
 object CustomSettingsHandler {
     const val CUSTOM_CONFIG_ACTION = "dev.eden.eden_emulator.LAUNCH_WITH_CUSTOM_CONFIG"
@@ -44,7 +51,9 @@ object CustomSettingsHandler {
         // Check if config already exists - this should be handled by the caller
         val configFile = getConfigFile(game)
         if (configFile.exists()) {
-            Log.warning("[CustomSettingsHandler] Config file already exists for game: ${game.title}")
+            Log.warning(
+                "[CustomSettingsHandler] Config file already exists for game: ${game.title}"
+            )
         }
 
         // Write the config file
@@ -115,43 +124,169 @@ object CustomSettingsHandler {
 
         // Check for driver requirements if activity and driverViewModel are provided
         if (activity != null && driverViewModel != null) {
-            val driverPath = extractDriverPath(customSettings)
-            if (driverPath != null) {
-                Log.info("[CustomSettingsHandler] Custom settings specify driver: $driverPath")
+            val rawDriverPath = extractDriverPath(customSettings)
+            if (rawDriverPath != null) {
+                // Normalize to local storage path (we only store drivers under driverStoragePath)
+                val driverFilename = rawDriverPath.substringAfterLast('/')
+                    .substringAfterLast('\\')
+                val localDriverPath = "${GpuDriverHelper.driverStoragePath}$driverFilename"
+                Log.info("[CustomSettingsHandler] Custom settings specify driver: $rawDriverPath (normalized: $localDriverPath)")
+
                 // Check if driver exists in the driver storage
-                val driverFile = File(driverPath)
+                val driverFile = File(localDriverPath)
                 if (!driverFile.exists()) {
-                    Log.error("[CustomSettingsHandler] Required driver not found: $driverPath")
-                    Toast.makeText(
-                        activity,
-                        activity.getString(
-                            R.string.custom_settings_failed_message,
-                            game.title,
-                            activity.getString(R.string.driver_not_found, driverFile.name)
-                        ),
-                        Toast.LENGTH_LONG
-                    ).show()
-                    // Don't write config if driver is missing
-                    return null
-                }
+                    Log.info("[CustomSettingsHandler] Driver not found locally: ${driverFile.name}")
 
-                // Verify it's a valid driver
-                val metadata = GpuDriverHelper.getMetadataFromZip(driverFile)
-                if (metadata.name == null) {
-                    Log.error("[CustomSettingsHandler] Invalid driver file: $driverPath")
-                    Toast.makeText(
-                        activity,
-                        activity.getString(
-                            R.string.custom_settings_failed_message,
-                            game.title,
-                            activity.getString(R.string.invalid_driver_file, driverFile.name)
-                        ),
-                        Toast.LENGTH_LONG
-                    ).show()
-                    return null
-                }
+                    // Ask user if they want to download the missing driver
+                    val shouldDownload = askUserToDownloadDriver(activity, driverFile.name)
+                    if (!shouldDownload) {
+                        Log.info("[CustomSettingsHandler] User declined to download driver")
+                        Toast.makeText(
+                            activity,
+                            activity.getString(R.string.driver_download_cancelled),
+                            Toast.LENGTH_SHORT
+                        ).show()
+                        return null
+                    }
 
-                Log.info("[CustomSettingsHandler] Driver verified: ${metadata.name}")
+                    // Check network connectivity after user consent
+                    if (!DriverResolver.isNetworkAvailable(activity)) {
+                        Log.error("[CustomSettingsHandler] No network connection available")
+                        Toast.makeText(
+                            activity,
+                            activity.getString(R.string.network_unavailable),
+                            Toast.LENGTH_LONG
+                        ).show()
+                        return null
+                    }
+
+                    Log.info("[CustomSettingsHandler] User approved, downloading driver")
+
+                    // Show progress dialog for driver download
+                    val dialogBinding = DialogProgressBinding.inflate(LayoutInflater.from(activity))
+                    dialogBinding.progressBar.isIndeterminate = false
+                    dialogBinding.title.text = activity.getString(R.string.installing_driver)
+                    dialogBinding.status.text = activity.getString(R.string.downloading)
+
+                    val progressDialog = MaterialAlertDialogBuilder(activity)
+                        .setView(dialogBinding.root)
+                        .setCancelable(false)
+                        .create()
+
+                    withContext(Dispatchers.Main) {
+                        progressDialog.show()
+                    }
+
+                    try {
+                        // Set up progress channel for thread-safe UI updates
+                        val progressChannel = Channel<Int>(Channel.CONFLATED)
+                        val progressJob = CoroutineScope(Dispatchers.Main).launch {
+                            for (progress in progressChannel) {
+                                dialogBinding.progressBar.progress = progress
+                            }
+                        }
+
+                        // Attempt to download and install the driver
+                        val driverUri = DriverResolver.ensureDriverAvailable(driverFilename, activity) { progress ->
+                            progressChannel.trySend(progress.toInt())
+                        }
+
+                        progressChannel.close()
+                        progressJob.cancel()
+
+                        withContext(Dispatchers.Main) {
+                            progressDialog.dismiss()
+                        }
+
+                        if (driverUri == null) {
+                            Log.error(
+                                "[CustomSettingsHandler] Failed to download driver: ${driverFile.name}"
+                            )
+                            Toast.makeText(
+                                activity,
+                                activity.getString(
+                                    R.string.custom_settings_failed_message,
+                                    game.title,
+                                    activity.getString(R.string.driver_not_found, driverFile.name)
+                                ),
+                                Toast.LENGTH_LONG
+                            ).show()
+                            return null
+                        }
+
+                        // Verify the downloaded driver (from normalized local path)
+                        val installedFile = File(localDriverPath)
+                        val metadata = GpuDriverHelper.getMetadataFromZip(installedFile)
+                        if (metadata.name == null) {
+                            Log.error(
+                                "[CustomSettingsHandler] Downloaded driver is invalid: $localDriverPath"
+                            )
+                            Toast.makeText(
+                                activity,
+                                activity.getString(
+                                    R.string.custom_settings_failed_message,
+                                    game.title,
+                                    activity.getString(
+                                        R.string.invalid_driver_file,
+                                        driverFile.name
+                                    )
+                                ),
+                                Toast.LENGTH_LONG
+                            ).show()
+                            return null
+                        }
+
+                        // Add to driver list
+                        driverViewModel.onDriverAdded(Pair(localDriverPath, metadata))
+                        Log.info(
+                            "[CustomSettingsHandler] Successfully downloaded and installed driver: ${metadata.name}"
+                        )
+
+                        Toast.makeText(
+                            activity,
+                            activity.getString(
+                                R.string.successfully_installed,
+                                metadata.name ?: driverFile.name
+                            ),
+                            Toast.LENGTH_SHORT
+                        ).show()
+                    } catch (e: Exception) {
+                        withContext(Dispatchers.Main) {
+                            progressDialog.dismiss()
+                        }
+                        Log.error("[CustomSettingsHandler] Error downloading driver: ${e.message}")
+                        Toast.makeText(
+                            activity,
+                            activity.getString(
+                                R.string.custom_settings_failed_message,
+                                game.title,
+                                e.message ?: activity.getString(
+                                    R.string.driver_not_found,
+                                    driverFile.name
+                                )
+                            ),
+                            Toast.LENGTH_LONG
+                        ).show()
+                        return null
+                    }
+                } else {
+                    // Driver exists, verify it's valid
+                    val metadata = GpuDriverHelper.getMetadataFromZip(driverFile)
+                    if (metadata.name == null) {
+                        Log.error("[CustomSettingsHandler] Invalid driver file: $localDriverPath")
+                        Toast.makeText(
+                            activity,
+                            activity.getString(
+                                R.string.custom_settings_failed_message,
+                                game.title,
+                                activity.getString(R.string.invalid_driver_file, driverFile.name)
+                            ),
+                            Toast.LENGTH_LONG
+                        ).show()
+                        return null
+                    }
+                    Log.info("[CustomSettingsHandler] Driver verified: ${metadata.name}")
+                }
             }
         }
 
@@ -290,6 +425,29 @@ object CustomSettingsHandler {
         }
     }
 
+    /**
+     * Ask user if they want to download a missing driver
+     */
+    private suspend fun askUserToDownloadDriver(activity: FragmentActivity, driverName: String): Boolean {
+        return suspendCoroutine { continuation ->
+            activity.runOnUiThread {
+                MaterialAlertDialogBuilder(activity)
+                    .setTitle(activity.getString(R.string.driver_missing_title))
+                    .setMessage(
+                        activity.getString(R.string.driver_missing_message, driverName)
+                    )
+                    .setPositiveButton(activity.getString(R.string.download)) { _, _ ->
+                        continuation.resume(true)
+                    }
+                    .setNegativeButton(activity.getString(R.string.cancel)) { _, _ ->
+                        continuation.resume(false)
+                    }
+                    .setCancelable(false)
+                    .show()
+            }
+        }
+    }
+
     /**
      * Extract driver path from custom settings INI content
      */
@@ -306,6 +464,8 @@ object CustomSettingsHandler {
 
             if (inGpuDriverSection && trimmed.startsWith("driver_path=")) {
                 return trimmed.substringAfter("driver_path=")
+                    .trim()
+                    .removeSurrounding("\"", "\"")
             }
         }
 

src/android/app/src/main/java/org/yuzu/yuzu_emu/utils/DriverResolver.kt

@@ -0,0 +1,447 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package org.yuzu.yuzu_emu.utils
+
+import android.content.Context
+import android.net.Uri
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withContext
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import org.yuzu.yuzu_emu.fragments.DriverFetcherFragment
+import java.io.File
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.ConcurrentHashMap
+import okhttp3.ConnectionPool
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import kotlinx.coroutines.delay
+import kotlin.math.pow
+
+/**
+ * Resolves driver download URLs from filenames by searching GitHub repositories
+ */
+object DriverResolver {
+    private const val CONNECTION_TIMEOUT_SECONDS = 30L
+    private const val CACHE_DURATION_MS = 3600000L // 1 hour
+    private const val BUFFER_SIZE = 8192
+    private const val MIN_API_CALL_INTERVAL = 2000L // 2 seconds between API calls
+    private const val MAX_RETRY_COUNT = 3
+
+    @Volatile
+    private var client: OkHttpClient? = null
+
+    private fun getClient(): OkHttpClient {
+        return client ?: synchronized(this) {
+            client ?: OkHttpClient.Builder()
+                .connectTimeout(CONNECTION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+                .readTimeout(CONNECTION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+                .writeTimeout(CONNECTION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
+                .followRedirects(true)
+                .followSslRedirects(true)
+                .connectionPool(ConnectionPool(5, 1, TimeUnit.MINUTES))
+                .build().also { client = it }
+        }
+    }
+
+    // Driver repository paths - (from DriverFetcherFragment) might extract these to a config file later
+    private val repositories = listOf(
+        "MrPurple666/purple-turnip",
+        "crueter/GameHub-8Elite-Drivers",
+        "K11MCH1/AdrenoToolsDrivers",
+        "Weab-chan/freedreno_turnip-CI"
+    )
+
+    private val urlCache = ConcurrentHashMap<String, ResolvedDriver>()
+    private val releaseCache = ConcurrentHashMap<String, List<DriverFetcherFragment.Release>>()
+    private var lastCacheTime = 0L
+    private var lastApiCallTime = 0L
+
+    data class ResolvedDriver(
+        val downloadUrl: String,
+        val repoPath: String,
+        val releaseTag: String,
+        val filename: String
+    )
+
+    // Matching helpers
+    private val KNOWN_SUFFIXES = listOf(
+        ".adpkg.zip",
+        ".zip",
+        ".7z",
+        ".tar.gz",
+        ".tar.xz",
+        ".rar"
+    )
+
+    private fun stripKnownSuffixes(name: String): String {
+        var result = name
+        var changed: Boolean
+        do {
+            changed = false
+            for (s in KNOWN_SUFFIXES) {
+                if (result.endsWith(s, ignoreCase = true)) {
+                    result = result.dropLast(s.length)
+                    changed = true
+                }
+            }
+        } while (changed)
+        return result
+    }
+
+    private fun normalizeName(name: String): String {
+        val base = stripKnownSuffixes(name.lowercase())
+        // Remove non-alphanumerics to make substring checks resilient
+        return base.replace(Regex("[^a-z0-9]+"), " ").trim()
+    }
+
+    private fun tokenize(name: String): Set<String> =
+        normalizeName(name).split(Regex("\\s+")).filter { it.isNotBlank() }.toSet()
+
+    // Jaccard similarity between two sets
+    private fun jaccard(a: Set<String>, b: Set<String>): Double {
+        if (a.isEmpty() || b.isEmpty()) return 0.0
+        val inter = a.intersect(b).size.toDouble()
+        val uni = a.union(b).size.toDouble()
+        return if (uni == 0.0) 0.0 else inter / uni
+    }
+
+    /**
+     * Resolve a driver download URL from its filename
+     * @param filename The driver filename (e.g., "turnip_mrpurple-T19-toasted.adpkg.zip")
+     * @return ResolvedDriver with download URL and metadata, or null if not found
+     */
+    suspend fun resolveDriverUrl(filename: String): ResolvedDriver? {
+        // Validate input
+        require(filename.isNotBlank()) { "Filename cannot be blank" }
+        require(!filename.contains("..")) { "Invalid filename: path traversal detected" }
+
+        // Check cache first
+        urlCache[filename]?.let {
+            Log.info("[DriverResolver] Found cached URL for $filename")
+            return it
+        }
+
+        Log.info("[DriverResolver] Resolving download URL for: $filename")
+
+        // Clear cache if expired
+        if (System.currentTimeMillis() - lastCacheTime > CACHE_DURATION_MS) {
+            releaseCache.clear()
+            lastCacheTime = System.currentTimeMillis()
+        }
+
+        return coroutineScope {
+            // Search all repositories in parallel
+            repositories.map { repoPath ->
+                async {
+                    searchRepository(repoPath, filename)
+                }
+            }.firstNotNullOfOrNull { it.await() }.also { resolved ->
+                // Cache the result if found
+                resolved?.let {
+                    urlCache[filename] = it
+                    Log.info("[DriverResolver] Cached resolution for $filename from ${it.repoPath}")
+                }
+            }
+        }
+    }
+
+    /**
+     * Search a specific repository for a driver file
+     */
+    private suspend fun searchRepository(repoPath: String, filename: String): ResolvedDriver? {
+        return withContext(Dispatchers.IO) {
+            try {
+                // Get releases from cache or fetch
+                val releases = releaseCache[repoPath] ?: fetchReleases(repoPath).also {
+                    releaseCache[repoPath] = it
+                }
+
+                // First pass: exact name (case-insensitive) against asset filenames
+                val target = filename.lowercase()
+                for (release in releases) {
+                    for (artifact in release.artifacts) {
+                        if (artifact.name.equals(filename, ignoreCase = true) || artifact.name.lowercase() == target) {
+                            Log.info("[DriverResolver] Found $filename in $repoPath/${release.tagName}")
+                            return@withContext ResolvedDriver(
+                                downloadUrl = artifact.url.toString(),
+                                repoPath = repoPath,
+                                releaseTag = release.tagName,
+                                filename = artifact.name
+                            )
+                        }
+                    }
+                }
+
+                // Second pass: fuzzy match by asset filenames only
+                val reqNorm = normalizeName(filename)
+                val reqTokens = tokenize(filename)
+                var best: ResolvedDriver? = null
+                var bestScore = 0.0
+
+                for (release in releases) {
+                    for (artifact in release.artifacts) {
+                        val artNorm = normalizeName(artifact.name)
+                        val artTokens = tokenize(artifact.name)
+
+                        var score = jaccard(reqTokens, artTokens)
+                        // Boost if one normalized name contains the other
+                        if (artNorm.contains(reqNorm) || reqNorm.contains(artNorm)) {
+                            score = maxOf(score, 0.92)
+                        }
+
+                        if (score > bestScore) {
+                            bestScore = score
+                            best = ResolvedDriver(
+                                downloadUrl = artifact.url.toString(),
+                                repoPath = repoPath,
+                                releaseTag = release.tagName,
+                                filename = artifact.name
+                            )
+                        }
+                    }
+                }
+
+                // Threshold to avoid bad guesses, this worked fine in testing but might need tuning
+                if (best != null && bestScore >= 0.6) {
+                    Log.info("[DriverResolver] Fuzzy matched $filename -> ${best.filename} in ${best.repoPath} (score=%.2f)".format(bestScore))
+                    return@withContext best
+                }
+                null
+            } catch (e: Exception) {
+                Log.error("[DriverResolver] Failed to search $repoPath: ${e.message}")
+                null
+            }
+        }
+    }
+
+    /**
+     * Fetch releases from a GitHub repository
+     */
+    private suspend fun fetchReleases(repoPath: String): List<DriverFetcherFragment.Release> = withContext(
+        Dispatchers.IO
+    ) {
+        // Rate limiting
+        val timeSinceLastCall = System.currentTimeMillis() - lastApiCallTime
+        if (timeSinceLastCall < MIN_API_CALL_INTERVAL) {
+            delay(MIN_API_CALL_INTERVAL - timeSinceLastCall)
+        }
+        lastApiCallTime = System.currentTimeMillis()
+
+        // Retry logic with exponential backoff
+        var retryCount = 0
+        var lastException: Exception? = null
+
+        while (retryCount < MAX_RETRY_COUNT) {
+            try {
+                val request = Request.Builder()
+                    .url("https://api.github.com/repos/$repoPath/releases")
+                    .header("Accept", "application/vnd.github.v3+json")
+                    .build()
+
+                return@withContext getClient().newCall(request).execute().use { response ->
+                    when {
+                        response.code == 404 -> throw IOException("Repository not found: $repoPath")
+                        response.code == 403 -> {
+                            val resetTime = response.header("X-RateLimit-Reset")?.toLongOrNull() ?: 0
+                            throw IOException(
+                                "API rate limit exceeded. Resets at ${java.util.Date(
+                                    resetTime * 1000
+                                )}"
+                            )
+                        }
+                        !response.isSuccessful -> throw IOException(
+                            "HTTP ${response.code}: ${response.message}"
+                        )
+                    }
+
+                    val body = response.body?.string()
+                        ?: throw IOException("Empty response from $repoPath")
+
+                    // Determine if this repo uses tag names (from DriverFetcherFragment logic)
+                    val useTagName = repoPath.contains("K11MCH1")
+                    val sortMode = if (useTagName) {
+                        DriverFetcherFragment.SortMode.PublishTime
+                    } else {
+                        DriverFetcherFragment.SortMode.Default
+                    }
+
+                    DriverFetcherFragment.Release.fromJsonArray(body, useTagName, sortMode)
+                }
+            } catch (e: IOException) {
+                lastException = e
+                if (retryCount == MAX_RETRY_COUNT - 1) throw e
+                delay((2.0.pow(retryCount) * 1000).toLong())
+                retryCount++
+            }
+        }
+        throw lastException ?: IOException(
+            "Failed to fetch releases after $MAX_RETRY_COUNT attempts"
+        )
+    }
+
+    /**
+     * Download a driver file to the cache directory
+     * @param resolvedDriver The resolved driver information
+     * @param context Android context for cache directory
+     * @return The downloaded file, or null if download failed
+     */
+    suspend fun downloadDriver(
+        resolvedDriver: ResolvedDriver,
+        context: Context,
+        onProgress: ((Float) -> Unit)? = null
+    ): File? {
+        return withContext(Dispatchers.IO) {
+            try {
+                Log.info(
+                    "[DriverResolver] Downloading ${resolvedDriver.filename} from ${resolvedDriver.repoPath}"
+                )
+
+                val cacheDir = context.externalCacheDir ?: throw IOException("Failed to access cache directory")
+                cacheDir.mkdirs()
+
+                val file = File(cacheDir, resolvedDriver.filename)
+
+                // If file already exists in cache and has content, return it
+                if (file.exists() && file.length() > 0) {
+                    Log.info("[DriverResolver] Using cached file: ${file.absolutePath}")
+                    return@withContext file
+                }
+
+                val request = Request.Builder()
+                    .url(resolvedDriver.downloadUrl)
+                    .header("Accept", "application/octet-stream")
+                    .build()
+
+                getClient().newCall(request).execute().use { response ->
+                    if (!response.isSuccessful) {
+                        throw IOException("Download failed: ${response.code}")
+                    }
+
+                    response.body?.use { body ->
+                        val contentLength = body.contentLength()
+                        body.byteStream().use { input ->
+                            file.outputStream().use { output ->
+                                val buffer = ByteArray(BUFFER_SIZE)
+                                var totalBytesRead = 0L
+                                var bytesRead: Int
+
+                                while (input.read(buffer).also { bytesRead = it } != -1) {
+                                    output.write(buffer, 0, bytesRead)
+                                    totalBytesRead += bytesRead
+
+                                    if (contentLength > 0) {
+                                        val progress = (totalBytesRead.toFloat() / contentLength) * 100f
+                                        onProgress?.invoke(progress)
+                                    }
+                                }
+                            }
+                        }
+                    } ?: throw IOException("Empty response body")
+                }
+
+                if (file.length() == 0L) {
+                    file.delete()
+                    throw IOException("Downloaded file is empty")
+                }
+
+                Log.info(
+                    "[DriverResolver] Successfully downloaded ${file.length()} bytes to ${file.absolutePath}"
+                )
+                file
+            } catch (e: Exception) {
+                Log.error("[DriverResolver] Download failed: ${e.message}")
+                null
+            }
+        }
+    }
+
+    /**
+     * Download and install a driver if not already present
+     * @param driverPath The driver filename or full path
+     * @param context Android context
+     * @param onProgress Optional progress callback (0-100)
+     * @return Uri of the installed driver, or null if failed
+     */
+    suspend fun ensureDriverAvailable(
+        driverPath: String,
+        context: Context,
+        onProgress: ((Float) -> Unit)? = null
+    ): Uri? {
+        // Extract filename from path (support both separators)
+        val filename = driverPath.substringAfterLast('/').substringAfterLast('\\')
+
+        // Check if driver already exists locally
+        val localPath = "${GpuDriverHelper.driverStoragePath}$filename"
+        val localFile = File(localPath)
+
+        if (localFile.exists() && localFile.length() > 0) {
+            Log.info("[DriverResolver] Driver already exists locally: $localPath")
+            return Uri.fromFile(localFile)
+        }
+
+        Log.info("[DriverResolver] Driver not found locally, attempting to download: $filename")
+
+        // Resolve download URL
+        val resolvedDriver = resolveDriverUrl(filename)
+        if (resolvedDriver == null) {
+            Log.error("[DriverResolver] Failed to resolve download URL for $filename")
+            return null
+        }
+
+        // Download the driver with progress callback
+        val downloadedFile = downloadDriver(resolvedDriver, context, onProgress)
+        if (downloadedFile == null) {
+            Log.error("[DriverResolver] Failed to download driver $filename")
+            return null
+        }
+
+        // Install the driver to internal storage
+        val downloadedUri = Uri.fromFile(downloadedFile)
+        if (GpuDriverHelper.copyDriverToInternalStorage(downloadedUri)) {
+            Log.info("[DriverResolver] Successfully installed driver to internal storage")
+            // Clean up cache file
+            downloadedFile.delete()
+            return Uri.fromFile(File(localPath))
+        } else {
+            Log.error("[DriverResolver] Failed to copy driver to internal storage")
+            downloadedFile.delete()
+            return null
+        }
+    }
+
+    /**
+     * Check network connectivity
+     */
+    fun isNetworkAvailable(context: Context): Boolean {
+        val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as? ConnectivityManager
+            ?: return false
+        val network = connectivityManager.activeNetwork ?: return false
+        val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
+        return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+    }
+
+    /**
+     * Clear all caches
+     */
+    fun clearCache() {
+        urlCache.clear()
+        releaseCache.clear()
+        lastCacheTime = 0L
+        lastApiCallTime = 0L
+    }
+
+    /**
+     * Clean up resources
+     */
+    fun cleanup() {
+        client?.dispatcher?.executorService?.shutdown()
+        client?.connectionPool?.evictAll()
+        client = null
+        clearCache()
+    }
+}

src/android/app/src/main/java/org/yuzu/yuzu_emu/views/GradientBorderCardView.kt

@@ -52,8 +52,10 @@ class GradientBorderCardView @JvmOverloads constructor(
         if (isEdenTheme) {
             // Gradient for Eden theme
             borderPaint.shader = LinearGradient(
-                0f, 0f,
-                w.toFloat(), h.toFloat(),
+                0f,
+                0f,
+                w.toFloat(),
+                h.toFloat(),
                 context.getColor(R.color.eden_border_gradient_start),
                 context.getColor(R.color.eden_border_gradient_end),
                 Shader.TileMode.CLAMP
@@ -62,7 +64,11 @@ class GradientBorderCardView @JvmOverloads constructor(
             // Solid color for other themes
             borderPaint.shader = null
             val typedValue = android.util.TypedValue()
-            context.theme.resolveAttribute(com.google.android.material.R.attr.colorPrimary, typedValue, true)
+            context.theme.resolveAttribute(
+                com.google.android.material.R.attr.colorPrimary,
+                typedValue,
+                true
+            )
             borderPaint.color = typedValue.data
         }
 

src/android/app/src/main/jni/CMakeLists.txt

@@ -17,7 +17,7 @@ add_library(yuzu-android SHARED
 
 set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR})
 
-target_link_libraries(yuzu-android PRIVATE audio_core common core input_common frontend_common Vulkan::Headers)
+target_link_libraries(yuzu-android PRIVATE audio_core common core input_common frontend_common Vulkan::Headers GPUOpen::VulkanMemoryAllocator)
 target_link_libraries(yuzu-android PRIVATE android camera2ndk EGL glad jnigraphics log)
 if (ARCHITECTURE_arm64)
     target_link_libraries(yuzu-android PRIVATE adrenotools)

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

@@ -596,6 +596,8 @@ jstring Java_org_yuzu_yuzu_1emu_utils_GpuDriverHelper_getGpuModel(JNIEnv *env, j
 
     const std::string model_name{device.GetModelName()};
 
+    window.release();
+
     return Common::Android::ToJString(env, model_name);
 }
 

src/android/app/src/main/res/menu/menu_in_game.xml

@@ -8,6 +8,11 @@
         android:icon="@drawable/ic_pause"
         android:title="@string/emulation_pause" />
 
+    <item
+        android:id="@+id/menu_quick_overlay"
+        android:icon="@drawable/ic_controller"
+        android:title="@string/emulation_show_overlay"/>
+
     <item
         android:id="@+id/menu_settings"
         android:icon="@drawable/ic_settings"

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

@@ -84,7 +84,7 @@
     <string name="use_lru_cache">تمكين ذاكرة التخزين المؤقت LRU</string>
     <string name="use_lru_cache_description">تمكين أو تعطيل ذاكرة التخزين المؤقت الأقل استخداماً مؤخراً (LRU) لتحسين الأداء عن طريق تقليل استخدام وحدة المعالجة المركزية. بعض الألعاب قد تواجه مشاكل معه، خاصةً TotK 1.2.1، لذا قم بتعطيله إذا لم تعمل اللعبة أو انهارت عشوائياً.</string>
     <string name="dyna_state">الحالة الديناميكية الممتدة</string>
-    <string name="dyna_state_description">تمكين ميزات فولكان لتحسين الأداء، العرض، وتوفير الموارد أثناء إنشاء خطوط المعالجة مع الحفاظ على استهلاك منخفض لوحدة المعالجة المركزية/وحدة معالجة الرسومات. هذه الامتدادات قد تزيد من حرارة الجهاز، ووحدات معالجة الرسومات من سلسلة A6XX القديمة قد لا تعمل بشكل صحيح. قم بتعطيله لمحاكاة الصيغ المضبوطة.</string>
+    <string name="dyna_state_description">يتحكم في عدد الميزات التي يمكن استخدامها في الحالة الديناميكية الممتدة. الأرقام الأعلى تسمح بالمزيد من Мيزات ويمكن أن تزيد الأداء، ولكن قد تسبب مشاكل مع بعض برامج التشغيل والبائعين. قد تختلف القيمة الافتراضية اعتمادًا على نظامك وقدرات硬件. يمكن تغيير هذه القيمة حتى يتم تحقيق الاستقرار وجودة بصرية أفضل.</string>
     <string name="disabled">معطل</string>
     <string name="use_sync_core">مزامنة سرعة النواة</string>
     <string name="use_sync_core_description">مزامنة سرعة النواة مع النسبة القصوى للسرعة لتحسين الأداء دون تغيير السرعة الفعلية للعبة.</string>
@@ -117,6 +117,10 @@
     <string name="cpu_ticks">دورات</string>
     <string name="skip_cpu_inner_invalidation">تخطي إبطال ذاكرة التخزين المؤقت الداخلية للوحدة المركزية</string>
     <string name="skip_cpu_inner_invalidation_description">يتخطى بعض عمليات إبطال ذاكرة التخزين المؤقت أثناء تحديثات الذاكرة، مما يقلل استخدام المعالج ويحسن أدائه. قد يسبب هذا أعطالاً أو تعطلًا في بعض الألعاب.</string>
+    <string name="cpuopt_unsafe_host_mmu">تمكين محاكاة MMU المضيف</string>
+    <string name="cpuopt_unsafe_host_mmu_description">يعمل هذا التحسين على تسريع وصول الذاكرة بواسطة البرنامج الضيف. يؤدي تمكينه إلى إجراء عمليات قراءة/كتابة ذاكرة الضيف مباشرة في الذاكرة والاستفادة من MMU المضيف. يؤدي تعطيل هذا إلى إجبار جميع عمليات الوصول إلى الذاكرة على استخدام محاكاة MMU البرمجية.</string>
+    <string name="dma_accuracy">مستوى DMA</string>
+    <string name="dma_accuracy_description">يتحكم في دقة تحديد مستوى DMA. الدقة الأعلى يمكنها إصلاح بعض المشاكل في بعض الألعاب، ولكنها قد تؤثر أيضًا على الأداء في بعض الحالات. إذا كنت غير متأكد، اتركه على الوضع الافتراضي.</string>
 
     <!-- Memory Layouts -->
     <string name="memory_4gb">4 جيجابايت (موصى به)</string>
@@ -494,6 +498,8 @@
     <string name="use_custom_rtc">ساعة مخصصة في الوقت الحقيقي</string>
     <string name="use_custom_rtc_description">يسمح لك بتعيين ساعة مخصصة في الوقت الفعلي منفصلة عن وقت النظام الحالي لديك</string>
     <string name="set_custom_rtc">تعيين ساعة مخصصة في الوقت الحقيقي</string>
+    <string name="disable_nca_verification">تعطيل التحقق من NCA</string>
+    <string name="disable_nca_verification_description">يعطل التحقق من سلامة أرشيفات محتوى NCA. قد يحسن هذا من سرعة التحميل لكنه يخاطر بتلف البيانات أو تمرير ملفات غير صالحة دون اكتشاف. ضروري لجعل الألعاب والتحديثات التي تتطلب نظامًا أساسيًا 20+ تعمل.</string>
 
     <!-- Network settings strings -->
     <string name="generate">توليد</string>
@@ -677,6 +683,50 @@
     <string name="loader_requires_firmware">اللعبة تتطلب برنامجاً ثابتاً</string>
     <string name="loader_requires_firmware_description"><![CDATA[اللعبة التي تحاول تشغيلها تتطلب برنامجاً ثابتاً للتمهيد أو لتجاوز القائمة الافتتاحية. يرجى <a href="https://yuzu-mirror.github.io/help/quickstart">نسخ وتثبيت البرنامج الثابت</a>، أو اضغط "موافق" للمتابعة على أي حال.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">جاري البحث عن اللعبة...</string>
+    <string name="game_not_found_for_title_id">لم يتم العثور على اللعبة لمعرف العنوان: %1$s</string>
+    <string name="custom_settings_failed_title">فشل الإعدادات المخصصة</string>
+    <string name="custom_settings_failed_message">فشل تطبيق الإعدادات المخصصة لـ %1$s: %2$s</string>
+    <string name="launch_with_default_settings">بدء التشغيل بالإعدادات الافتراضية</string>
+    <string name="launch_cancelled">تم إلغاء البدء</string>
+    <string name="custom_settings_failure_reasons">غير قادر على تطبيق الإعدادات المطلوبة. قد يكون هذا بسبب отсут برامج تشغيل GPU أو مشاكل في التهيئة.</string>
+    <string name="custom_settings_applied">تم تطبيق الإعدادات المخصصة</string>
+    <string name="launching_game">جاري تشغيل %1$s...</string>
+    <string name="failed_to_initialize_game">فشل تهيئة اللعبة</string>
+    <string name="custom_intent_launch_message_with_settings">هل تريد تشغيل %1$s بالإعدادات المخصصة؟</string>
+    <string name="custom_intent_launch_message">هل تريد تشغيل %1$s؟</string>
+    <string name="custom_intent_launch_title">تشغيل اللعبة</string>
+    <string name="launch">تشغيل</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">فشل كتابة ملف التهيئة</string>
+    <string name="config_apply_failed">فشل تطبيق التهيئة</string>
+    <string name="config_already_exists_title">التهيئة موجودة بالفعل</string>
+    <string name="config_already_exists_message">توجد إعدادات مخصصة بالفعل لـ %1$s.\n\nهل تريد الكتابة فوق التهيئة الموجودة؟\n\nلا يمكن التراجع عن هذا الإجراء.</string>
+    <string name="config_exists_prompt">جاري التحقق من وجود تهيئة حالية...</string>
+    <string name="overwrite_cancelled">تم إلغاء الكتابة فوق</string>
+    <string name="checking_driver">جاري التحقق من وجود برنامج تشغيل مخصص: %1$s</string>
+    <string name="driver_unavailable">برنامج التشغيل المخصص غير متاح لهذا الجهاز</string>
+    <string name="overwrite">الكتابة فوق</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">برنامج تشغيل GPU مفقود</string>
+    <string name="missing_gpu_driver_message">برنامج التشغيل المخصص المحدد \"%s\" غير مثبت. هل تريد تنزيله وتثبيته الآن؟</string>
+    <string name="downloading_driver">جاري تنزيل برنامج التشغيل...</string>
+    <string name="driver_installed">تم تثبيت برنامج التشغيل بنجاح</string>
+    <string name="driver_installation_failed_title">فشل تثبيت برنامج التشغيل</string>
+    <string name="driver_installation_failed_message">فشل تثبيت برنامج تشغيل GPU: %s</string>
+    <string name="driver_not_available_title">برنامج التشغيل غير متاح</string>
+    <string name="driver_not_available_message">برنامج التشغيل المحدد غير متاح للتنزيل.</string>
+    <string name="driver_not_found">برنامج التشغيل المطلوب غير مثبت: %s</string>
+    <string name="invalid_driver_file">ملف برنامج تشغيل غير صالح: %s</string>
+    <string name="network_unavailable">لا يوجد اتصال بالشبكة. يرجى التحقق من اتصال الإنترنت والمحاولة مرة أخرى.</string>
+    <string name="driver_missing_title">مطلوب برنامج تشغيل GPU</string>
+    <string name="driver_missing_message">تكوين اللعبة يتطلب برنامج تشغيل GPU \"%s\" غير المثبت على جهازك.\n\nهل تريد تنزيله وتثبيته الآن?</string>
+    <string name="driver_download_cancelled">تم إلغاء تنزيل برنامج التشغيل. لا يمكن تشغيل اللعبة بدون برنامج التشغيل المطلوب.</string>
+    <string name="download">تنزيل</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">الخروج من المحاكاة</string>
     <string name="emulation_done">إنهاء</string>
@@ -685,7 +735,8 @@
     <string name="emulation_rel_stick_center">مركز العصا النسبي</string>
     <string name="emulation_dpad_slide">مزلاق الأسهم</string>
     <string name="emulation_haptics">الاهتزازات الديناميكية</string>
-    <string name="emulation_show_overlay">عرض التراكب</string>
+    <string name="emulation_show_overlay">إظهار وحدة التحكم</string>
+    <string name="emulation_hide_overlay">إخفاء وحدة التحكم</string>
     <string name="emulation_toggle_all">الكل</string>
     <string name="emulation_control_adjust">ضبط التراكب</string>
     <string name="emulation_control_scale">الحجم</string>
@@ -741,6 +792,12 @@
     <string name="renderer_accuracy_high">عالي</string>
     <string name="renderer_accuracy_extreme">Extreme (بطيء)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">افتراضي</string>
+    <string name="dma_accuracy_normal">عادي</string>
+    <string name="dma_accuracy_high">عالي</string>
+    <string name="dma_accuracy_extreme">مفرط</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">تمكين ذاكرة التخزين المؤقت LRU</string>
     <string name="use_lru_cache_description">چالاک یان ناچالاککردنی کاشەی LRU، کارایی باشتر دەکات بە هەڵگرتنی بەکارهێنانی پرۆسەی CPU. هەندێک یاری کێشەی لەگەڵ هەیە، بەتایبەتی TotK 1.2.1، بۆیە بیخەوێنە ئەگەر یاریەکە نەگەڕێت یان بە هەڕەمەکی بشکێت.</string>
     <string name="dyna_state">الحالة الديناميكية الممتدة</string>
-    <string name="dyna_state_description">کاریگەرییەکانی ڤولکان چالاک بکە بۆ باشترکردنی کارایی، رێندرکردن، و هەڵگرتنی سەرچاوەکان لە دروستکردنی پایپلاین بە هەمان کات کەمترین بەکارهێنانی CPU/GPU بەکاربهێنرێت. ئەم زیادکراوانە ڕەنگە پلەی گەرمی ئامێر زیاد بکەن، و GPU-کانی هێڵی کۆنی A6XX ڕەنگە بە شێوەیەکی گونجاو کارنەکەن. بیخەوێنە بۆ نەخشەکێشانی فۆرماتە پێوانەکراوەکان.</string>
+    <string name="dyna_state_description">کۆntrolی ژمارەی تایبەتمەندییەکان دەکات کە دەتوانرێت لە دۆخی هایپرDynamic بەکاربهێنرێت. ژمارەی زیاتر ڕێگە بە تایبەتمەندییەکی زیاتر دەدات و دەتوانێت کارایی باشتر بکات، بەڵام لەوانەیە کێشە دروست بکات لەگەڵ هەندێک لە درایڤەرەکان و فرۆشەکان. نرخی گریمانەیی دەگۆڕێت بەپێی سیستەم و تواناکانی hardwareی تۆ. دەتوانیت ئەم نرخە بگۆڕیت تا جێگیری و جێیەکی بینینی باشتر دەستبکەوێت.</string>
     <string name="disabled">ناچالاک</string>
     <string name="use_sync_core">مزامنة سرعة النواة</string>
     <string name="use_sync_core_description">خێرایی تیکەکانی ناوک ڕێکبخە لەگەڵ ڕێژەی خێرایی بەرزترین بۆ باشترکردنی کارایی بەبێ گۆڕینی خێرایی ڕاستەقینەی یارییەکە.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">تیک</string>
     <string name="skip_cpu_inner_invalidation">بازنەکردنی ناوەکی CPU</string>
     <string name="skip_cpu_inner_invalidation_description">هەندێک لە بازنەکردنەکانی هەڵگر لە کاتی نوێکردنەوەی بیرگە دەنێرێت، کەمکردنەوەی بەکارهێنانی CPU و باشترکردنی کارایی. لەوانەیە لە هەندێک یاری کێشە درووست بکات.</string>
+    <string name="cpuopt_unsafe_host_mmu">چالاککردنی میمیکردنی MMU میواندە</string>
+    <string name="cpuopt_unsafe_host_mmu_description">ئەم باشکردنە خێرایی دەستکەوتنی بیرگە لەلایەن پرۆگرامی میوانەکە زیاد دەکات. چالاککردنی وای لێدەکات کە خوێندنەوە/نووسینەکانی بیرگەی میوانەکە ڕاستەوخۆ لە بیرگە ئەنجام بدرێت و میمیکردنی MMU میواندە بەکاربهێنێت. ناچالاککردنی ئەمە هەموو دەستکەوتنەکانی بیرگە ڕەت دەکاتەوە لە بەکارهێنانی میمیکردنی MMU نەرمەکاڵا.</string>
+    <string name="dma_accuracy">ئاستی DMA</string>
+    <string name="dma_accuracy_description">کۆنتڕۆڵی وردی ڕێکخستنی DMA دەکات. وردی زیاتر دەتوانێ هەندێک کێشە لە هەندێک یاری چارەسەر بکات، بەڵام لە هەندێک حاڵەتدا کاریگەری لەسەر کارایی هەیە. ئەگەر دڵنیا نیت، بە ڕێکخستنی بنەڕەتی بێڵە.</string>
 
     <string name="memory_4gb">4GB (پێشنیارکراو)</string>
     <string name="memory_6gb">6GB (نائاسایش)</string>
@@ -478,6 +482,8 @@
     <string name="use_custom_rtc">RTCی تایبەتمەند</string>
     <string name="use_custom_rtc_description">ڕێگەت پێدەدات کاتژمێرێکی کاتی ڕاستەقینەی تایبەتمەند دابنێیت کە جیاوازە لە کاتی ئێستای سیستەمەکەت.</string>
     <string name="set_custom_rtc">دانانی RTCی تایبەتمەند</string>
+    <string name="disable_nca_verification">ناچالاککردنی پشکنینی NCA</string>
+    <string name="disable_nca_verification_description">پشکنینی پێکهاتەی ئارشیڤەکانی ناوەڕۆکی NCA ناچالاک دەکات. ئەمە لەوانەیە خێرایی بارکردن به‌ره‌وپێش ببات، بەڵام مەترسی لەناوچوونی داتا یان ئەوەی فایلە نادروستەکان بەبێ ئەوەی دۆزرایەوە تێپەڕبن زیاتر دەکات. بۆ ئەوەی یاری و نوێکردنەوەکان کار بکەن کە پێویستی بە فریموێری 20+ هەیە زۆر پێویستە.</string>
 
     <!-- Network settings strings -->
     <string name="generate">بەرهەم هێنان</string>
@@ -654,6 +660,50 @@
     <string name="loader_requires_firmware">یارییەکە فریموێر پێویستە</string>
     <string name="loader_requires_firmware_description"><![CDATA[یارییەکە کە تۆ هەوڵ دەدەیت بیخەیتە کار فریموێر پێویستە بۆ کردنەوە یان تێپەڕاندنی مێنیوی کردنەوە. تکایە <a href="https://yuzu-mirror.github.io/help/quickstart"> فریموێر دامپ بکە و دابنێ</a>, یان پەنجە بنێ سەر "باشە" بۆ بەردەوامبوون هەرچۆنێک بێت.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">گەڕان بە دوای یارییە...</string>
+    <string name="game_not_found_for_title_id">یاری نەدۆزرایەوە بۆ ناسنامەی ناونیشان: %1$s</string>
+    <string name="custom_settings_failed_title">ڕێکخستنە هەڵبژێردراوەکان سەرکەوتوو نەبوو</string>
+    <string name="custom_settings_failed_message">سەرکەوتوو نەبوو لە جێبەجێکردنی ڕێکخستنە هەڵبژێردراوەکان بۆ %1$s: %2$s</string>
+    <string name="launch_with_default_settings">دەستپێکردن بە ڕێکخستنە بنەڕەتییەکان</string>
+    <string name="launch_cancelled">دەستپێکردن هەڵوەشیندراوە</string>
+    <string name="custom_settings_failure_reasons">ناتوانێت ڕێکخستنە داواکراوەکان جێبەجێ بکات. لەوانەیە ئەمە بەهۆی ونبوونی ڕاهێنەری GPU یان کێشەکانی ڕێکخستنەوە بێت.</string>
+    <string name="custom_settings_applied">ڕێکخستنە هەڵبژێردراوەکان جێبەجێ کرا</string>
+    <string name="launching_game">دەستپێکردنی %1$s...</string>
+    <string name="failed_to_initialize_game">سەرکەوتوو نەبوو لە دەستپێکردنی یارییەکە</string>
+    <string name="custom_intent_launch_message_with_settings">ئایا دەتەوێت %1$s بە ڕێکخستنە هەڵبژێردراوەکان دەستپێبکەیت؟</string>
+    <string name="custom_intent_launch_message">ئایا دەتەوێت %1$s دەستپێبکەیت?</string>
+    <string name="custom_intent_launch_title">دەستپێکردنی یاری</string>
+    <string name="launch">دەستپێکردن</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">سەرکەوتوو نەبوو لە نووسینی پەڕگەی ڕێکخستن</string>
+    <string name="config_apply_failed">سەرکەوتوو نەبوو لە جێبەجێکردنی ڕێکخستن</string>
+    <string name="config_already_exists_title">ڕێکخستن هەبووی تری هەیە</string>
+    <string name="config_already_exists_message">ڕێکخستنە هەڵبژێردراوەکان هەڵە بۆ %1$s.\n\nئایا دەتەوێت ڕێکخستنە هەبووەکە بسڕیتەوە؟\n\nناتوانیت ئەم کردارە بگەڕێنیتەوە.</string>
+    <string name="config_exists_prompt">پشکنین بۆ ڕێکخستنی ئێستا...</string>
+    <string name="overwrite_cancelled">سڕینەوە هەڵوەشیندراوە</string>
+    <string name="checking_driver">پشکنین بۆ ڕاهێنەری هەڵبژێردراو: %1$s</string>
+    <string name="driver_unavailable">ڕاهێنەری هەڵبژێردراو بۆ ئەم ئامێرە بەردەست نییە</string>
+    <string name="overwrite">سڕینەوە</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">ڕاهێنەری GPU ونبووە</string>
+    <string name="missing_gpu_driver_message">ڕاهێنەری هەڵبژێردراوی دیاریکراو \"%s\" دامەزراو نییە. ئایا دەتەوێت ئێستا دایببزێنیت و دامەزرێنیت?</string>
+    <string name="downloading_driver">داگرتنی ڕاهێنەر...</string>
+    <string name="driver_installed">ڕاهێنەر بە سەرکەوتوویی دامەزرا</string>
+    <string name="driver_installation_failed_title">دامەزرانی ڕاهێنەر سەرکەوتوو نەبوو</string>
+    <string name="driver_installation_failed_message">سەرکەوتوو نەبوو لە دامەزراندنی ڕاهێنەری GPU: %s</string>
+    <string name="driver_not_available_title">ڕاهێنەر بەردەست نییە</string>
+    <string name="driver_not_available_message">ڕاهێنەری دیاریکراو بۆ داگرتن بەردەست نییە.</string>
+    <string name="driver_not_found">ڕاهێنەری پێویست دامەزراو نییە: %s</string>
+    <string name="invalid_driver_file">پەڕگەی ڕاهێنەری نادروست: %s</string>
+    <string name="network_unavailable">هیچ پەیوەندییەکی تۆڕ بەردەست نییە. تکایە پەیوەندیی ئینتەرنێتەکەت بپشکنە و دووبارە هەوڵبدە.</string>
+    <string name="driver_missing_title">ڕاهێنەری GPU پێویستە</string>
+    <string name="driver_missing_message">ڕێکخستنی یارییەکە پێویستی بە ڕاهێنەری GPU \"%s\" هەیە کە لەسەر ئامێرەکەت دامەزراو نییە.\n\nئایا دەتەوێت ئێستا دایببزێنیت و دامەزرێنیت?</string>
+    <string name="driver_download_cancelled">داگرتنی ڕاهێنەر هەڵوەشیندراوە. ناتوانیت یارییەکە دەستپێبکەیت بەبێ ڕاهێنەری پێویست.</string>
+    <string name="download">داگرتن</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">دەرچوون لە ئیمولەیشن</string>
     <string name="emulation_done">تەواو</string>
@@ -662,7 +712,8 @@
     <string name="emulation_rel_stick_center">ناوەندی گێڕ بەنزیکەیی</string>
     <string name="emulation_dpad_slide">خلیسکانی 4 دوگمەکە</string>
     <string name="emulation_haptics">لەرینەوەی پەنجەلێدان</string>
-    <string name="emulation_show_overlay">نیشاندانی داپۆشەر</string>
+    <string name="emulation_show_overlay">نیشاندانی کۆنتڕۆڵەر</string>
+    <string name="emulation_hide_overlay">پیشاندانی کۆنتڕۆڵەر</string>
     <string name="emulation_toggle_all">گۆڕینی سەرجەم</string>
     <string name="emulation_control_adjust">ڕێکخستنی داپۆشەر</string>
     <string name="emulation_control_scale">پێوەر</string>
@@ -688,6 +739,7 @@
     <string name="fatal_error">هەڵەی کوشندە</string>
     <string name="fatal_error_message">هەڵەیەکی کوشندە ڕوویدا. بۆ وردەکارییەکان لۆگەکە بپشکنە.\nبەردەوامی ئیمولەیشن لەوانەیە ببێتە هۆی تێکچوون و فڕێدانەدەرەوە.</string>
     <string name="performance_warning">کوژاندنەوەی ئەم ڕێکخستنە دەبێتە هۆی کەمکردنەوەی کارایی ئیمولەیشن! بۆ باشترین ئەزموون، باشترە ئەم ڕێکخستنە چالاک بهێڵیتەوە.</string>
+
     <!-- Region Names -->
     <string name="region_japan">ژاپۆن</string>
     <string name="region_usa">ئەمریکا</string>
@@ -699,6 +751,7 @@
 
     <string name="memory_byte_shorthand">B</string>
     <string name="memory_gigabyte">GB</string>
+
     <!-- Renderer APIs -->
     <string name="renderer_vulkan">ڤوڵکان</string>
     <string name="renderer_none">هیچ</string>
@@ -708,6 +761,12 @@
     <string name="renderer_accuracy_high">بەرز</string>
     <string name="renderer_accuracy_extreme">ئەوپەڕ (خاو)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">بنەڕەتی</string>
+    <string name="dma_accuracy_normal">ئاسایی</string>
+    <string name="dma_accuracy_high">بەرز</string>
+    <string name="dma_accuracy_extreme">زۆر بەرز</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -84,7 +84,7 @@
     <string name="use_lru_cache">Povolit LRU mezipaměť</string>
     <string name="use_lru_cache_description">Povolte nebo zakažte mezipaměť LRU, čímž zvýšíte výkon snížením využití procesoru CPU. Některé hry s ní mají problémy, zejména TotK 1.2.1, takže ji deaktivujte, pokud hra neběží nebo náhodně padá.</string>
     <string name="dyna_state">Rozšířený dynamický stav</string>
-    <string name="dyna_state_description">Umožňuje funkce Vulkan pro zlepšení výkonu, vykreslování a úsporu zdrojů při vytváření pipeline při zachování nižšího využití CPU/GPU. Tato rozšíření mohou zvýšit teplotu zařízení a starší GPU řady A6XX nemusí správně reagovat. Vypněte pro emulaci měřítkových formátů.</string>
+    <string name="dyna_state_description">Ovládá počet funkcí, které lze použít v rozšířeném dynamickém stavu. Vyšší hodnoty umožňují více funkcí a mohou zvýšit výkon, ale mohou způsobit problémy s některými ovladači a výrobci. Výchozí hodnota se může lišit v závislosti na vašem systému a hardwarových schopnostech. Tuto hodnotu lze měnit, dokud nedosáhnete stability a lepší vizuální kvality.</string>
     <string name="disabled">Vypnuto</string>
     <string name="use_sync_core">Synchronizovat rychlost jádra</string>
     <string name="use_sync_core_description">Synchronizuje rychlost jádra s maximálním procentem rychlosti, aby se zlepšil výkon bez změny skutečné rychlosti hry.</string>
@@ -125,6 +125,10 @@
     <string name="cpu_ticks">Takty</string>
     <string name="skip_cpu_inner_invalidation">Přeskočit vnitřní invalidaci CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Přeskočí některé invalidace mezipaměti na straně CPU během aktualizací paměti, čímž sníží zatížení CPU a zlepší jeho výkon. Může způsobit chyby nebo pády v některých hrách.</string>
+    <string name="cpuopt_unsafe_host_mmu">Povolit emulaci hostitelské MMU</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Tato optimalizace zrychluje přístup do paměti hostovaného programu. Její povolení způsobí, že čtení a zápisy do paměti hosta se provádějí přímo v paměti a využívají hostitelskou MMU. Zakázání této funkce vynutí použití softwarové emulace MMU pro všechny přístupy do paměti.</string>
+    <string name="dma_accuracy">Úroveň DMA</string>
+    <string name="dma_accuracy_description">Ovládá přesnost DMA. Vyšší přesnost může opravit problémy v některých hrách, ale může také ovlivnit výkon. Pokud si nejste jisti, ponechejte výchozí nastavení.</string>
 
     <string name="memory_4gb">4GB (Doporučeno)</string>
     <string name="memory_6gb">6GB (Nebezpečné)</string>
@@ -454,6 +458,8 @@
     <string name="use_custom_rtc">Vlastní RTC</string>
     <string name="use_custom_rtc_description">Vlastní nastavení času</string>
     <string name="set_custom_rtc">Nastavit vlastní RTC</string>
+    <string name="disable_nca_verification">Zakázat ověřování NCA</string>
+    <string name="disable_nca_verification_description">Zakáže ověřování integrity archivů obsahu NCA. To může zlepšit rychlost načítání, ale hrozí poškození dat nebo neodhalení neplatných souborů. Je nutné, aby fungovaly hry a aktualizace vyžadující firmware 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Generovat</string>
@@ -634,6 +640,50 @@
     <string name="loader_requires_firmware">Hra vyžaduje firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Hra, kterou se pokoušíte spustit, vyžaduje firmware pro spuštění nebo pro překročení úvodní nabídky. Prosím <a href="https://yuzu-mirror.github.io/help/quickstart"> převezměte a nainstalujte firmware</a>, nebo stiskněte "OK" pro pokračování v každém případě.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Hledání hry...</string>
+    <string name="game_not_found_for_title_id">Hra nebyla nalezena pro ID titulu: %1$s</string>
+    <string name="custom_settings_failed_title">Vlastní nastavení selhalo</string>
+    <string name="custom_settings_failed_message">Nepodařilo se použít vlastní nastavení pro %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Spustit s výchozím nastavením</string>
+    <string name="launch_cancelled">Spuštění zrušeno</string>
+    <string name="custom_settings_failure_reasons">Nelze použít požadovaná nastavení. Důvodem může být chybějící ovladač GPU nebo problémy s konfigurací.</string>
+    <string name="custom_settings_applied">Vlastní nastavení použito</string>
+    <string name="launching_game">Spouštím %1$s...</string>
+    <string name="failed_to_initialize_game">Nepodařilo se inicializovat hru</string>
+    <string name="custom_intent_launch_message_with_settings">Chcete spustit %1$s s vlastním nastavením?</string>
+    <string name="custom_intent_launch_message">Chcete spustit %1$s?</string>
+    <string name="custom_intent_launch_title">Spustit hru</string>
+    <string name="launch">Spustit</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Nepodařilo se zapsat konfigurační soubor</string>
+    <string name="config_apply_failed">Nepodařilo se použít konfiguraci</string>
+    <string name="config_already_exists_title">Konfigurace již existuje</string>
+    <string name="config_already_exists_message">Vlastní nastavení již existuje pro %1$s.\n\nChcete přepsat stávající konfiguraci?\n\nTuto akci nelze vrátit zpět.</string>
+    <string name="config_exists_prompt">Kontrola existující konfigurace...</string>
+    <string name="overwrite_cancelled">Přepsání zrušeno</string>
+    <string name="checking_driver">Kontrola vlastního ovladače: %1$s</string>
+    <string name="driver_unavailable">Vlastní ovladač není pro toto zařízení k dispozici</string>
+    <string name="overwrite">Přepsat</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Chybí ovladač GPU</string>
+    <string name="missing_gpu_driver_message">Vybraný vlastní ovladač \"%s\" není nainstalován. Chcete jej nyní stáhnout и nainstalovat?</string>
+    <string name="downloading_driver">Stahování ovladače...</string>
+    <string name="driver_installed">Ovladač byl úspěšně nainstalován</string>
+    <string name="driver_installation_failed_title">Instalace ovladače selhala</string>
+    <string name="driver_installation_failed_message">Nepodařilo se nainstalovat ovladač GPU: %s</string>
+    <string name="driver_not_available_title">Ovladač není k dispozici</string>
+    <string name="driver_not_available_message">Vybraný ovladač není k dispozici ke stažení.</string>
+    <string name="driver_not_found">Požadovaný ovladač není nainstalován: %s</string>
+    <string name="invalid_driver_file">Neplatný soubor ovladače: %s</string>
+    <string name="network_unavailable">Není dostupné síťové připojení. Zkontrolujte prosím připojení k internetu a zkuste to znovu.</string>
+    <string name="driver_missing_title">Vyžadován ovladač GPU</string>
+    <string name="driver_missing_message">Konfigurace hry vyžaduje ovladač GPU \"%s\", který není na vašem zařízení nainstalován.\n\nChcete jej nyní stáhnout a nainstalovat?</string>
+    <string name="driver_download_cancelled">Stahování ovladače bylo zrušeno. Hru nelze spustit bez požadovaného ovladače.</string>
+    <string name="download">Stáhnout</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Ukončit emulaci</string>
     <string name="emulation_done">Hotovo</string>
@@ -643,7 +693,8 @@
     <string name="emulation_rel_stick_center">Relativní střed joysticku</string>
     <string name="emulation_dpad_slide">D-pad slide</string>
     <string name="emulation_haptics">Haptická odezva</string>
-    <string name="emulation_show_overlay">Zobrazit překryv</string>
+    <string name="emulation_show_overlay">Zobrazit ovladač</string>
+    <string name="emulation_hide_overlay">Skrýt ovladač</string>
     <string name="emulation_toggle_all">Přepnout vše</string>
     <string name="emulation_control_adjust">Upravit překryv</string>
     <string name="emulation_control_scale">Měřítko</string>
@@ -684,6 +735,12 @@
     <string name="renderer_accuracy_high">Vysoká</string>
     <string name="renderer_accuracy_extreme">Extrémní (Pomalé)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Výchozí</string>
+    <string name="dma_accuracy_normal">Normální</string>
+    <string name="dma_accuracy_high">Vysoká</string>
+    <string name="dma_accuracy_extreme">Extrémní</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">LRU-Cache aktivieren</string>
     <string name="use_lru_cache_description">Aktivieren oder deaktivieren Sie den LRU-Cache, um die Leistung durch Einsparung von CPU-Prozessorauslastung zu verbessern. Einige Spiele haben Probleme damit, insbesondere TotK 1.2.1, deaktivieren Sie es also, wenn das Spiel nicht startet oder zufällig abstürzt.</string>
     <string name="dyna_state">Erweiterter dynamischer Status</string>
-    <string name="dyna_state_description">Aktiviert Vulkan-Funktionen zur Verbesserung der Leistung, des Renderings und zur Einsparung von Ressourcen bei der Pipeline-Erstellung bei gleichzeitig geringer CPU/GPU-Auslastung. Diese Erweiterungen können die Gerätetemperatur erhöhen, und ältere GPUs der A6XX-Serie reagieren möglicherweise nicht richtig. Deaktivieren Sie dies, um skalierte Formate zu emulieren.</string>
+    <string name="dyna_state_description">Steuert die Anzahl der Funktionen, die im Erweiterten Dynamischen Zustand verwendet werden können. Höhere Werte ermöglichen mehr Funktionen und können die Leistung steigern, können jedoch bei einigen Treibern und Herstellern zu Problemen führen. Der Standardwert kann je nach System und Hardwarefähigkeiten variieren. Dieser Wert kann geändert werden, bis Stabilität und eine bessere visuelle Qualität erreicht sind.</string>
     <string name="disabled">Deaktiviert</string>
     <string name="use_sync_core">Kern-Geschwindigkeit synchronisieren</string>
     <string name="use_sync_core_description">Synchronisiert die Taktrate des Kerns mit der maximalen Geschwindigkeit, um die Leistung zu verbessern, ohne die tatsächliche Spielgeschwindigkeit zu verändern.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">CPU-interne Invalidierung überspringen</string>
     <string name="skip_cpu_inner_invalidation_description">Überspringt bestimmte Cache-Invalidierungen auf CPU-Seite während Speicherupdates, reduziert die CPU-Auslastung und verbessert die Leistung. Kann in einigen Spielen zu Fehlern oder Abstürzen führen.</string>
+    <string name="cpuopt_unsafe_host_mmu">Host-MMU-Emulation aktivieren</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Diese Optimierung beschleunigt Speicherzugriffe durch das Gastprogramm. Wenn aktiviert, erfolgen Speicherlese- und -schreibvorgänge des Gastes direkt im Speicher und nutzen die MMU des Hosts. Das Deaktivieren erzwingt die Verwendung der Software-MMU-Emulation für alle Speicherzugriffe.</string>
+    <string name="dma_accuracy">DMA-Level</string>
+    <string name="dma_accuracy_description">Steuert die DMA-Präzisionsgenauigkeit. Eine höhere Präzision kann Probleme in einigen Spielen beheben, kann aber in einigen Fällen auch die Leistung beeinträchtigen. Im Zweifel auf „Standard“ belassen.</string>
 
     <string name="memory_4gb">4 GB (Empfohlen)</string>
     <string name="memory_6gb">6 GB (Unsicher)</string>
@@ -482,6 +486,8 @@ Wird der Handheld-Modus verwendet, verringert es die Auflösung und erhöht die
     <string name="select_rtc_date">RTC-Datum auswählen</string>
     <string name="select_rtc_time">RTC-Zeit auswählen</string>
     <string name="use_custom_rtc">Benutzerdefinierte Echtzeituhr</string>
+    <string name="disable_nca_verification">NCA-Verifizierung deaktivieren</string>
+    <string name="disable_nca_verification_description">Deaktiviert die Integritätsprüfung von NCA-Inhaltsarchiven. Dies kann die Ladegeschwindigkeit verbessern, riskiert jedoch Datenbeschädigung oder dass ungültige Dateien unentdeckt bleiben. Ist notwendig, um Spiele und Updates, die Firmware 20+ benötigen, zum Laufen zu bringen.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Generieren</string>
@@ -710,10 +716,61 @@ Wirklich fortfahren?</string>
     <string name="loader_requires_firmware">Spiel erfordert Firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Das Spiel, das Sie starten möchten, benötigt Firmware zum Booten oder zum Überspringen des Startmenüs. Bitte <a href="https://yuzu-mirror.github.io/help/quickstart"> dumpen und installieren Sie Firmware</a>, oder drücken Sie "OK", um trotzdem zu starten.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Suche nach Spiel...</string>
+    <string name="game_not_found_for_title_id">Spiel nicht gefunden für Titel-ID: %1$s</string>
+    <string name="custom_settings_failed_title">Benutzerdefinierte Einstellungen fehlgeschlagen</string>
+    <string name="custom_settings_failed_message">Fehler beim Anwenden der benutzerdefinierten Einstellungen für %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Mit Standardeinstellungen starten</string>
+    <string name="launch_cancelled">Start abgebrochen</string>
+    <string name="custom_settings_failure_reasons">Die angeforderten Einstellungen konnten nicht angewendet werden. Dies kann an fehlenden GPU-Treibern oder Konfigurationsproblemen liegen.</string>
+    <string name="custom_settings_applied">Benutzerdefinierte Einstellungen übernommen</string>
+    <string name="launching_game">Starte %1$s...</string>
+    <string name="failed_to_initialize_game">Spielinitialisierung fehlgeschlagen</string>
+    <string name="custom_intent_launch_message_with_settings">Möchten Sie %1$s mit benutzerdefinierten Einstellungen starten?</string>
+    <string name="custom_intent_launch_message">Möchten Sie %1$s starten?</string>
+    <string name="custom_intent_launch_title">Spiel starten</string>
+    <string name="launch">Starten</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Konfigurationsdatei konnte nicht geschrieben werden</string>
+    <string name="config_apply_failed">Konfiguration konnte nicht angewendet werden</string>
+    <string name="config_already_exists_title">Konfiguration existiert bereits</string>
+    <string name="config_already_exists_message">Benutzerdefinierte Einstellungen existieren bereits für %1$s.\n\nMöchten Sie die bestehende Konfiguration überschreiben?\n\nDiese Aktion kann nicht rückgängig gemacht werden.</string>
+    <string name="config_exists_prompt">Überprüfe auf vorhandene Konfiguration...</string>
+    <string name="overwrite_cancelled">Überschreiben abgebrochen</string>
+    <string name="checking_driver">Üoverprüfe benutzerdefinierten Treiber: %1$s</string>
+    <string name="driver_unavailable">Benutzerdefinierter Treiber für dieses Gerät nicht verfügbar</string>
+    <string name="overwrite">Überschreiben</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">GPU-Treiber fehlt</string>
+    <string name="missing_gpu_driver_message">Der ausgewählte benutzerdefinierte Treiber \"%s\" ist nicht installiert. Möchten Sie ihn jetzt herunterladen und installieren?</string>
+    <string name="downloading_driver">Treiber wird heruntergeladen...</string>
+    <string name="driver_installed">Treiber erfolgreich installiert</string>
+    <string name="driver_installation_failed_title">Treiberinstallation fehlgeschlagen</string>
+    <string name="driver_installation_failed_message">Fehler beim Installieren des GPU-Treibers: %s</string>
+    <string name="driver_not_available_title">Treiber nicht verfügbar</string>
+    <string name="driver_not_available_message">Der ausgewählte Treiber ist nicht zum Download verfügbar.</string>
+    <string name="driver_not_found">Erforderlicher Treiber nicht installiert: %s</string>
+    <string name="invalid_driver_file">Ungültige Treiberdatei: %s</string>
+    <string name="network_unavailable">Keine Netzwerkverbindung verfügbar. Bitte überprüfen Sie Ihre Internetverbindung und versuchen Sie es erneut.</string>
+    <string name="driver_missing_title">GPU-Treiber erforderlich</string>
+    <string name="driver_missing_message">Die Spielkonfiguration erfordert den GPU-Treiber \"%s\", der auf Ihrem Gerät nicht installiert ist.\n\nMöchten Sie ihn jetzt herunterladen и installieren?</string>
+    <string name="driver_download_cancelled">Treiberdownload abgebrochen. Das Spiel kann ohne den erforderlichen Treiber nicht gestartet werden.</string>
+    <string name="download">Herunterladen</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Emulation beenden</string>
     <string name="emulation_done">Fertig</string>
     <string name="emulation_fps_counter">FPS Zähler</string>
+    <string name="emulation_thermal_indicator"></string>
+    <string name="emulation_toggle_controls">Steuerung umschalten</string>
+    <string name="emulation_rel_stick_center">Relativer Stick-Zentrum</string>
+    <string name="emulation_dpad_slide">D-Pad-Scrollen</string>
+    <string name="emulation_haptics">Haptisches Feedback</string>
+    <string name="emulation_show_overlay">Controller anzeigen</string>
+    <string name="emulation_hide_overlay">Controller ausblenden</string>
     <string name="emulation_toggle_all">Alle umschalten</string>
     <string name="emulation_control_adjust">Overlay anpassen</string>
     <string name="emulation_control_scale">Größe</string>
@@ -770,6 +827,12 @@ Wirklich fortfahren?</string>
     <string name="renderer_accuracy_high">Hoch</string>
     <string name="renderer_accuracy_extreme">Extrem (Langsam)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Standard</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Hoch</string>
+    <string name="dma_accuracy_extreme">Extrem</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Habilitar caché LRU</string>
     <string name="use_lru_cache_description">Activa o desactiva la caché LRU, mejorando el rendimiento al ahorrar uso del proceso de la CPU. Algunos juegos tienen problemas con ella, notablemente TotK 1.2.1, así que desactívala si el juego no inicia o se cierra aleatoriamente.</string>
     <string name="dyna_state">Estado dinámico extendido</string>
-    <string name="dyna_state_description">Habilita funciones de Vulkan para mejorar el rendimiento, el renderizado y ahorrar recursos en la creación de pipelines manteniendo un uso bajo de CPU/GPU. Estas extensiones pueden aumentar la temperatura del dispositivo, y las GPU de la antigua línea A6XX pueden no reaccionar correctamente. Desactívalo para emular formatos escalados.</string>
+    <string name="dyna_state_description">Controla la cantidad de funciones que se pueden usar en el Estado Dinámico Extendido. Los valores más altos permiten más funciones y pueden aumentar el rendimiento, pero pueden causar problemas con algunos controladores y fabricantes. El valor predeterminado puede variar según su sistema y las capacidades de su hardware. Este valor se puede cambiar hasta lograr estabilidad y una mejor calidad visual.</string>
     <string name="disabled">Desactivado</string>
     <string name="use_sync_core">Sincronizar velocidad del núcleo</string>
     <string name="use_sync_core_description">Sincroniza la velocidad del núcleo con el porcentaje máximo de velocidad para mejorar el rendimiento sin alterar la velocidad real del juego.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">Omitir invalidación interna de la CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Omite ciertas invalidaciones de caché durante actualizaciones de memoria, reduciendo el uso de CPU y mejorando su rendimiento. Puede causar fallos en algunos juegos.</string>
+    <string name="cpuopt_unsafe_host_mmu">Habilitar emulación de MMU del host</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Esta optimización acelera los accesos a la memoria por parte del programa invitado. Al habilitarla, las lecturas/escrituras de memoria del invitado se realizan directamente en la memoria y utilizan la MMU del host. Deshabilitar esto obliga a que todos los accesos a la memoria utilicen la emulación de MMU por software.</string>
+    <string name="dma_accuracy">Nivel de DMA</string>
+    <string name="dma_accuracy_description">Controla la precisión del DMA. Una mayor precisión puede solucionar problemas en algunos juegos, pero también puede afectar el rendimiento en algunos casos. Si no está seguro, déjelo en Predeterminado.</string>
 
     <string name="memory_4gb">4GB (Recomendado)</string>
     <string name="memory_6gb">6GB (Inseguro)</string>
@@ -502,6 +506,8 @@
     <string name="use_custom_rtc">RTC personalizado</string>
     <string name="use_custom_rtc_description">Te permite tener un reloj personalizado en tiempo real diferente del tiempo del propio sistema.</string>
     <string name="set_custom_rtc">Configurar RTC personalizado</string>
+    <string name="disable_nca_verification">Desactivar verificación NCA</string>
+    <string name="disable_nca_verification_description">Desactiva la verificación de integridad de los archivos de contenido NCA. Esto puede mejorar la velocidad de carga, pero arriesga corrupción de datos o que archivos inválidos pasen desapercibidos. Es necesario para que funcionen juegos y actualizaciones que requieren firmware 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Generar</string>
@@ -749,6 +755,50 @@
     <string name="loader_requires_firmware">El juego requiere firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[El juego que intentas iniciar requiere firmware para arrancar o pasar el menú de inicio. Por favor <a href="https://yuzu-mirror.github.io/help/quickstart"> vuelca e instala el firmware</a>, o pulsa "Aceptar" para continuar de todos modos.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Buscando juego...</string>
+    <string name="game_not_found_for_title_id">Juego no encontrado para el ID de título: %1$s</string>
+    <string name="custom_settings_failed_title">Configuración personalizada fallida</string>
+    <string name="custom_settings_failed_message">Error al aplicar la configuración personalizada para %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Iniciar con configuración predeterminada</string>
+    <string name="launch_cancelled">Inicio cancelado</string>
+    <string name="custom_settings_failure_reasons">No se pueden aplicar los ajustes solicitados. Esto puede deberse a controladores GPU faltantes o problemas de configuración.</string>
+    <string name="custom_settings_applied">Configuración personalizada aplicada</string>
+    <string name="launching_game">Iniciando %1$s...</string>
+    <string name="failed_to_initialize_game">Error al inicializar el juego</string>
+    <string name="custom_intent_launch_message_with_settings">¿Quieres iniciar %1$s con configuración personalizada?</string>
+    <string name="custom_intent_launch_message">¿Quieres iniciar %1$s?</string>
+    <string name="custom_intent_launch_title">Iniciar juego</string>
+    <string name="launch">Iniciar</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Error al escribir el archivo de configuración</string>
+    <string name="config_apply_failed">Error al aplicar la configuración</string>
+    <string name="config_already_exists_title">La configuración ya existe</string>
+    <string name="config_already_exists_message">Ya existe una configuración personalizada para %1$s.\n\n¿Quieres sobrescribir la configuración existente?\n\nEsta acción no se puede deshacer.</string>
+    <string name="config_exists_prompt">Comprobando la configuración existente...</string>
+    <string name="overwrite_cancelled">Sobrescritura cancelada</string>
+    <string name="checking_driver">Comprobando controlador personalizado: %1$s</string>
+    <string name="driver_unavailable">Controlador personalizado no disponible para este dispositivo</string>
+    <string name="overwrite">Sobrescribir</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Falta controlador de GPU</string>
+    <string name="missing_gpu_driver_message">El controlador personalizado seleccionado \"%s\" no está instalado. ¿Quieres descargarlo e instalarlo ahora?</string>
+    <string name="downloading_driver">Descargando controlador...</string>
+    <string name="driver_installed">Controlador instalado correctamente</string>
+    <string name="driver_installation_failed_title">Error en la instalación del controlador</string>
+    <string name="driver_installation_failed_message">Error al instalar el controlador de GPU: %s</string>
+    <string name="driver_not_available_title">Controlador no disponible</string>
+    <string name="driver_not_available_message">El controlador seleccionado no está disponible para descargar.</string>
+    <string name="driver_not_found">Controlador requerido no instalado: %s</string>
+    <string name="invalid_driver_file">Archivo de controlador no válido: %s</string>
+    <string name="network_unavailable">No hay conexión de red disponible. Por favor, compruebe su conexión a Internet e inténtelo de nuevo.</string>
+    <string name="driver_missing_title">Se requiere controlador de GPU</string>
+    <string name="driver_missing_message">La configuración del juego requiere el controlador de GPU \"%s\" que no está instalado en su dispositivo.\n\n¿Quieres descargarlo e instalarlo ahora?</string>
+    <string name="driver_download_cancelled">Descarga del controlador cancelada. El juego no se puede iniciar sin el controlador requerido.</string>
+    <string name="download">Descargar</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Salir de la emulación</string>
     <string name="emulation_done">Hecho</string>
@@ -758,7 +808,8 @@
     <string name="emulation_rel_stick_center">Centro relativo del stick</string>
     <string name="emulation_dpad_slide">Deslizamiento de la cruceta</string>
     <string name="emulation_haptics">Toques hápticos</string>
-    <string name="emulation_show_overlay">Mostrar overlay</string>
+    <string name="emulation_show_overlay">Mostrar controlador</string>
+    <string name="emulation_hide_overlay">Ocultar controlador</string>
     <string name="emulation_toggle_all">Alternar todo</string>
     <string name="emulation_control_adjust">Ajustar overlay</string>
     <string name="emulation_control_scale">Escala</string>
@@ -819,6 +870,12 @@
     <string name="renderer_accuracy_high">Alto</string>
     <string name="renderer_accuracy_extreme">Extremo (Lento)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Predeterminado</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Alto</string>
+    <string name="dma_accuracy_extreme">Extremo</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">فعال‌سازی حافظه نهان LRU</string>
     <string name="use_lru_cache_description">حافظه پنهان LRU را فعال یا غیرفعال کنید تا با کاهش استفاده از پردازنده، عملکرد بهبود یابد. برخی بازی‌ها مانند TotK 1.2.1 با این ویژگی مشکل دارند، در صورت عدم راه‌اندازی یا قطعی تصادفی بازی، آن را غیرفعال کنید.</string>
     <string name="dyna_state">حالت پویای گسترده</string>
-    <string name="dyna_state_description">قابلیت‌های ولکان را برای بهبود عملکرد، رندرینگ و صرفه‌جویی در منابع هنگام ایجاد خط لوله فعال می‌کند، در حالی که استفاده کمتری از CPU/GPU دارد. این پسوندها ممکن است دمای دستگاه را افزایش دهند و GPUهای قدیمی خط A6XX ممکن است به درستی واکنش نشان ندهند. برای شبیه‌سازی فرمت‌های مقیاس‌شده غیرفعال کنید.</string>
+    <string name="dyna_state_description">تعداد قابلیت‌هایی که می‌توان در حالت Extended Dynamic State استفاده کرد را کنترل می‌کند. اعداد بالاتر قابلیت‌های بیشتری را فعال کرده و می‌توانند عملکرد را افزایش دهند، اما ممکن است با برخی درایورها و فروشندگان مشکلاتی ایجاد کنند. مقدار پیش‌فرض بسته به سیستم و قابلیت‌های سخت‌افزاری شما ممکن است متفاوت باشد. این مقدار را می‌توان تغییر داد تا زمانی که پایداری و کیفیت بصری بهتری حاصل شود.</string>
     <string name="disabled">غیرفعال</string>
     <string name="use_sync_core">همگام‌سازی سرعت هسته</string>
     <string name="use_sync_core_description">همگام‌سازی سرعت هسته با حداکثر درصد سرعت برای بهبود عملکرد بدون تغییر سرعت واقعی بازی.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">تیک‌ها</string>
     <string name="skip_cpu_inner_invalidation">رد کردن ابطال داخلی CPU</string>
     <string name="skip_cpu_inner_invalidation_description">بعضی ابطال‌های حافظه نهان در هنگام به‌روزرسانی‌های حافظه را رد می‌کند، استفاده از CPU را کاهش داده و عملکرد آن را بهبود می‌بخشد. ممکن است در برخی بازی‌ها باعث مشکلات یا خرابی شود.</string>
+    <string name="cpuopt_unsafe_host_mmu">فعال‌سازی شبیه‌سازی MMU میزبان</string>
+    <string name="cpuopt_unsafe_host_mmu_description">این بهینه‌سازی دسترسی‌های حافظه توسط برنامه میهمان را تسریع می‌کند. فعال‌سازی آن باعث می‌شود خواندن/نوشتن حافظه میهمان مستقیماً در حافظه انجام شود و از MMU میزبان استفاده کند. غیرفعال کردن این قابلیت، همه دسترسی‌های حافظه را مجبور به استفاده از شبیه‌سازی نرم‌افزاری MMU می‌کند.</string>
+    <string name="dma_accuracy">سطح DMA</string>
+    <string name="dma_accuracy_description">دقت صحت DMA را کنترل می کند. دقت بالاتر می تواند مشکلات برخی بازی ها را برطرف کند، اما در برخی موارد نیز می تواند بر عملکرد تأثیر بگذارد. اگر مطمئن نیستید، آن را روی پیش فرض بگذارید.</string>
 
     <string name="memory_4gb">4 گیگابایت (توصیه شده)</string>
     <string name="memory_6gb">6 گیگابایت (ناامن)</string>
@@ -500,6 +504,8 @@
     <string name="use_custom_rtc">زمان سفارشی</string>
     <string name="use_custom_rtc_description">به شما امکان می‌دهد یک ساعت سفارشی جدا از زمان فعلی سیستم خود تنظیم کنید.</string>
     <string name="set_custom_rtc">تنظیم زمان سفارشی</string>
+    <string name="disable_nca_verification">غیرفعال کردن تأیید اعتبار NCA</string>
+    <string name="disable_nca_verification_description">بررسی صحت آرشیوهای محتوای NCA را غیرفعال می‌کند. این ممکن است سرعت بارگذاری را بهبود بخشد اما خطر خرابی داده یا تشخیص داده نشدن فایل‌های نامعتبر را به همراه دارد. برای کار کردن بازی‌ها و به‌روزرسانی‌هایی که به فرمور ۲۰+ نیاز دارند، ضروری است.</string>
 
     <!-- Network settings strings -->
     <string name="generate">تولید</string>
@@ -748,6 +754,50 @@
     <string name="loader_requires_firmware">بازی نیاز به فیرمور دارد</string>
     <string name="loader_requires_firmware_description"><![CDATA[بازی که می‌خواهید اجرا کنید برای بوت شدن یا عبور از منوی شروع نیاز به فیرمور دارد. لطفا <a href="https://yuzu-mirror.github.io/help/quickstart"> فیرمور را دامپ و نصب کنید</a> یا برای ادامه کار "تایید" را فشار دهید.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">در حال جستجوی بازی...</string>
+    <string name="game_not_found_for_title_id">بازی برای شناسه عنوان یافت نشد: %1$s</string>
+    <string name="custom_settings_failed_title">تنظیمات سفارشی ناموفق بود</string>
+    <string name="custom_settings_failed_message">اعمال تنظیمات سفارشی برای %1$s ناموفق بود: %2$s</string>
+    <string name="launch_with_default_settings">اجرا با تنظیمات پیش‌فرض</string>
+    <string name="launch_cancelled">اجرا لغو شد</string>
+    <string name="custom_settings_failure_reasons">قادر به اعمال تنظیمات درخواستی نیست. این ممکن است به دلیل عدم وجود درایورهای GPU یا مشکلات پیکربندی باشد.</string>
+    <string name="custom_settings_applied">تنظیمات سفارشی اعمال شد</string>
+    <string name="launching_game">در حال اجرای %1$s...</string>
+    <string name="failed_to_initialize_game">مشکل در مقداردهی اولیه بازی</string>
+    <string name="custom_intent_launch_message_with_settings">آیا می‌خواهید %1$s را با تنظیمات سفارشی اجرا کنید؟</string>
+    <string name="custom_intent_launch_message">آیا می‌خواهید %1$s را اجرا کنید؟</string>
+    <string name="custom_intent_launch_title">اجرای بازی</string>
+    <string name="launch">اجرا</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">نوشتن فایل پیکربندی ناموفق بود</string>
+    <string name="config_apply_failed">اعمال پیکربندی ناموفق بود</string>
+    <string name="config_already_exists_title">پیکربندی از قبل وجود دارد</string>
+    <string name="config_already_exists_message">تنظیمات سفارشی از قبل برای %1$s وجود دارد.\n\nآیا می‌خواهید پیکربندی موجود را بازنویسی کنید؟\n\nاین عمل قابل بازگشت نیست.</string>
+    <string name="config_exists_prompt">در حال بررسی پیکربندی موجود...</string>
+    <string name="overwrite_cancelled">بازنویسی لغو شد</string>
+    <string name="checking_driver">در حال بررسی درایور سفارشی: %1$s</string>
+    <string name="driver_unavailable">درایور سفارشی برای این دستگاه در دسترس نیست</string>
+    <string name="overwrite">بازنویسی</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">درایور GPU یافت نشد</string>
+    <string name="missing_gpu_driver_message">درایور سفارشی انتخاب شده \"%s\" نصب نشده است. آیا می‌خواهید هم اکنون آن را دانلود و نصب کنید؟</string>
+    <string name="downloading_driver">در حال دانلود درایور...</string>
+    <string name="driver_installed">درایور با موفقیت نصب شد</string>
+    <string name="driver_installation_failed_title">نصب درایور ناموفق بود</string>
+    <string name="driver_installation_failed_message">نصب درایور GPU ناموفق بود: %s</string>
+    <string name="driver_not_available_title">درایور در دسترس نیست</string>
+    <string name="driver_not_available_message">درایور انتخاب شده برای دانلود در دسترس نیست.</string>
+    <string name="driver_not_found">درایور مورد نیاز نصب نشده است: %s</string>
+    <string name="invalid_driver_file">فایل درایور نامعتبر: %s</string>
+    <string name="network_unavailable">اتصال شبکه در دسترس نیست. لطفاً اتصال اینترنت خود را بررسی کرده و مجدداً تلاش کنید.</string>
+    <string name="driver_missing_title">درایور GPU مورد نیاز است</string>
+    <string name="driver_missing_message">پیکربندی بازی به درایور GPU \"%s\" نیاز دارد که روی دستگاه شما نصب نیست.\n\nآیا می‌خواهید هم اکنون آن را دانلود و نصب کنید?</string>
+    <string name="driver_download_cancelled">دانلود درایور لغو شد. بازی بدون درایور مورد نیاز قابل اجرا نیست.</string>
+    <string name="download">دانلود</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">خروج از شبیه‌سازی</string>
     <string name="emulation_done">انجام شد</string>
@@ -757,7 +807,8 @@
     <string name="emulation_rel_stick_center">مرکز نسبی استیک</string>
     <string name="emulation_dpad_slide">لغزش دکمه‌های جهتی</string>
     <string name="emulation_haptics">لرزش لمسی</string>
-    <string name="emulation_show_overlay">نشان دادن نمایش روی صفحه</string>
+    <string name="emulation_show_overlay">نمایش کنترلر</string>
+    <string name="emulation_hide_overlay">پنهان کردن کنترلر</string>
     <string name="emulation_toggle_all">تغییر همه</string>
     <string name="emulation_control_adjust">تنظیم نمایش روی صفحه</string>
     <string name="emulation_control_scale">مقیاس</string>
@@ -818,6 +869,12 @@
     <string name="renderer_accuracy_high">زیاد</string>
     <string name="renderer_accuracy_extreme">افراطی (کند)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">پیش فرض</string>
+    <string name="dma_accuracy_normal">معمولی</string>
+    <string name="dma_accuracy_high">بالا</string>
+    <string name="dma_accuracy_extreme">فوق العاده</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Activer le cache LRU</string>
     <string name="use_lru_cache_description">Active ou désactive le cache LRU pour améliorer les performances en réduisant l\'utilisation du processeur. Certains jeux comme TotK 1.2.1 ont des problèmes - désactivez-le si le jeu ne démarre pas ou plante aléatoirement.</string>
     <string name="dyna_state">État dynamique étendu</string>
-    <string name="dyna_state_description">Active les fonctionnalités Vulkan pour améliorer les performances, le rendu et économiser les ressources lors de la création des pipelines tout en maintenant une utilisation réduite du CPU/GPU. Ces extensions peuvent augmenter la température de l\'appareil et les GPU anciens de la série A6XX peuvent mal réagir. Désactivez pour émuler les formats mis à l\'échelle.</string>
+    <string name="dyna_state_description">Contrôle le nombre de fonctionnalités utilisables dans l\'état dynamique étendu. Des valeurs plus élevées permettent plus de fonctionnalités et peuvent augmenter les performances, mais peuvent causer des problèmes avec certains pilotes et fabricants. La valeur par défaut peut varier selon votre système et vos capacités matérielles. Cette valeur peut être modifiée jusqu\'à obtenir une stabilité et une meilleure qualité visuelle.</string>
     <string name="disabled">Désactivé</string>
     <string name="use_sync_core">Synchroniser la vitesse du cœur</string>
     <string name="use_sync_core_description">Synchronise la vitesse du cœur avec le pourcentage de vitesse maximal pour améliorer les performances sans modifier la vitesse réelle du jeu.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">Ignorer l\'invalidation interne du CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Ignore certaines invalidations de cache côté CPU lors des mises à jour mémoire, réduisant l\'utilisation du CPU et améliorant ses performances. Peut causer des bugs ou plantages sur certains jeux.</string>
+    <string name="cpuopt_unsafe_host_mmu">Activer l\'émulation de la MMU hôte</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Cette optimisation accélère les accès mémoire par le programme invité. L\'activer entraîne que les lectures/écritures mémoire de l\'invité sont effectuées directement en mémoire et utilisent la MMU de l\'hôte. Désactiver cela force tous les accès mémoire à utiliser l\'émulation logicielle de la MMU.</string>
+    <string name="dma_accuracy">Niveau DMA</string>
+    <string name="dma_accuracy_description">Contrôle la précision du DMA. Une précision plus élevée peut résoudre les problèmes dans certains jeux, mais peut aussi affecter les performances dans certains cas. Si vous n\'êtes pas sûr, laissez-la sur Défaut.</string>
 
     <string name="memory_4gb">4 Go (Recommandé)</string>
     <string name="memory_6gb">6 Go (Dangereux)</string>
@@ -502,6 +506,8 @@
     <string name="use_custom_rtc">RTC personnalisé</string>
     <string name="use_custom_rtc_description">Vous permet de définir une horloge en temps réel personnalisée distincte de l\'heure actuelle de votre système.</string>
     <string name="set_custom_rtc">Définir l\'horloge RTC personnalisée</string>
+    <string name="disable_nca_verification">Désactiver la vérification NCA</string>
+    <string name="disable_nca_verification_description">Désactive la vérification d\'intégrité des archives de contenu NCA. Cela peut améliorer la vitesse de chargement mais risque une corruption des données ou que des fichiers invalides ne soient pas détectés. Est nécessaire pour faire fonctionner les jeux et mises à jour nécessitant un firmware 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Générer</string>
@@ -797,6 +803,50 @@
     <string name="loader_requires_firmware">Jeu nécessite un firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Ce jeu nécessite un firmware pour démarrer ou passer le menu d\'accueil. Veuillez <a href="https://yuzu-mirror.github.io/help/quickstart">dumper et installer le firmware</a> ou appuyez sur "OK" pour continuer quand même.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Recherche du jeu...</string>
+    <string name="game_not_found_for_title_id">Jeu non trouvé pour l\'ID de titre : %1$s</string>
+    <string name="custom_settings_failed_title">Échec des paramètres personnalisés</string>
+    <string name="custom_settings_failed_message">Échec de l\'application des paramètres personnalisés pour %1$s : %2$s</string>
+    <string name="launch_with_default_settings">Lancer avec les paramètres par défaut</string>
+    <string name="launch_cancelled">Lancement annulé</string>
+    <string name="custom_settings_failure_reasons">Impossible d\'appliquer les paramètres demandés. Cela peut être dû à des pilotes GPU manquants ou à des problèmes de configuration.</string>
+    <string name="custom_settings_applied">Paramètres personnalisés appliqués</string>
+    <string name="launching_game">Lancement de %1$s...</string>
+    <string name="failed_to_initialize_game">Échec de l\'initialisation du jeu</string>
+    <string name="custom_intent_launch_message_with_settings">Voulez-vous lancer %1$s avec des paramètres personnalisés ?</string>
+    <string name="custom_intent_launch_message">Voulez-vous lancer %1$s ?</string>
+    <string name="custom_intent_launch_title">Lancer le jeu</string>
+    <string name="launch">Lancer</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Échec de l\'écriture du fichier de configuration</string>
+    <string name="config_apply_failed">Échec de l\'application de la configuration</string>
+    <string name="config_already_exists_title">Configuration déjà existante</string>
+    <string name="config_already_exists_message">Des paramètres personnalisés existent déjà pour %1$s.\n\nVoulez-vous écraser la configuration existante ?\n\nCette action ne peut pas être annulée.</string>
+    <string name="config_exists_prompt">Vérification de la configuration existante...</string>
+    <string name="overwrite_cancelled">Écrasement annulé</string>
+    <string name="checking_driver">Vérification du pilote personnalisé : %1$s</string>
+    <string name="driver_unavailable">Pilote personnalisé non disponible pour cet appareil</string>
+    <string name="overwrite">Écraser</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Pilote GPU manquant</string>
+    <string name="missing_gpu_driver_message">Le pilote personnalisé sélectionné \"%s\" n\'est pas installé. Voulez-vous le télécharger et l\'installer maintenant ?</string>
+    <string name="downloading_driver">Téléchargement du pilote...</string>
+    <string name="driver_installed">Pilote installé avec succès</string>
+    <string name="driver_installation_failed_title">Échec de l\'installation du pilote</string>
+    <string name="driver_installation_failed_message">Échec de l\'installation du pilote GPU : %s</string>
+    <string name="driver_not_available_title">Pilote non disponible</string>
+    <string name="driver_not_available_message">Le pilote sélectionné n\'est pas disponible au téléchargement.</string>
+    <string name="driver_not_found">Pilote requis non installé : %s</string>
+    <string name="invalid_driver_file">Fichier de pilote invalide : %s</string>
+    <string name="network_unavailable">Aucune connexion réseau disponible. Veuillez vérifier votre connexion Internet et réessayer.</string>
+    <string name="driver_missing_title">Pilote GPU requis</string>
+    <string name="driver_missing_message">La configuration du jeu nécessite le pilote GPU \"%s\" qui n\'est pas installé sur votre appareil.\n\nVoulez-vous le télécharger et l\'installer maintenant ?</string>
+    <string name="driver_download_cancelled">Téléchargement du pilote annulé. Le jeu ne peut pas être lancé sans le pilote requis.</string>
+    <string name="download">Télécharger</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Quitter l\'émulation</string>
     <string name="emulation_done">Terminé</string>
@@ -806,7 +856,8 @@
     <string name="emulation_rel_stick_center">Centre du stick relatif</string>
     <string name="emulation_dpad_slide">Glissement du D-pad</string>
     <string name="emulation_haptics">Toucher haptique</string>
-    <string name="emulation_show_overlay">Afficher l\'overlay</string>
+    <string name="emulation_show_overlay">Afficher la manette</string>
+    <string name="emulation_hide_overlay">Masquer la manette</string>
     <string name="emulation_toggle_all">Tout basculer</string>
     <string name="emulation_control_adjust">Ajuster l\'overlay</string>
     <string name="emulation_control_scale">Échelle</string>
@@ -867,6 +918,12 @@
     <string name="renderer_accuracy_high">Haut</string>
     <string name="renderer_accuracy_extreme">Extrême (Lent)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Défaut</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Élevé</string>
+    <string name="dma_accuracy_extreme">Extrême</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">הפעלת מטמון LRU</string>
     <string name="use_lru_cache_description">הפעל או השבת מטמון LRU לשיפור ביצועים על ידי חיסכון בשימוש במעבד. לחלק מהמשחקים כמו TotK 1.2.1 יש בעיות - השבת אם המשחק לא עולה או קורס באקראי.</string>
     <string name="dyna_state">מצב דינמי מורחב</string>
-    <string name="dyna_state_description">מאפשר תכונות Vulkan לשיפור ביצועים, רינדור וחיסכון במשאבים בעת יצירת צינורות עיבוד תוך שמירה על שימוש נמוך במעבד/מעבד גרפי. הרחבות אלו עלולות להעלות את טמפרטורת המכשיר, ומעבדים גרפיים מקו A6XX הישן עשויים לא להגיב כראוי. השבת כדי לדמות פורמטים מוקטנים.</string>
+    <string name="dyna_state_description">שולט במספר התכונות שניתן להשתמש בהן במצב דינמי מורחב. מספרים גבוהים יותר מאפשרים יותר תכונות ויכולים לשפר את הביצועים, אך עלולים לגרום לבעיות עם כמה מנהלי התקנים וספקים. הערך המוגדר כברירת מחדל עשוי להשתנות בהתאם למערכת שלך ויכולות החומרה. ניתן לשנות ערך זה עד להשגת יציבות ואיכות ויזואלית טובה יותר.</string>
     <string name="disabled">מושבת</string>
     <string name="use_sync_core">סנכרון מהירות ליבה</string>
     <string name="use_sync_core_description">סנכרן את מהירות הליבה לאחוז המהירות המרבי כדי לשפר ביצועים מבלי לשנות את מהירות המשחק בפועל.</string>
@@ -127,6 +127,10 @@
     <string name="cpu_ticks">טיקים</string>
     <string name="skip_cpu_inner_invalidation">דלג על איפוס מטמון פנימי של המעבד</string>
     <string name="skip_cpu_inner_invalidation_description">מדלג על איפוסי מטמון מסוימים במהלך עדכוני זיכרון, מפחית שימוש במעבד ומשפר ביצועים. עלול לגרום לתקלות או קריסות בחלק מהמשחקים.</string>
+    <string name="cpuopt_unsafe_host_mmu">הפעל אמולציית MMU מארח</string>
+    <string name="cpuopt_unsafe_host_mmu_description">אופטימיזציה זו מאיצה את גישת הזיכרון על ידי התוכנית האורחת. הפעלתה גורמת לכך שפעולות קריאה/כתיבה לזיכרון האורח מתבצעות ישירות לזיכרון ומשתמשות ב-MMU של המארח. השבתת זאת מאלצת את כל גישות הזיכרון להשתמש באמולציית MMU תוכנתית.</string>
+    <string name="dma_accuracy">רמת DMA</string>
+    <string name="dma_accuracy_description">שולטת בדיוק הדיוק של DMA. דיוק גבוה יותר יכול לתקן בעיות בחלק מהמשחקים, אך הוא עלול גם להשפיע על הביצועים במקרים מסוימים. אם אינך בטוח, השאר ברירת מחדל.</string>
 
     <string name="memory_4gb">4GB (מומלץ)</string>
     <string name="memory_6gb">6GB (לא בטוח)</string>
@@ -501,6 +505,8 @@
     <string name="use_custom_rtc">RTC מותאם אישית</string>
     <string name="use_custom_rtc_description">מאפשר לך לקבוע שעון זמן אמת נפרד משעון המערכת שלך.</string>
     <string name="set_custom_rtc">קבע RTC מותאם אישית</string>
+    <string name="disable_nca_verification">השבת אימות NCA</string>
+    <string name="disable_nca_verification_description">משבית את אימות השלמות של ארכיוני התוכן של NCA. זה עשוי לשפר את מהירות הטעינה אך מסתכן בשחיקת נתונים או שמא קבצים לא חוקיים יעברו ללא זיהוי. זה הכרחי כדי לגרום למשחקים ועדכונים הדורשים firmware 20+ לעבוד.</string>
 
     <!-- Network settings strings -->
     <string name="generate">יצירה</string>
@@ -683,6 +689,50 @@
     <string name="loader_requires_firmware">המשחק דורש קושחה</string>
     <string name="loader_requires_firmware_description"><![CDATA[המשחק שאתה מנסה להפעיל דורש קושחה לאתחול או למעבר מתפריט הפתיחה. אנא <a href="https://yuzu-mirror.github.io/help/quickstart">שמור והתקן קושחה</a> או לחץ "אישור" כדי להמשיך בכל מקרה.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">מחפש משחק...</string>
+    <string name="game_not_found_for_title_id">משחק לא נמצא למזהה כותרת: %1$s</string>
+    <string name="custom_settings_failed_title">הגדרות מותאמות אישית נכשלו</string>
+    <string name="custom_settings_failed_message">נכשל בהחלת הגדרות מותאמות אישית עבור %1$s: %2$s</string>
+    <string name="launch_with_default_settings">הפעל עם הגדרות ברירת מחדל</string>
+    <string name="launch_cancelled">ההפעלה בוטלה</string>
+    <string name="custom_settings_failure_reasons">לא ניתן להחיל את ההגדרות המבוקשות. זה עשוי להיות עקב חסרון מנהלי התקן של GPU או בעיות תצורה.</string>
+    <string name="custom_settings_applied">הגדרות מותאמות אישית הוחלו</string>
+    <string name="launching_game">מפעיל את %1$s...</string>
+    <string name="failed_to_initialize_game">נכשל באתחול המשחק</string>
+    <string name="custom_intent_launch_message_with_settings">האם ברצונך להפעיל את %1$s עם הגדרות מותאמות אישית?</string>
+    <string name="custom_intent_launch_message">האם ברצונך להפעיל את %1$s?</string>
+    <string name="custom_intent_launch_title">הפעל משחק</string>
+    <string name="launch">הפעל</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">נכשל בכתיבת קובץ התצורה</string>
+    <string name="config_apply_failed">נכשל בהחלת התצורה</string>
+    <string name="config_already_exists_title">תצורה כבר קיימת</string>
+    <string name="config_already_exists_message">הגדרות מותאמות אישית כבר קיימות עבור %1$s.\n\nהאם ברצונך לדרוס את התצורה הקיימת?\n\nפעולה זו לא ניתנת לביטול.</string>
+    <string name="config_exists_prompt">בודק אם קיימת תצורה...</string>
+    <string name="overwrite_cancelled">דריסה בוטלה</string>
+    <string name="checking_driver">בודק מנהל התקן מותאם אישית: %1$s</string>
+    <string name="driver_unavailable">מנהל התקן מותאם אישית לא זמין למכשיר זה</string>
+    <string name="overwrite">דרוס</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">מנהל התקן GPU חסר</string>
+    <string name="missing_gpu_driver_message">מנהל ההתקן המותאם אישית הנבחר \"%s\" אינו מותקן. האם ברצונך להוריד ולהתקין אותו כעת?</string>
+    <string name="downloading_driver">מוריד מנהל התקן...</string>
+    <string name="driver_installed">מנהל ההתקן הותקן בהצלחה</string>
+    <string name="driver_installation_failed_title">התקנת מנהל ההתקן נכשלה</string>
+    <string name="driver_installation_failed_message">נכשלה התקנת מנהל ההתקן של GPU: %s</string>
+    <string name="driver_not_available_title">מנהל התקן לא זמין</string>
+    <string name="driver_not_available_message">מנהל ההתקן הנבחר אינו זמין להורדה.</string>
+    <string name="driver_not_found">מנהל התקן נדרש לא מותקן: %s</string>
+    <string name="invalid_driver_file">קובץ מנהל התקן לא חוקי: %s</string>
+    <string name="network_unavailable">אין חיבור אינטרנט זמין. אנא בדוק את חיבור האינטרנט שלך ונסה שוב.</string>
+    <string name="driver_missing_title">נדרש מנהל התקן GPU</string>
+    <string name="driver_missing_message">תצורת המשחק דורשת מנהל התקן GPU \"%s\" אשר אינו מותקן במכשירך.\n\nהאם ברצונך להוריד ולהתקין אותו כעת?</string>
+    <string name="driver_download_cancelled">הורדת מנהל ההתקן בוטלה. לא ניתן להפעיל את המשחק ללא מנהל ההתקן הנדרש.</string>
+    <string name="download">הורד</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">צא מהאמולציה</string>
     <string name="emulation_done">סיום</string>
@@ -691,7 +741,8 @@
     <string name="emulation_rel_stick_center">מרכז ג׳ויסטיק יחסי</string>
     <string name="emulation_dpad_slide">החלקת D-pad</string>
     <string name="emulation_haptics">רטט מגע</string>
-    <string name="emulation_show_overlay">הצג את שכבת-העל</string>
+    <string name="emulation_show_overlay">הצג בקר</string>
+    <string name="emulation_hide_overlay">הסתר בקר</string>
     <string name="emulation_toggle_all">החלף הכל</string>
     <string name="emulation_control_adjust">התאם את שכבת-העל</string>
     <string name="emulation_control_scale">קנה מידה</string>
@@ -749,6 +800,12 @@
     <string name="renderer_accuracy_high">גבוה</string>
     <string name="renderer_accuracy_extreme">אקסטרים (איטי)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">ברירת מחדל</string>
+    <string name="dma_accuracy_normal">רגיל</string>
+    <string name="dma_accuracy_high">גבוה</string>
+    <string name="dma_accuracy_extreme">קיצוני</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">LRU gyorsítótár engedélyezése</string>
     <string name="use_lru_cache_description">Engedélyezi vagy letiltja az LRU gyorsítótárat, növelve a teljesítményt a CPU használat csökkentésével. Néhány játéknak (különösen a TotK 1.2.1-nek) problémája lehet vele - tiltsa le, ha a játék nem indul el vagy véletlenszerűen összeomlik.</string>
     <string name="dyna_state">Kiterjesztett Dinamikus Állapot</string>
-    <string name="dyna_state_description">Engedélyezi a Vulkan funkciókat a teljesítmény, renderelés javítására és erőforrások spórolására a pipeline létrehozásánál, miközben alacsony CPU/GPU használatot tart fenn. Ezek a kiterjesztések növelhetik az eszköz hőmérsékletét, és a régebbi A6XX sorozatú GPU-k nem feltétlenül működnek megfelelően. Tiltsa le a skálázott formátumok emulálásához.</string>
+    <string name="dyna_state_description">Szabályozza a Kiterjesztett Dynamikus Állapotban használható funkciók számát. A magasabb értékek több funkciót tesznek lehetővé és növelhetik a teljesítményt, de problémákat okozhatnak egyes meghajtókkal és gyártókkal. Az alapértelmezett érték eltérő lehet a rendszertől és a hardverképességektől függően. Ez az érték módosítható, amíg el nem éri a stabilitást és a jobb vizuális minőséget.</string>
     <string name="disabled">Letiltva</string>
     <string name="use_sync_core">Magsebesség szinkronizálása</string>
     <string name="use_sync_core_description">A mag sebességének szinkronizálása a maximális sebesség százalékával a teljesítmény javítása érdekében a játék tényleges sebességének megváltoztatása nélkül.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Tick-ek</string>
     <string name="skip_cpu_inner_invalidation">CPU belső érvénytelenítés kihagyása</string>
     <string name="skip_cpu_inner_invalidation_description">Kihagy néhány CPU-oldali gyorsítótár-érvénytelenítést memóriafrissítések közben, csökkentve a CPU használatát és javítva a teljesítményt. Néhány játékban hibákat vagy összeomlást okozhat.</string>
+    <string name="cpuopt_unsafe_host_mmu">Gazda MMU emuláció engedélyezése</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Ez az optimalizáció gyorsítja a vendégprogram memória-hozzáférését. Engedélyezése esetén a vendég memóriaolvasási/írási műveletei közvetlenül a memóriában történnek, és kihasználják a gazda MMU-ját. Letiltás esetén minden memória-hozzáférés a szoftveres MMU emulációt használja.</string>
+    <string name="dma_accuracy">DMA szint</string>
+    <string name="dma_accuracy_description">Szabályozza a DMA pontosságát. A magasabb pontosság megoldhat néhány játék problémáit, de bizonyos esetekben befolyásolhatja a teljesítményt. Ha bizonytalan, hagyja Alapértelmezett beállításnál.</string>
 
     <string name="memory_4gb">4GB (Ajánlott)</string>
     <string name="memory_6gb">6GB (Nem biztonságos)</string>
@@ -497,6 +501,8 @@
     <string name="use_custom_rtc">Egyéni RTC</string>
     <string name="use_custom_rtc_description">Megadhatsz egy valós idejű órát, amely eltér a rendszer által használt órától.</string>
     <string name="set_custom_rtc">Egyéni RTC beállítása</string>
+    <string name="disable_nca_verification">NCA ellenőrzés letiltása</string>
+    <string name="disable_nca_verification_description">Letiltja az NCA tartalomarchívumok integritás-ellenőrzését. Ez javíthatja a betöltési sebességet, de az adatsérülés vagy az érvénytelen fájlok észrevétlen maradásának kockázatával jár. Elengedhetetlen a 20+ firmware-et igénylő játékok és frissítések működtetéséhez.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Generálás</string>
@@ -787,6 +793,50 @@
     <string name="loader_requires_firmware">A játék firmware-t igényel</string>
     <string name="loader_requires_firmware_description"><![CDATA[A játék, amelyet el szeretne indítani, firmware-t igényel a bootoláshoz vagy a kezdőmenü átlépéséhez. Kérjük, <a href="https://yuzu-mirror.github.io/help/quickstart"> dumpolja és telepítse a firmware-t</a>, vagy nyomja meg az "OK" gombot a folytatáshoz.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Játék keresése...</string>
+    <string name="game_not_found_for_title_id">A játék nem található a következő címazonosítóhoz: %1$s</string>
+    <string name="custom_settings_failed_title">Egyéni beállítások sikertelenek</string>
+    <string name="custom_settings_failed_message">Nem sikerült alkalmazni az egyéni beállításokat ehhez: %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Indítás alapértelmezett beállításokkal</string>
+    <string name="launch_cancelled">Indítás megszakítva</string>
+    <string name="custom_settings_failure_reasons">Nem sikerült alkalmazni a kért beállításokat. Ennek oka hiányzó GPU illesztőprogramok vagy konfigurációs problémák lehetnek.</string>
+    <string name="custom_settings_applied">Egyéni beállítások alkalmazva</string>
+    <string name="launching_game">%1$s indítása...</string>
+    <string name="failed_to_initialize_game">A játék inicializálása sikertelen</string>
+    <string name="custom_intent_launch_message_with_settings">Szeretné elindítani a(z) %1$s-t egyéni beállításokkal?</string>
+    <string name="custom_intent_launch_message">Szeretné elindítani a(z) %1$s-t?</string>
+    <string name="custom_intent_launch_title">Játék indítása</string>
+    <string name="launch">Indítás</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">A konfigurációs fájl írása sikertelen</string>
+    <string name="config_apply_failed">A konfiguráció alkalmazása sikertelen</string>
+    <string name="config_already_exists_title">A konfiguráció már létezik</string>
+    <string name="config_already_exists_message">Már léteznek egyéni beállítások a(z) %1$s számára.\n\nSzeretné felülírni a meglévő konfigurációt?\n\nEzt a műveletet nem lehet visszavonni.</string>
+    <string name="config_exists_prompt">Létező konfiguráció keresése...</string>
+    <string name="overwrite_cancelled">A felülírás megszakítva</string>
+    <string name="checking_driver">Egyéni illesztőprogram ellenőrzése: %1$s</string>
+    <string name="driver_unavailable">Egyéni illesztőprogram nem elérhető ehhez az eszközhöz</string>
+    <string name="overwrite">Felülírás</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">GPU illesztőprogram hiányzik</string>
+    <string name="missing_gpu_driver_message">A kiválasztott egyéni illesztőprogram \"%s\" nincs telepítve. Szeretné most letölteni és telepíteni?</string>
+    <string name="downloading_driver">Illesztőprogram letöltése...</string>
+    <string name="driver_installed">Az illesztőprogram sikeresen telepítve</string>
+    <string name="driver_installation_failed_title">Az illesztőprogram telepítése sikertelen</string>
+    <string name="driver_installation_failed_message">Nem sikerült telepíteni a GPU illesztőprogramot: %s</string>
+    <string name="driver_not_available_title">Az illesztőprogram nem elérhető</string>
+    <string name="driver_not_available_message">A kiválasztott illesztőprogram nem érhető el letöltésre.</string>
+    <string name="driver_not_found">A szükséges illesztőprogram nincs telepítve: %s</string>
+    <string name="invalid_driver_file">Érvénytelen illesztőprogramfájl: %s</string>
+    <string name="network_unavailable">Nincs hálózati kapcsolat. Kérjük, ellenőrizze az internetkapcsolatát, és próbálja újra.</string>
+    <string name="driver_missing_title">GPU illesztőprogram szükséges</string>
+    <string name="driver_missing_message">A játék konfigurációja \"%s\" GPU illesztőprogramot igényel, amely nincs telepítve az eszközén.\n\nSzeretné most letölteni és telepíteni?</string>
+    <string name="driver_download_cancelled">Az illesztőprogram letöltése megszakítva. A játék nem indítható el a szükséges illesztőprogram nélkül.</string>
+    <string name="download">Letöltés</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Emuláció bezárása</string>
     <string name="emulation_done">Kész</string>
@@ -795,7 +845,8 @@
     <string name="emulation_toggle_controls">Irányítás átkapcsolása</string>
     <string name="emulation_dpad_slide">D-pad csúsztatása</string>
     <string name="emulation_haptics">Érintés haptikája</string>
-    <string name="emulation_show_overlay">Átfedés mutatása</string>
+    <string name="emulation_show_overlay">Vezérlő megjelenítése</string>
+    <string name="emulation_hide_overlay">Vezérlő elrejtése</string>
     <string name="emulation_toggle_all">Összes átkapcsolása</string>
     <string name="emulation_control_adjust">Átfedés testreszabása</string>
     <string name="emulation_control_scale">Skálázás</string>
@@ -856,6 +907,12 @@
     <string name="renderer_accuracy_high">Magas</string>
     <string name="renderer_accuracy_extreme">Extrém (Lassú)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Alapértelmezett</string>
+    <string name="dma_accuracy_normal">Normál</string>
+    <string name="dma_accuracy_high">Magas</string>
+    <string name="dma_accuracy_extreme">Extrém</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Aktifkan LRU Cache</string>
     <string name="use_lru_cache_description">Aktifkan atau nonaktifkan cache LRU untuk meningkatkan performa dengan mengurangi penggunaan proses CPU. Beberapa game seperti TotK 1.2.1 memiliki masalah - nonaktifkan jika game tidak mau berjalan atau crash acak.</string>
     <string name="dyna_state">Status Dinamis Ekstensi</string>
-    <string name="dyna_state_description">Aktifkan fitur Vulkan untuk meningkatkan performa, rendering dan menghemat sumber daya saat pembuatan pipeline sambil mempertahankan penggunaan CPU/GPU yang rendah. Ekstensi ini dapat meningkatkan suhu perangkat, dan GPU seri A6XX lama mungkin tidak merespons dengan benar. Nonaktifkan untuk emulasi format skala.</string>
+    <string name="dyna_state_description">Mengontrol jumlah fitur yang dapat digunakan dalam Extended Dynamic State. Angka yang lebih tinggi memungkinkan lebih banyak fitur dan dapat meningkatkan performa, tetapi dapat menyebabkan masalah dengan beberapa driver dan vendor. Nilai default dapat bervariasi tergantung pada sistem dan kemampuan hardware Anda. Nilai ini dapat diubah hingga stabilitas dan kualitas visual yang lebih baik tercapai.</string>
     <string name="disabled">Dinonaktifkan</string>
     <string name="use_sync_core">Sinkronisasi Kecepatan Inti</string>
     <string name="use_sync_core_description">Sinkronkan kecepatan inti dengan persentase kecepatan maksimum untuk meningkatkan performa tanpa mengubah kecepatan sebenarnya dari permainan.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">Lewati Pembatalan Internal CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Melewati beberapa pembatalan cache sisi CPU selama pembaruan memori, mengurangi penggunaan CPU dan meningkatkan kinerjanya. Mungkin menyebabkan gangguan atau crash pada beberapa game.</string>
+    <string name="cpuopt_unsafe_host_mmu">Aktifkan Emulasi MMU Host</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Optimasi ini mempercepat akses memori oleh program tamu. Mengaktifkannya menyebabkan pembacaan/penulisan memori tamu dilakukan langsung ke memori dan memanfaatkan MMU Host. Menonaktifkan ini memaksa semua akses memori menggunakan Emulasi MMU Perangkat Lunak.</string>
+    <string name="dma_accuracy">Level DMA</string>
+    <string name="dma_accuracy_description">Mengontrol akurasi presisi DMA. Presisi yang lebih tinggi dapat memperbaiki masalah di beberapa game, tetapi juga dapat memengaruhi performa dalam beberapa kasus. Jika tidak yakin, biarkan di Bawaan.</string>
 
     <string name="memory_4gb">4GB (Direkomendasikan)</string>
     <string name="memory_6gb">6GB (Tidak Aman)</string>
@@ -498,6 +502,8 @@
     <string name="use_custom_rtc">RTC Kustom</string>
     <string name="use_custom_rtc_description">Memungkinkan Anda untuk mengatur jam waktu nyata kustom yang terpisah dari waktu sistem saat ini Anda.</string>
     <string name="set_custom_rtc">Setel RTC Kustom</string>
+    <string name="disable_nca_verification">Nonaktifkan Verifikasi NCA</string>
+    <string name="disable_nca_verification_description">Menonaktifkan verifikasi integritas arsip konten NCA. Ini dapat meningkatkan kecepatan pemuatan tetapi berisiko kerusakan data atau file yang tidak valid tidak terdeteksi. Diperlukan untuk membuat game dan pembaruan yang membutuhkan firmware 20+ bekerja.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Hasilkan</string>
@@ -741,6 +747,50 @@
     <string name="loader_requires_firmware">Game memerlukan firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Game yang ingin Anda jalankan memerlukan firmware untuk boot atau melewati menu pembuka. Silakan <a href="https://yuzu-mirror.github.io/help/quickstart"> dump dan instal firmware</a>, atau tekan "OK" untuk melanjutkan.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Mencari game...</string>
+    <string name="game_not_found_for_title_id">Game tidak ditemukan untuk ID Judul: %1$s</string>
+    <string name="custom_settings_failed_title">Pengaturan Kustom Gagal</string>
+    <string name="custom_settings_failed_message">Gagal menerapkan pengaturan kustom untuk %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Luncurkan dengan Pengaturan Default</string>
+    <string name="launch_cancelled">Peluncuran dibatalkan</string>
+    <string name="custom_settings_failure_reasons">Tidak dapat menerapkan pengaturan yang diminta. Ini mungkin karena driver GPU yang hilang atau masalah konfigurasi.</string>
+    <string name="custom_settings_applied">Pengaturan kustom diterapkan</string>
+    <string name="launching_game">Meluncurkan %1$s...</string>
+    <string name="failed_to_initialize_game">Gagal menginisialisasi game</string>
+    <string name="custom_intent_launch_message_with_settings">Apakah Anda ingin meluncurkan %1$s dengan pengaturan kustom?</string>
+    <string name="custom_intent_launch_message">Apakah Anda ingin meluncurkan %1$s?</string>
+    <string name="custom_intent_launch_title">Luncurkan Game</string>
+    <string name="launch">Luncurkan</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Gagal menulis file konfigurasi</string>
+    <string name="config_apply_failed">Gagal menerapkan konfigurasi</string>
+    <string name="config_already_exists_title">Konfigurasi Sudah Ada</string>
+    <string name="config_already_exists_message">Pengaturan kustom sudah ada untuk %1$s.\n\nApakah Anda ingin menimpa konfigurasi yang ada?\n\nTindakan ini tidak dapat dibatalkan.</string>
+    <string name="config_exists_prompt">Memeriksa konfigurasi yang ada...</string>
+    <string name="overwrite_cancelled">Penimpaan dibatalkan</string>
+    <string name="checking_driver">Memeriksa driver kustom: %1$s</string>
+    <string name="driver_unavailable">Driver kustom tidak tersedia untuk perangkat ini</string>
+    <string name="overwrite">Timpa</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Driver GPU Hilang</string>
+    <string name="missing_gpu_driver_message">Driver kustom yang dipilih \"%s\" tidak terinstal. Apakah Anda ingin mengunduh dan menginstalnya sekarang?</string>
+    <string name="downloading_driver">Mengunduh driver...</string>
+    <string name="driver_installed">Driver berhasil diinstal</string>
+    <string name="driver_installation_failed_title">Instalasi Driver Gagal</string>
+    <string name="driver_installation_failed_message">Gagal menginstal driver GPU: %s</string>
+    <string name="driver_not_available_title">Driver Tidak Tersedia</string>
+    <string name="driver_not_available_message">Driver yang dipilih tidak tersedia untuk diunduh.</string>
+    <string name="driver_not_found">Driver yang diperlukan tidak terinstal: %s</string>
+    <string name="invalid_driver_file">File driver tidak valid: %s</string>
+    <string name="network_unavailable">Tidak ada koneksi jaringan yang tersedia. Silakan periksa koneksi internet Anda dan coba lagi.</string>
+    <string name="driver_missing_title">Driver GPU Diperlukan</string>
+    <string name="driver_missing_message">Konfigurasi game memerlukan driver GPU \"%s\" yang tidak terinstal di perangkat Anda.\n\nApakah Anda ingin mengunduh dan menginstalnya sekarang?</string>
+    <string name="driver_download_cancelled">Pengunduhan driver dibatalkan. Game tidak dapat diluncurkan tanpa driver yang diperlukan.</string>
+    <string name="download">Unduh</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Keluar</string>
     <string name="emulation_done">Selesai</string>
@@ -750,7 +800,8 @@
     <string name="emulation_rel_stick_center">Pusat stick relatif</string>
     <string name="emulation_dpad_slide">Geser Dpad</string>
     <string name="emulation_haptics">Haptik</string>
-    <string name="emulation_show_overlay">Tampilkan Hamparan</string>
+    <string name="emulation_show_overlay">Tampilkan Kontroler</string>
+    <string name="emulation_hide_overlay">Sembunyikan Kontroler</string>
     <string name="emulation_toggle_all">Alihkan Semua</string>
     <string name="emulation_control_adjust">Menyesuaikan</string>
     <string name="emulation_control_scale">Skala</string>
@@ -811,6 +862,12 @@
     <string name="renderer_accuracy_high">Tinggi</string>
     <string name="renderer_accuracy_extreme">Ekstrim (Lambat)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Bawaan</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Tinggi</string>
+    <string name="dma_accuracy_extreme">Ekstrem</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Abilita cache LRU</string>
     <string name="use_lru_cache_description">Abilita o disabilita la cache LRU per migliorare le prestazioni riducendo l\'uso della CPU. Alcuni giochi come TotK 1.2.1 hanno problemi - disabilitalo se il gioco non si avvia o crasha casualmente.</string>
     <string name="dyna_state">Stato dinamico esteso</string>
-    <string name="dyna_state_description">Abilita le funzionalità Vulkan per migliorare prestazioni, rendering e risparmiare risorse durante la creazione della pipeline mantenendo un basso utilizzo di CPU/GPU. Queste estensioni possono aumentare la temperatura del dispositivo e le GPU della vecchia serie A6XX potrebbero non rispondere correttamente. Disabilita per emulare formati scalati.</string>
+    <string name="dyna_state_description">Controlla il numero di funzioni utilizzabili nello Stato Dinamico Esteso. Valori più alti consentono più funzioni e possono aumentare le prestazioni, ma potrebbero causare problemi con alcuni driver e vendor. Il valore predefinito può variare in base al sistema e alle capacità hardware. Questo valore può essere modificato finché non si raggiunge la stabilità e una migliore qualità visiva.</string>
     <string name="disabled">Disabilitato</string>
     <string name="use_sync_core">Sincronizza velocità core</string>
     <string name="use_sync_core_description">Sincronizza la velocità del core con la percentuale massima di velocità per migliorare le prestazioni senza alterare la velocità effettiva del gioco.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Tick</string>
     <string name="skip_cpu_inner_invalidation">Salta invalidamento interno CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Salta alcuni invalidamenti della cache lato CPU durante gli aggiornamenti di memoria, riducendo l\'uso della CPU e migliorandone le prestazioni. Potrebbe causare glitch o crash in alcuni giochi.</string>
+    <string name="cpuopt_unsafe_host_mmu">Abilita emulazione MMU host</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Questa ottimizzazione accelera gli accessi alla memoria da parte del programma guest. Abilitandola, le letture/scritture della memoria guest vengono eseguite direttamente in memoria e sfruttano la MMU host. Disabilitandola, tutti gli accessi alla memoria sono costretti a utilizzare l\'emulazione software della MMU.</string>
+    <string name="dma_accuracy">Livello DMA</string>
+    <string name="dma_accuracy_description">Controlla la precisione del DMA. Una precisione più alta può risolvere problemi in alcuni giochi, ma in alcuni casi può influire sulle prestazioni. Se non sei sicuro, lascia su Predefinito.</string>
 
     <string name="memory_4gb">4GB (Consigliato)</string>
     <string name="memory_6gb">6GB (Non sicuro)</string>
@@ -501,6 +505,8 @@
     <string name="use_custom_rtc">RTC Personalizzato</string>
     <string name="use_custom_rtc_description">Ti permette di impostare un orologio in tempo reale personalizzato, completamente separato da quello di sistema.</string>
     <string name="set_custom_rtc">Imposta un orologio in tempo reale personalizzato</string>
+    <string name="disable_nca_verification">Disabilita verifica NCA</string>
+    <string name="disable_nca_verification_description">Disabilita la verifica dell\'integrità degli archivi di contenuto NCA. Può migliorare la velocità di caricamento ma rischia il danneggiamento dei dati o che file non validi passino inosservati. Necessario per far funzionare giochi e aggiornamenti che richiedono il firmware 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Genera</string>
@@ -714,6 +720,50 @@
     <string name="loader_requires_firmware">Il gioco richiede firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Il gioco che stai cercando di avviare richiede firmware per l\'avvio o per superare il menu iniziale. Per favore <a href="https://yuzu-mirror.github.io/help/quickstart"> dumpa e installa il firmware</a>, o premi "OK" per continuare comunque.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Ricerca del gioco in corso...</string>
+    <string name="game_not_found_for_title_id">Gioco non trovato per l\'ID titolo: %1$s</string>
+    <string name="custom_settings_failed_title">Impostazioni personalizzate non riuscite</string>
+    <string name="custom_settings_failed_message">Impossibile applicare le impostazioni personalizzate per %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Avvia con impostazioni predefinite</string>
+    <string name="launch_cancelled">Avvio annullato</string>
+    <string name="custom_settings_failure_reasons">Impossibile applicare le impostazioni richieste. Ciò potrebbe essere dovuto a driver GPU mancanti o problemi di configurazione.</string>
+    <string name="custom_settings_applied">Impostazioni personalizzate applicate</string>
+    <string name="launching_game">Avvio di %1$s...</string>
+    <string name="failed_to_initialize_game">Impossibile inizializzare il gioco</string>
+    <string name="custom_intent_launch_message_with_settings">Vuoi avviare %1$s con impostazioni personalizzate?</string>
+    <string name="custom_intent_launch_message">Vuoi avviare %1$s?</string>
+    <string name="custom_intent_launch_title">Avvia gioco</string>
+    <string name="launch">Avvia</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Impossibile scrivere il file di configurazione</string>
+    <string name="config_apply_failed">Impossibile applicare la configurazione</string>
+    <string name="config_already_exists_title">Configurazione già esistente</string>
+    <string name="config_already_exists_message">Impostazioni personalizzate già esistenti per %1$s.\n\nVuoi sovrascrivere la configurazione esistente?\n\nQuesta azione non può essere annullata.</string>
+    <string name="config_exists_prompt">Verifica della configurazione esistente...</string>
+    <string name="overwrite_cancelled">Sovrascrittura annullata</string>
+    <string name="checking_driver">Verifica del driver personalizzato: %1$s</string>
+    <string name="driver_unavailable">Driver personalizzato non disponibile per questo dispositivo</string>
+    <string name="overwrite">Sovrascrivi</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Driver GPU mancante</string>
+    <string name="missing_gpu_driver_message">Il driver personalizzato selezionato \"%s\" non è installato. Vuoi scaricarlo e installarlo ora?</string>
+    <string name="downloading_driver">Download del driver in corso...</string>
+    <string name="driver_installed">Driver installato correttamente</string>
+    <string name="driver_installation_failed_title">Installazione del driver non riuscita</string>
+    <string name="driver_installation_failed_message">Impossibile installare il driver GPU: %s</string>
+    <string name="driver_not_available_title">Driver non disponibile</string>
+    <string name="driver_not_available_message">Il driver selezionato non è disponibile per il download.</string>
+    <string name="driver_not_found">Driver richiesto non installato: %s</string>
+    <string name="invalid_driver_file">File driver non valido: %s</string>
+    <string name="network_unavailable">Nessuna connessione di rete disponibile. Controlla la connessione Internet e riprova.</string>
+    <string name="driver_missing_title">Driver GPU richiesto</string>
+    <string name="driver_missing_message">La configurazione del gioco richiede il driver GPU \"%s\" che non è installato sul tuo dispositivo.\n\nVuoi scaricarlo e installarlo ora?</string>
+    <string name="driver_download_cancelled">Download del driver annullato. Il gioco non può essere avviato senza il driver richiesto.</string>
+    <string name="download">Scarica</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Arresta emulazione</string>
     <string name="emulation_done">Fatto</string>
@@ -722,7 +772,8 @@
     <string name="emulation_rel_stick_center">Centro relativo degli Stick</string>
     <string name="emulation_dpad_slide">DPad A Scorrimento</string>
     <string name="emulation_haptics">Feedback Aptico</string>
-    <string name="emulation_show_overlay">Mostra l\'overlay</string>
+    <string name="emulation_show_overlay">Mostra l\'controller</string>
+    <string name="emulation_hide_overlay">Nascondi l\'controller</string>
     <string name="emulation_toggle_all">Attiva/Disattiva tutto</string>
     <string name="emulation_control_adjust">Regola l\'overlay</string>
     <string name="emulation_control_scale">Scala</string>
@@ -780,6 +831,12 @@
     <string name="renderer_accuracy_high">Alta</string>
     <string name="renderer_accuracy_extreme">Estrema (Lenta)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Predefinito</string>
+    <string name="dma_accuracy_normal">Normale</string>
+    <string name="dma_accuracy_high">Alto</string>
+    <string name="dma_accuracy_extreme">Estremo</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">LRUキャッシュを有効化</string>
     <string name="use_lru_cache_description">LRUキャッシュを有効/無効にし、CPUプロセスの使用を節約してパフォーマンスを向上させます。TotK 1.2.1など一部のゲームで問題が発生する可能性があるため、ゲームが起動しない場合やランダムにクラッシュする場合は無効にしてください。</string>
     <string name="dyna_state">拡張ダイナミックステート</string>
-    <string name="dyna_state_description">Vulkan機能を有効にし、パイプライン作成時のCPU/GPU使用率を低く保ちながら、パフォーマンス、レンダリング、リソース節約を改善します。これらの拡張機能はデバイスの温度を上昇させる可能性があり、旧A6XXシリーズのGPUは正しく反応しない場合があります。スケールフォーマットをエミュレートするには無効にしてください。</string>
+    <string name="dyna_state_description">拡張ダイナミックステートで使用できる機能の数を制御します。数値が高いほどより多くの機能が使用可能になり、パフォーマンスが向上する可能性がありますが、一部のドライバーやベンダーで問題が発生する可能性があります。デフォルト値は、お使いのシステムとハードウェアの機能によって異なります。安定性とより良い画質が得られるまでこの値を変更できます。</string>
     <string name="disabled">無効</string>
     <string name="use_sync_core">コア速度の同期</string>
     <string name="use_sync_core_description">コアの速度を最大速度パーセンテージに同期させ、ゲームの実際の速度を変えずにパフォーマンスを向上させます。</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">ティック</string>
     <string name="skip_cpu_inner_invalidation">CPU内部無効化をスキップ</string>
     <string name="skip_cpu_inner_invalidation_description">メモリ更新時のCPU側キャッシュ無効化をスキップし、CPU使用率を減らして性能を向上させます。一部のゲームで不具合やクラッシュが発生する可能性があります。</string>
+    <string name="cpuopt_unsafe_host_mmu">ホストMMUエミュレーションを有効化</string>
+    <string name="cpuopt_unsafe_host_mmu_description">この最適化により、ゲストプログラムによるメモリアクセスが高速化されます。有効にすると、ゲストのメモリ読み書きが直接メモリ内で実行され、ホストのMMUを利用します。無効にすると、すべてのメモリアクセスでソフトウェアMMUエミュレーションが使用されます。</string>
+    <string name="dma_accuracy">DMAレベル</string>
+    <string name="dma_accuracy_description">DMAの精度を制御します。精度を高くすると一部のゲームの問題が修正される場合がありますが、場合によってはパフォーマンスに影響を与える可能性もあります。不明な場合は、デフォルトのままにしてください。</string>
 
     <string name="memory_4gb">4GB (推奨)</string>
     <string name="memory_6gb">6GB (安全でない)</string>
@@ -487,6 +491,8 @@
     <string name="use_custom_rtc">カスタム RTC</string>
     <string name="use_custom_rtc_description">現在のシステム時間とは別に、任意のリアルタイムクロックを設定できます。</string>
     <string name="set_custom_rtc">カスタムRTCを設定</string>
+    <string name="disable_nca_verification">NCA検証を無効化</string>
+    <string name="disable_nca_verification_description">NCAコンテンツアーカイブの整合性検証を無効にします。読み込み速度が向上する可能性がありますが、データ破損や不正なファイルが検出されないリスクがあります。ファームウェア20以上が必要なゲームや更新を動作させるために必要です。</string>
 
     <!-- Network settings strings -->
     <string name="generate">生成</string>
@@ -673,6 +679,50 @@
     <string name="loader_requires_firmware">ゲームにはファームウェアが必要です</string>
     <string name="loader_requires_firmware_description"><![CDATA[起動しようとしているゲームは、起動または開始メニューを通過するためにファームウェアが必要です。<a href="https://yuzu-mirror.github.io/help/quickstart"> ファームウェアをダンプしてインストール</a>するか、"OK"を押して続行してください。]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">ゲームを検索中...</string>
+    <string name="game_not_found_for_title_id">タイトルID: %1$s のゲームが見つかりません</string>
+    <string name="custom_settings_failed_title">カスタム設定の失敗</string>
+    <string name="custom_settings_failed_message">%1$s のカスタム設定の適用に失敗しました: %2$s</string>
+    <string name="launch_with_default_settings">デフォルト設定で起動</string>
+    <string name="launch_cancelled">起動がキャンセルされました</string>
+    <string name="custom_settings_failure_reasons">要求された設定を適用できません。GPUドライバーの不足または設定の問題が原因である可能性があります。</string>
+    <string name="custom_settings_applied">カスタム設定が適用されました</string>
+    <string name="launching_game">%1$s を起動中...</string>
+    <string name="failed_to_initialize_game">ゲームの初期化に失敗しました</string>
+    <string name="custom_intent_launch_message_with_settings">%1$s をカスタム設定で起動しますか？</string>
+    <string name="custom_intent_launch_message">%1$s を起動しますか？</string>
+    <string name="custom_intent_launch_title">ゲームを起動</string>
+    <string name="launch">起動</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">設定ファイルの書き込みに失敗しました</string>
+    <string name="config_apply_failed">設定の適用に失敗しました</string>
+    <string name="config_already_exists_title">設定が既に存在します</string>
+    <string name="config_already_exists_message">%1$s のカスタム設定は既に存在します。\n\n既存の設定を上書きしますか？\n\nこの操作は元に戻せません。</string>
+    <string name="config_exists_prompt">既存の設定を確認中...</string>
+    <string name="overwrite_cancelled">上書きがキャンセルされました</string>
+    <string name="checking_driver">カスタムドライバーを確認中: %1$s</string>
+    <string name="driver_unavailable">このデバイスではカスタムドライバーは利用できません</string>
+    <string name="overwrite">上書き</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">GPUドライバーが見つかりません</string>
+    <string name="missing_gpu_driver_message">選択したカスタムドライバー \"%s\" がインストールされていません。今すぐダウンロードしてインストールしますか？</string>
+    <string name="downloading_driver">ドライバーをダウンロード中...</string>
+    <string name="driver_installed">ドライバーが正常にインストールされました</string>
+    <string name="driver_installation_failed_title">ドライバーのインストールに失敗しました</string>
+    <string name="driver_installation_failed_message">GPUドライバーのインストールに失敗しました: %s</string>
+    <string name="driver_not_available_title">ドライバーが利用できません</string>
+    <string name="driver_not_available_message">選択したドライバーはダウンロードできません。</string>
+    <string name="driver_not_found">必要なドライバーがインストールされていません: %s</string>
+    <string name="invalid_driver_file">無効なドライバーファイル: %s</string>
+    <string name="network_unavailable">ネットワーク接続が利用できません。インターネット接続を確認してからもう一度お試しください。</string>
+    <string name="driver_missing_title">GPUドライバーが必要です</string>
+    <string name="driver_missing_message">ゲーム設定にはGPUドライバー \"%s\" が必要ですが、お使いのデバイスにインストールされていません。\n\n今すぐダウンロードしてインストールしますか？</string>
+    <string name="driver_download_cancelled">ドライバーのダウンロードがキャンセルされました。必要なドライバーがないとゲームを起動できません。</string>
+    <string name="download">ダウンロード</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">終了</string>
     <string name="emulation_done">完了</string>
@@ -681,7 +731,8 @@
     <string name="emulation_rel_stick_center">スティックを固定しない</string>
     <string name="emulation_dpad_slide">十字キーをスライド操作</string>
     <string name="emulation_haptics">タッチ振動</string>
-    <string name="emulation_show_overlay">ボタンを表示</string>
+    <string name="emulation_show_overlay">コントローラーを表示</string>
+    <string name="emulation_hide_overlay">コントローラーを非表示</string>
     <string name="emulation_toggle_all">すべて切替</string>
     <string name="emulation_control_adjust">見た目を調整</string>
     <string name="emulation_control_scale">大きさ</string>
@@ -739,6 +790,12 @@
     <string name="renderer_accuracy_high">高</string>
     <string name="renderer_accuracy_extreme">最高 (低速)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">デフォルト</string>
+    <string name="dma_accuracy_normal">標準</string>
+    <string name="dma_accuracy_high">高</string>
+    <string name="dma_accuracy_extreme">最高</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">LRU 캐시 사용</string>
     <string name="use_lru_cache_description">LRU 캐시를 활성화 또는 비활성화하여 CPU 프로세스 사용을 절약하고 성능을 향상시킵니다. TotK 1.2.1을 포함한 일부 게임에서 문제가 발생할 수 있으므로 게임이 부팅되지 않거나 무작위로 충돌하는 경우 비활성화하세요.</string>
     <string name="dyna_state">확장 동적 상태</string>
-    <string name="dyna_state_description">파이프라인 생성 시 CPU/GPU 사용량을 낮게 유지하면서 성능, 렌더링 및 리소스 절약을 개선하기 위해 Vulkan 기능을 활성화합니다. 이 확장 기능은 장치 온도를 높일 수 있으며 이전 A6XX 라인에 속하는 GPU가 제대로 반응하지 않을 수 있습니다. 스케일된 형식을 에뮬레이트하려면 비활성화하세요.</string>
+    <string name="dyna_state_description">확장 동적 상태에서 사용할 수 있는 기능의 수를 제어합니다. 높은 값은 더 많은 기능을 허용하고 성능을 높일 수 있지만, 일부 드라이버 및 벤더에서 문제를 일으킬 수 있습니다. 기본값은 시스템 및 하드웨어 기능에 따라 다를 수 있습니다. 안정성과 더 나은 시각적 품질이 달성될 때까지 이 값을 변경할 수 있습니다.</string>
     <string name="disabled">비활성화됨</string>
     <string name="use_sync_core">코어 속도 동기화</string>
     <string name="use_sync_core_description">코어 틱 속도를 최대 속도 백분율과 동기화하여 게임의 실제 속도를 변경하지 않고 성능을 향상시킵니다.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">틱</string>
     <string name="skip_cpu_inner_invalidation">CPU 내부 무효화 건너뛰기</string>
     <string name="skip_cpu_inner_invalidation_description">메모리 업데이트 시 일부 CPU 측 캐시 무효화를 건너뛰어 CPU 사용량을 줄이고 성능을 향상시킵니다. 일부 게임에서 오류 또는 충돌을 일으킬 수 있습니다.</string>
+    <string name="cpuopt_unsafe_host_mmu">호스트 MMU 에뮬레이션 사용</string>
+    <string name="cpuopt_unsafe_host_mmu_description">이 최적화는 게스트 프로그램의 메모리 접근 속도를 높입니다. 활성화하면 게스트의 메모리 읽기/쓰기가 메모리에서 직접 수행되고 호스트의 MMU를 활용합니다. 비활성화하면 모든 메모리 접근에 소프트웨어 MMU 에뮬레이션을 사용하게 됩니다.</string>
+    <string name="dma_accuracy">DMA 수준</string>
+    <string name="dma_accuracy_description">DMA 정밀도를 제어합니다. 높은 정밀도는 일부 게임의 문제를 해결할 수 있지만 경우에 따라 성능에 영향을 미칠 수도 있습니다. 확실하지 않다면 기본값으로 두세요.</string>
 
     <string name="memory_4gb">4GB (권장)</string>
     <string name="memory_6gb">6GB (안전하지 않음)</string>
@@ -497,6 +501,8 @@
     <string name="use_custom_rtc">사용자 지정 RTC</string>
     <string name="use_custom_rtc_description">현재 시스템 시간과 별도로 사용자 지정 RTC를 설정할 수 있습니다.</string>
     <string name="set_custom_rtc">사용자 지정 RTC 설정</string>
+    <string name="disable_nca_verification">NCA 검증 비활성화</string>
+    <string name="disable_nca_verification_description">NCA 콘텐츠 아카이브의 무결성 검증을 비활성화합니다. 로딩 속도를 향상시킬 수 있지만 데이터 손상이나 유효하지 않은 파일이 미검증될 위험이 있습니다. 펌웨어 20+가 필요한 게임 및 업데이트를 실행하려면 필요합니다.</string>
 
     <!-- Network settings strings -->
     <string name="generate">생성</string>
@@ -741,6 +747,50 @@
     <string name="loader_requires_firmware">게임에 펌웨어가 필요합니다</string>
     <string name="loader_requires_firmware_description"><![CDATA[실행하려는 게임은 부팅하거나 시작 메뉴를 통과하기 위해 펌웨어가 필요합니다. <a href="https://yuzu-mirror.github.io/help/quickstart">펌웨어를 덤프하여 설치</a>하거나 "확인"을 눌러 계속 진행하세요.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">게임 검색 중...</string>
+    <string name="game_not_found_for_title_id">타이틀 ID에 대한 게임을 찾을 수 없음: %1$s</string>
+    <string name="custom_settings_failed_title">사용자 지정 설정 실패</string>
+    <string name="custom_settings_failed_message">%1$s에 대한 사용자 지정 설정 적용 실패: %2$s</string>
+    <string name="launch_with_default_settings">기본 설정으로 실행</string>
+    <string name="launch_cancelled">실행 취소됨</string>
+    <string name="custom_settings_failure_reasons">요청한 설정을 적용할 수 없습니다. GPU 드라이버 누락 또는 구성 문제 때문일 수 있습니다.</string>
+    <string name="custom_settings_applied">사용자 지정 설정이 적용됨</string>
+    <string name="launching_game">%1$s 실행 중...</string>
+    <string name="failed_to_initialize_game">게임 초기화 실패</string>
+    <string name="custom_intent_launch_message_with_settings">%1$s을(를) 사용자 지정 설정으로 실행하시겠습니까?</string>
+    <string name="custom_intent_launch_message">%1$s을(를) 실행하시겠습니까?</string>
+    <string name="custom_intent_launch_title">게임 실행</string>
+    <string name="launch">실행</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">구성 파일 작성 실패</string>
+    <string name="config_apply_failed">구성 적용 실패</string>
+    <string name="config_already_exists_title">구성이 이미 존재함</string>
+    <string name="config_already_exists_message">%1$s에 대한 사용자 지정 설정이 이미 존재합니다.\n\n기존 구성을 덮어쓰시겠습니까?\n\n이 작업은 취소할 수 없습니다.</string>
+    <string name="config_exists_prompt">기존 구성 확인 중...</string>
+    <string name="overwrite_cancelled">덮어쓰기 취소됨</string>
+    <string name="checking_driver">사용자 지정 드라이버 확인 중: %1$s</string>
+    <string name="driver_unavailable">이 기기에서는 사용자 지정 드라이버를 사용할 수 없음</string>
+    <string name="overwrite">덮어쓰기</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">GPU 드라이버 누락</string>
+    <string name="missing_gpu_driver_message">선택한 사용자 지정 드라이버 \"%s\"이(가) 설치되지 않았습니다. 지금 다운로드하여 설치하시겠습니까?</string>
+    <string name="downloading_driver">드라이버 다운로드 중...</string>
+    <string name="driver_installed">드라이버가 성공적으로 설치됨</string>
+    <string name="driver_installation_failed_title">드라이버 설치 실패</string>
+    <string name="driver_installation_failed_message">GPU 드라이버 설치 실패: %s</string>
+    <string name="driver_not_available_title">드라이버를 사용할 수 없음</string>
+    <string name="driver_not_available_message">선택한 드라이버를 다운로드할 수 없습니다.</string>
+    <string name="driver_not_found">필요한 드라이버가 설치되지 않았습니다: %s</string>
+    <string name="invalid_driver_file">잘못된 드라이버 파일: %s</string>
+    <string name="network_unavailable">사용 가능한 네트워크 연결이 없습니다. 인터넷 연결을 확인하고 다시 시도하십시오.</string>
+    <string name="driver_missing_title">GPU 드라이버 필요</string>
+    <string name="driver_missing_message">게임 구성에 GPU 드라이버 \"%s\"이(가) 필요하지만 기기에 설치되어 있지 않습니다.\n\n지금 다운로드하여 설치하시겠습니까?</string>
+    <string name="driver_download_cancelled">드라이버 다운로드가 취소되었습니다. 필요한 드라이버 없이는 게임을 실행할 수 없습니다.</string>
+    <string name="download">다운로드</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">에뮬레이션 종료</string>
     <string name="emulation_done">완료</string>
@@ -750,6 +800,7 @@
     <string name="emulation_dpad_slide">십자키 슬라이드</string>
     <string name="emulation_haptics">터치 햅틱</string>
     <string name="emulation_show_overlay">컨트롤러 표시</string>
+    <string name="emulation_hide_overlay">컨트롤러 숨기기</string>
     <string name="emulation_toggle_all">모두 선택</string>
     <string name="emulation_control_adjust">컨트롤러 조정</string>
     <string name="emulation_control_scale">크기</string>
@@ -810,6 +861,12 @@
     <string name="renderer_accuracy_high">높음</string>
     <string name="renderer_accuracy_extreme">극한 (느림)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">기본값</string>
+    <string name="dma_accuracy_normal">보통</string>
+    <string name="dma_accuracy_high">높음</string>
+    <string name="dma_accuracy_extreme">극단적</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Aktiver LRU-mellomlager</string>
     <string name="use_lru_cache_description">Aktiver eller deaktiver LRU-mellomlager for å forbedre ytelsen ved å spare CPU-prosessorbruk. Noen spill som TotK 1.2.1 har problemer med dette - deaktiver hvis spillet ikke starter eller krasjer tilfeldig.</string>
     <string name="dyna_state">Utvidet dynamisk tilstand</string>
-    <string name="dyna_state_description">Aktiverer Vulkan-funksjoner for å forbedre ytelse, rendering og spare ressurser ved oppretting av pipeline samtidig som CPU/GPU-bruken holdes lav. Disse utvidelsene kan øke enhetstemperaturen, og eldre GPU-er fra A6XX-serien reagerer kanskje ikke ordentlig. Deaktiver for å emulere skalerte formater.</string>
+    <string name="dyna_state_description">Kontrollerer antall funksjoner som kan brukes i Utvidet Dynamisk Tilstand. Høyere tall tillater flere funksjoner og kan øke ytelsen, men kan forårsake problemer med noen drivere og leverandører. Standardverdien kan variere avhengig av systemet og maskinvareevnene dine. Denne verdien kan endres til stabilitet og bedre visuell kvalitet er oppnådd.</string>
     <string name="disabled">Deaktivert</string>
     <string name="use_sync_core">Synkroniser kjernespeed</string>
     <string name="use_sync_core_description">Synkroniser kjernens hastighet med maksimal hastighetsprosent for å forbedre ytelsen uten å endre spillets faktiske hastighet.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Takter</string>
     <string name="skip_cpu_inner_invalidation">Hopp over CPU intern invalidering</string>
     <string name="skip_cpu_inner_invalidation_description">Hopper over enkelte CPU-side cache-invalideringer under minneoppdateringer, reduserer CPU-bruk og forbedrer ytelsen. Kan forårsake feil eller krasj i noen spill.</string>
+    <string name="cpuopt_unsafe_host_mmu">Aktiver verts-MMU-emulering</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Denne optimaliseringen fremskynder minnetilgang av gjesteprogrammet. Hvis aktivert, utføres gjestens minnelesing/skriving direkte i minnet og bruker vertens MMU. Deaktivering tvinger alle minnetilganger til å bruke programvarebasert MMU-emulering.</string>
+    <string name="dma_accuracy">DMA-nivå</string>
+    <string name="dma_accuracy_description">Styrer DMA-presisjonsnøyaktigheten. Høyere presisjon kan fikse problemer i noen spill, men kan også påvirke ytelsen i noen tilfeller. Hvis du er usikker, la den stå på Standard.</string>
 
     <string name="memory_4gb">4GB (Anbefalt)</string>
     <string name="memory_6gb">6GB (Usikkert)</string>
@@ -478,6 +482,8 @@
     <string name="use_custom_rtc">Tilpasset Sannhetstidsklokke</string>
     <string name="use_custom_rtc_description">Gjør det mulig å stille inn en egendefinert sanntidsklokke separat fra den gjeldende systemtiden.</string>
     <string name="set_custom_rtc">Angi tilpasset RTC</string>
+    <string name="disable_nca_verification">Deaktiver NCA-verifisering</string>
+    <string name="disable_nca_verification_description">Deaktiverer integritetsverifisering av NCA-innholdsarkiv. Dette kan forbedre lastehastigheten, men medfører risiko for datakorrupsjon eller at ugyldige filer ikke oppdages. Er nødvendig for å få spill og oppdateringer som trenger firmware 20+ til å fungere.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Generer</string>
@@ -664,6 +670,50 @@
     <string name="loader_requires_firmware">Spillet krever fastvare</string>
     <string name="loader_requires_firmware_description"><![CDATA[Spillet du prøver å starte krever fastvare for oppstart eller for å komme forbi startmenyen. Vennligst <a href="https://yuzu-mirror.github.io/help/quickstart"> dump og installer fastvare</a>, eller trykk "OK" for å fortsette likevel.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Søker etter spill...</string>
+    <string name="game_not_found_for_title_id">Spill ikke funnet for tittel-ID: %1$s</string>
+    <string name="custom_settings_failed_title">Egendefinerte innstillinger mislyktes</string>
+    <string name="custom_settings_failed_message">Kunne ikke bruke egendefinerte innstillinger for %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Start med standardinnstillinger</string>
+    <string name="launch_cancelled">Start avbrutt</string>
+    <string name="custom_settings_failure_reasons">Kan ikke bruke de forespurte innstillingene. Dette kan skyldes manglende GPU-drivere eller konfigurasjonsproblemer.</string>
+    <string name="custom_settings_applied">Egendefinerte innstillinger brukt</string>
+    <string name="launching_game">Starter %1$s...</string>
+    <string name="failed_to_initialize_game">Kunne ikke initialisere spillet</string>
+    <string name="custom_intent_launch_message_with_settings">Vil du starte %1$s med egendefinerte innstillinger?</string>
+    <string name="custom_intent_launch_message">Vil du starte %1$s?</string>
+    <string name="custom_intent_launch_title">Start spill</string>
+    <string name="launch">Start</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Kunne ikke skrive konfigurasjonsfil</string>
+    <string name="config_apply_failed">Kunne ikke bruke konfigurasjon</string>
+    <string name="config_already_exists_title">Konfigurasjon finnes allerede</string>
+    <string name="config_already_exists_message">Egendefinerte innstillinger finnes allerede for %1$s.\n\nVil du overskrive den eksisterende konfigurasjonen?\n\nDenne handlingen kan ikke angres.</string>
+    <string name="config_exists_prompt">Sjekker for eksisterende konfigurasjon...</string>
+    <string name="overwrite_cancelled">Overskriving avbrutt</string>
+    <string name="checking_driver">Sjekker for egendefinert driver: %1$s</string>
+    <string name="driver_unavailable">Egendefinert driver ikke tilgjengelig for denne enheten</string>
+    <string name="overwrite">Overskriv</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">GPU-driver mangler</string>
+    <string name="missing_gpu_driver_message">Den valgte egendefinerte driveren \"%s\" er ikke installert. Vil du laste ned og installere den nå?</string>
+    <string name="downloading_driver">Laster ned driver...</string>
+    <string name="driver_installed">Driver installert vellykket</string>
+    <string name="driver_installation_failed_title">Driverinstallasjon mislyktes</string>
+    <string name="driver_installation_failed_message">Kunne ikke installere GPU-driveren: %s</string>
+    <string name="driver_not_available_title">Driver ikke tilgjengelig</string>
+    <string name="driver_not_available_message">Den valgte driveren er ikke tilgjengelig for nedlasting.</string>
+    <string name="driver_not_found">Påkrevd driver ikke installert: %s</string>
+    <string name="invalid_driver_file">Ugyldig driverfil: %s</string>
+    <string name="network_unavailable">Ingen nettverkstilkobling tilgjengelig. Vennligst sjekk internettilkoblingen din og prøv på nytt.</string>
+    <string name="driver_missing_title">GPU-driver kreves</string>
+    <string name="driver_missing_message">Spillkonfigurasjonen krever GPU-driver \"%s\" som ikke er installert på enheten din.\n\nVil du laste ned og installere den nå?</string>
+    <string name="driver_download_cancelled">Driver-nedlasting avbrutt. Spillet kan ikke startes uten den påkrevde driveren.</string>
+    <string name="download">Last ned</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Avslutt emulering</string>
     <string name="emulation_done">Ferdig</string>
@@ -672,7 +722,8 @@
     <string name="emulation_rel_stick_center">Relativt pinnesenter</string>
     <string name="emulation_dpad_slide">D-pad-skyving</string>
     <string name="emulation_haptics">Berøringshaptikk</string>
-    <string name="emulation_show_overlay">Vis overlegg</string>
+    <string name="emulation_show_overlay">Vis kontroller</string>
+    <string name="emulation_hide_overlay">Skjul kontroller</string>
     <string name="emulation_toggle_all">Veksle mellom alle</string>
     <string name="emulation_control_adjust">Juster overlegg</string>
     <string name="emulation_control_scale">Skaler</string>
@@ -698,6 +749,7 @@
     <string name="fatal_error">Fatal Feil</string>
     <string name="fatal_error_message">Det oppstod en fatal feil. Sjekk loggen for mer informasjon.\nFortsatt emulering kan føre til krasj og feil.</string>
     <string name="performance_warning">Hvis du slår av denne innstillingen, reduseres emuleringsytelsen betydelig! Vi anbefaler at du lar denne innstillingen være aktivert for å få den beste opplevelsen.</string>
+
     <!-- Region Names -->
     <string name="region_japan">Japan</string>
     <string name="region_usa">USA</string>
@@ -709,6 +761,7 @@
 
     <string name="memory_byte_shorthand">B</string>
     <string name="memory_gigabyte">GB</string>
+
     <!-- Renderer APIs -->
     <string name="renderer_vulkan">Vulkan</string>
     <string name="renderer_none">Ingen</string>
@@ -718,6 +771,12 @@
     <string name="renderer_accuracy_high">Høy</string>
     <string name="renderer_accuracy_extreme">Ekstrem (Treg)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Standard</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Høy</string>
+    <string name="dma_accuracy_extreme">Ekstrem</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Włącz pamięć podręczną LRU</string>
     <string name="use_lru_cache_description">Włącz lub wyłącz pamięć podręczną LRU, aby poprawić wydajność poprzez zmniejszenie użycia procesora. Niektóre gry, takie jak TotK 1.2.1, mogą mieć problemy - wyłącz, jeśli gra się nie uruchamia lub losowo zawiesza.</string>
     <string name="dyna_state">Rozszerzony stan dynamiczny</string>
-    <string name="dyna_state_description">Włącza funkcje Vulkan w celu poprawy wydajności, renderowania i oszczędzania zasobów podczas tworzenia potoku, przy jednoczesnym utrzymaniu niskiego wykorzystania CPU/GPU. Te rozszerzenia mogą zwiększać temperaturę urządzenia, a starsze GPU z linii A6XX mogą nie działać poprawnie. Wyłącz, aby emulować formaty skalowane.</string>
+    <string name="dyna_state_description">Kontroluje liczbę funkcji, które mogą być używane w Rozszerzonym Stanie Dynamicznym. Wyższe wartości pozwalają na więcej funkcji i mogą zwiększyć wydajność, ale mogą powodować problemy z niektórymi sterownikami i producentami. Wartość domyślna może się różnić w zależności od systemu i możliwości sprzętowych. Tę wartość można zmieniać, aż do osiągnięcia stabilności i lepszej jakości wizualnej.</string>
     <string name="disabled">Wyłączone</string>
     <string name="use_sync_core">Synchronizuj prędkość rdzenia</string>
     <string name="use_sync_core_description">Synchronizuje prędkość rdzenia z maksymalnym procentem prędkości, aby poprawić wydajność bez zmiany rzeczywistej prędkości gry.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Takty</string>
     <string name="skip_cpu_inner_invalidation">Pomiń wewnętrzne unieważnienie CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Pomija niektóre unieważnienia pamięci podręcznej po stronie CPU podczas aktualizacji pamięci, zmniejszając użycie CPU i poprawiając jego wydajność. Może powodować błędy lub awarie w niektórych grach.</string>
+    <string name="cpuopt_unsafe_host_mmu">Włącz emulację MMU hosta</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Ta optymalizacja przyspiesza dostęp do pamięci przez program gościa. Włączenie powoduje, że odczyty/zapisy pamięci gościa są wykonywane bezpośrednio w pamięci i wykorzystują MMU hosta. Wyłączenie wymusza użycie programowej emulacji MMU dla wszystkich dostępów do pamięci.</string>
+    <string name="dma_accuracy">Poziom DMA</string>
+    <string name="dma_accuracy_description">Kontroluje dokładność precyzji DMA. Wyższy poziom może naprawić problemy w niektórych grach, ale może również wpłynąć na wydajność. Jeśli nie jesteś pewien, pozostaw wartość «Domyślny».</string>
 
     <string name="memory_4gb">4GB (Zalecane)</string>
     <string name="memory_6gb">6GB (Niebezpieczne)</string>
@@ -478,6 +482,8 @@
     <string name="use_custom_rtc">Niestandardowy RTC</string>
     <string name="use_custom_rtc_description">Ta opcja pozwala na wybranie własnych ustawień czasu używanych w czasie emulacji, innych niż czas systemu Android.</string>
     <string name="set_custom_rtc">Ustaw niestandardowy czas RTC</string>
+    <string name="disable_nca_verification">Wyłącz weryfikację NCA</string>
+    <string name="disable_nca_verification_description">Wyłącza weryfikację integralności archiwów zawartości NCA. Może to poprawić szybkość ładowania, ale niesie ryzyko uszkodzenia danych lub niezauważenia nieprawidłowych plików. Konieczne, aby działały gry i aktualizacje wymagające firmware\'u 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Generuj</string>
@@ -662,6 +668,50 @@
     <string name="loader_requires_firmware">Gra wymaga oprogramowania sprzętowego</string>
     <string name="loader_requires_firmware_description"><![CDATA[Gra, którą próbujesz uruchomić, wymaga oprogramowania sprzętowego do uruchomienia lub przejścia przez menu startowe. Proszę <a href="https://yuzu-mirror.github.io/help/quickstart"> zrzuć i zainstaluj oprogramowanie sprzętowe</a>, lub naciśnij "OK", aby kontynuować mimo to.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Wyszukiwanie gry...</string>
+    <string name="game_not_found_for_title_id">Nie znaleziono gry dla ID tytułu: %1$s</string>
+    <string name="custom_settings_failed_title">Niestandardowe ustawienia nie powiodły się</string>
+    <string name="custom_settings_failed_message">Nie udało się zastosować niestandardowych ustawień dla %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Uruchom z ustawieniami domyślnymi</string>
+    <string name="launch_cancelled">Uruchamianie anulowane</string>
+    <string name="custom_settings_failure_reasons">Nie można zastosować żądanych ustawień. Może to być spowodowane brakującymi sterownikami GPU lub problemami z konfiguracją.</string>
+    <string name="custom_settings_applied">Zastosowano niestandardowe ustawienia</string>
+    <string name="launching_game">Uruchamianie %1$s...</string>
+    <string name="failed_to_initialize_game">Nie udało się zainicjować gry</string>
+    <string name="custom_intent_launch_message_with_settings">Czy chcesz uruchomić %1$s z niestandardowymi ustawieniami?</string>
+    <string name="custom_intent_launch_message">Czy chcesz uruchomić %1$s?</string>
+    <string name="custom_intent_launch_title">Uruchom grę</string>
+    <string name="launch">Uruchom</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Nie udało się zapisać pliku konfiguracyjnego</string>
+    <string name="config_apply_failed">Nie udało się zastosować konfiguracji</string>
+    <string name="config_already_exists_title">Konfiguracja już istnieje</string>
+    <string name="config_already_exists_message">Niestandardowe ustawienia już istnieją dla %1$s.\n\nCzy chcesz nadpisać istniejącą konfigurację?\n\nTej czynności nie można cofnąć.</string>
+    <string name="config_exists_prompt">Sprawdzanie istniejącej konfiguracji...</string>
+    <string name="overwrite_cancelled">Nadpisywanie anulowane</string>
+    <string name="checking_driver">Sprawdzanie niestandardowego sterownika: %1$s</string>
+    <string name="driver_unavailable">Niestandardowy sterownik niedostępny dla tego urządzenia</string>
+    <string name="overwrite">Nadpisz</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Brak sterownika GPU</string>
+    <string name="missing_gpu_driver_message">Wybrany niestandardowy sterownik \"%s\" nie jest zainstalowany. Czy chcesz go teraz pobrać i zainstalować?</string>
+    <string name="downloading_driver">Pobieranie sterownika...</string>
+    <string name="driver_installed">Sterownik pomyślnie zainstalowany</string>
+    <string name="driver_installation_failed_title">Instalacja sterownika nie powiodła się</string>
+    <string name="driver_installation_failed_message">Nie udało się zainstalować sterownika GPU: %s</string>
+    <string name="driver_not_available_title">Sterownik niedostępny</string>
+    <string name="driver_not_available_message">Wybrany sterownik nie jest dostępny do pobrania.</string>
+    <string name="driver_not_found">Wymagany sterownik nie jest zainstalowany: %s</string>
+    <string name="invalid_driver_file">Nieprawidłowy plik sterownika: %s</string>
+    <string name="network_unavailable">Brak dostępnego połączenia sieciowego. Sprawdź swoje połączenie internetowe i spróbuj ponownie.</string>
+    <string name="driver_missing_title">Wymagany sterownik GPU</string>
+    <string name="driver_missing_message">Konfiguracja gry wymaga sterownika GPU \"%s\", który nie jest zainstalowany na Twoim urządzeniu.\n\nCzy chcesz go teraz pobrać i zainstalować?</string>
+    <string name="driver_download_cancelled">Pobieranie sterownika anulowane. Gra nie może zostać uruchomiona bez wymaganego sterownika.</string>
+    <string name="download">Pobierz</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Zakończ emulację</string>
     <string name="emulation_done">Gotowe</string>
@@ -670,7 +720,8 @@
     <string name="emulation_rel_stick_center">Wycentruj gałki</string>
     <string name="emulation_dpad_slide">Ruchomy D-pad</string>
     <string name="emulation_haptics">Wibracje haptyczne</string>
-    <string name="emulation_show_overlay">Pokaż przyciski</string>
+    <string name="emulation_show_overlay">Pokaż kontroler</string>
+    <string name="emulation_hide_overlay">Ukryj kontroler</string>
     <string name="emulation_toggle_all">Włącz wszystkie</string>
     <string name="emulation_control_adjust">Dostosuj nakładkę</string>
     <string name="emulation_control_scale">Skala</string>
@@ -707,6 +758,7 @@
 
     <string name="memory_byte_shorthand">B</string>
     <string name="memory_gigabyte">GB</string>
+
     <!-- Renderer APIs -->
     <string name="renderer_vulkan">Vulkan</string>
     <string name="renderer_none">Żadny</string>
@@ -716,6 +768,12 @@
     <string name="renderer_accuracy_high">Wysoki</string>
     <string name="renderer_accuracy_extreme">Ekstremalny (Wolny)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">預設</string>
+    <string name="dma_accuracy_normal">普通</string>
+    <string name="dma_accuracy_high">高</string>
+    <string name="dma_accuracy_extreme">極高</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

src/android/app/src/main/res/values-pt-rBR/strings.xml

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Ativar cache LRU</string>
     <string name="use_lru_cache_description">Ative ou desative o cache LRU para melhorar o desempenho economizando uso do processador. Alguns jogos como TotK 1.2.1 têm problemas - desative se o jogo não iniciar ou travar aleatoriamente.</string>
     <string name="dyna_state">Estado Dinâmico Estendido</string>
-    <string name="dyna_state_description">Ativa recursos Vulkan para melhorar desempenho, renderização e economizar recursos na criação de pipelines mantendo baixo uso de CPU/GPU. Essas extensões podem aumentar a temperatura do dispositivo e GPUs da linha A6XX mais antigos podem não responder adequadamente. Desative para emular formatos dimensionados.</string>
+    <string name="dyna_state_description">Controla o número de recursos que podem ser usados no Estado Dinâmico Estendido. Números mais altos permitem mais recursos e podem aumentar o desempenho, mas podem causar problemas com alguns drivers e fabricantes. O valor padrão pode variar dependendo do seu sistema e capacidades de hardware. Este valor pode ser alterado até que a estabilidade e uma melhor qualidade visual sejam alcançadas.</string>
     <string name="disabled">Desativado</string>
     <string name="use_sync_core">Sincronizar velocidade do núcleo</string>
     <string name="use_sync_core_description">Sincroniza a velocidade do núcleo com a porcentagem máxima de velocidade para melhorar o desempenho sem alterar a velocidade real do jogo.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">Pular invalidação interna da CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Ignora algumas invalidações de cache do lado da CPU durante atualizações de memória, reduzindo o uso da CPU e melhorando seu desempenho. Pode causar falhas ou travamentos em alguns jogos.</string>
+    <string name="cpuopt_unsafe_host_mmu">Ativar Emulação de MMU do Host</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Esta otimização acelera os acessos à memória pelo programa convidado. Ativar isso faz com que as leituras/gravações de memória do convidado sejam feitas diretamente na memória e utilizem a MMU do Host. Desativar isso força todos os acessos à memória a usarem a Emulação de MMU por Software.</string>
+    <string name="dma_accuracy">Nível DMA</string>
+    <string name="dma_accuracy_description">Controla a precisão do DMA. Maior precisão pode corrigir problemas em alguns jogos, mas também pode impactar o desempenho em alguns casos. Se não tiver certeza, deixe em Padrão.</string>
 
     <string name="memory_4gb">4GB (Recomendado)</string>
     <string name="memory_6gb">6GB (Inseguro)</string>
@@ -502,6 +506,8 @@
     <string name="use_custom_rtc">Data e hora personalizadas</string>
     <string name="use_custom_rtc_description">Permite a você configurar um relógio em tempo real separado do relógio do seu dispositivo.</string>
     <string name="set_custom_rtc">Definir um relógio em tempo real personalizado</string>
+    <string name="disable_nca_verification">Desativar verificação NCA</string>
+    <string name="disable_nca_verification_description">Desativa a verificação de integridade de arquivos de conteúdo NCA. Pode melhorar a velocidade de carregamento, mas arrisica corromper dados ou que arquivos inválidos passem despercebidos. É necessário para fazer jogos e atualizações que exigem firmware 20+ funcionarem.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Gerar</string>
@@ -798,6 +804,50 @@ uma tentativa de mapeamento automático</string>
     <string name="loader_requires_firmware">O jogo requer firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[O jogo que você está tentando iniciar requer firmware para inicializar ou passar do menu de abertura. Por favor <a href="https://yuzu-mirror.github.io/help/quickstart"> faça dump e instale o firmware</a>, ou pressione "OK" para continuar mesmo assim.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Procurando jogo...</string>
+    <string name="game_not_found_for_title_id">Jogo não encontrado para o ID do Título: %1$s</string>
+    <string name="custom_settings_failed_title">Configurações Personalizadas Falharam</string>
+    <string name="custom_settings_failed_message">Falha ao aplicar configurações personalizadas para %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Iniciar com Configurações Padrão</string>
+    <string name="launch_cancelled">Inicialização cancelada</string>
+    <string name="custom_settings_failure_reasons">Não foi possível aplicar as configurações solicitadas. Isso pode ser devido a drivers de GPU ausentes ou problemas de configuração.</string>
+    <string name="custom_settings_applied">Configurações personalizadas aplicadas</string>
+    <string name="launching_game">Iniciando %1$s...</string>
+    <string name="failed_to_initialize_game">Falha ao inicializar o jogo</string>
+    <string name="custom_intent_launch_message_with_settings">Deseja iniciar %1$s com configurações personalizadas?</string>
+    <string name="custom_intent_launch_message">Deseja iniciar %1$s?</string>
+    <string name="custom_intent_launch_title">Iniciar Jogo</string>
+    <string name="launch">Iniciar</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Falha ao escrever arquivo de configuração</string>
+    <string name="config_apply_failed">Falha ao aplicar configuração</string>
+    <string name="config_already_exists_title">Configuração Já Existe</string>
+    <string name="config_already_exists_message">Configurações personalizadas já existem para %1$s.\n\nDeseja sobrescrever a configuração existente?\n\nEsta ação não pode ser desfeita.</string>
+    <string name="config_exists_prompt">Verificando configuração existente...</string>
+    <string name="overwrite_cancelled">Sobrescrita cancelada</string>
+    <string name="checking_driver">Verificando driver personalizado: %1$s</string>
+    <string name="driver_unavailable">Driver personalizado não disponível para este dispositivo</string>
+    <string name="overwrite">Sobrescrever</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Driver de GPU Ausente</string>
+    <string name="missing_gpu_driver_message">O driver personalizado selecionado \"%s\" não está instalado. Deseja baixar e instalá-lo agora?</string>
+    <string name="downloading_driver">Baixando driver...</string>
+    <string name="driver_installed">Driver instalado com sucesso</string>
+    <string name="driver_installation_failed_title">Instalação do Driver Falhou</string>
+    <string name="driver_installation_failed_message">Falha ao instalar o driver da GPU: %s</string>
+    <string name="driver_not_available_title">Driver Não Disponível</string>
+    <string name="driver_not_available_message">O driver selecionado não está disponível para download.</string>
+    <string name="driver_not_found">Driver necessário não instalado: %s</string>
+    <string name="invalid_driver_file">Arquivo de driver inválido: %s</string>
+    <string name="network_unavailable">Nenhuma conexão de rede disponível. Verifique sua conexão com a internet e tente novamente.</string>
+    <string name="driver_missing_title">Driver de GPU Necessário</string>
+    <string name="driver_missing_message">A configuração do jogo requer o driver de GPU \"%s\" que não está instalado em seu dispositivo.\n\nDeseja baixar e instalá-lo agora?</string>
+    <string name="driver_download_cancelled">Download do driver cancelado. O jogo não pode ser iniciado sem o driver necessário.</string>
+    <string name="download">Baixar</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Sair da emulação</string>
     <string name="emulation_done">Feito</string>
@@ -807,7 +857,8 @@ uma tentativa de mapeamento automático</string>
     <string name="emulation_rel_stick_center">Centro Relativo do Analógico</string>
     <string name="emulation_dpad_slide">Deslizamento dos Botões Direcionais</string>
     <string name="emulation_haptics">Vibração ao tocar</string>
-    <string name="emulation_show_overlay">Mostrar overlay</string>
+    <string name="emulation_show_overlay">Mostrar controle</string>
+    <string name="emulation_hide_overlay">Ocultar controle</string>
     <string name="emulation_toggle_all">Marcar/Desmarcar tudo</string>
     <string name="emulation_control_adjust">Ajustar overlay</string>
     <string name="emulation_control_scale">Escala</string>
@@ -868,6 +919,12 @@ uma tentativa de mapeamento automático</string>
     <string name="renderer_accuracy_high">Alta</string>
     <string name="renderer_accuracy_extreme">Extrema (Lenta)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Padrão</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Alto</string>
+    <string name="dma_accuracy_extreme">Extremo</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

src/android/app/src/main/res/values-pt-rPT/strings.xml

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Ativar cache LRU</string>
     <string name="use_lru_cache_description">Ative ou desative a cache LRU para melhorar desempenho poupando uso do processador. Alguns jogos como TotK 1.2.1 têm problemas - desative se o jogo não iniciar ou falhar aleatoriamente.</string>
     <string name="dyna_state">Estado Dinâmico Estendido</string>
-    <string name="dyna_state_description">Ativa funcionalidades Vulkan para melhorar desempenho, renderização e poupar recursos na criação de pipelines mantendo baixa utilização de CPU/GPU. Estas extensões podem aumentar a temperatura do dispositivo e GPUs da linha A6XX mais antigos podem não responder corretamente. Desative para emular formatos dimensionados.</string>
+    <string name="dyna_state_description">Controla o número de funcionalidades que podem ser utilizadas no Estado Dinâmico Alargado. Valores mais elevados permitem mais funcionalidades e podem aumentar o desempenho, mas podem causar problemas com alguns controladores e fabricantes. O valor predefinido pode variar consoante o seu sistema e capacidades de hardware. Este valor pode ser alterado até ser alcançada a estabilidade e uma melhor qualidade visual.</string>
     <string name="disabled">Desativado</string>
     <string name="use_sync_core">Sincronizar velocidade do núcleo</string>
     <string name="use_sync_core_description">Sincroniza a velocidade do núcleo com a percentagem máxima de velocidade para melhorar o desempenho sem alterar a velocidade real do jogo.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">Ignorar invalidação interna da CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Ignora algumas invalidações de cache do lado da CPU durante atualizações de memória, reduzindo a utilização da CPU e melhorando o desempenho. Pode causar falhas ou crashes em alguns jogos.</string>
+    <string name="cpuopt_unsafe_host_mmu">Ativar Emulação de MMU do Anfitrião</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Esta otimização acelera os acessos à memória pelo programa convidado. Ativar faz com que as leituras/escritas de memória do convidado sejam efetuadas diretamente na memória e utilizem a MMU do Anfitrião. Desativar força todos os acessos à memória a usar a Emulação de MMU por Software.</string>
+    <string name="dma_accuracy">Nível DMA</string>
+    <string name="dma_accuracy_description">Controla a precisão do DMA. Maior precisão pode corrigir problemas em alguns jogos, mas também pode afetar o desempenho nalguns casos. Se não tiver a certeza, deixe em Predefinido.</string>
 
     <string name="memory_4gb">4GB (Recomendado)</string>
     <string name="memory_6gb">6GB (Inseguro)</string>
@@ -502,6 +506,8 @@
     <string name="use_custom_rtc">RTC personalizado</string>
     <string name="use_custom_rtc_description">Permite a você configurar um relógio em tempo real separado do relógio do seu dispositivo.</string>
     <string name="set_custom_rtc">Defina um relógio em tempo real personalizado</string>
+    <string name="disable_nca_verification">Desativar verificação NCA</string>
+    <string name="disable_nca_verification_description">Desativa a verificação de integridade dos arquivos de conteúdo NCA. Pode melhorar a velocidade de carregamento, mas arrisca a corrupção de dados ou que ficheiros inválidos passem despercebidos. É necessário para que jogos e atualizações que necessitam de firmware 20+ funcionem.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Gerar</string>
@@ -798,6 +804,50 @@ uma tentativa de mapeamento automático</string>
     <string name="loader_requires_firmware">O jogo requer firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[O jogo que está a tentar iniciar requer firmware para arrancar ou passar o menu inicial. Por favor <a href="https://yuzu-mirror.github.io/help/quickstart"> faça dump e instale o firmware</a>, ou pressione "OK" para continuar mesmo assim.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">A procurar jogo...</string>
+    <string name="game_not_found_for_title_id">Jogo não encontrado para o ID do Título: %1$s</string>
+    <string name="custom_settings_failed_title">Definições Personalizadas Falharam</string>
+    <string name="custom_settings_failed_message">Falha ao aplicar definições personalizadas para %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Iniciar com Definições Predefinidas</string>
+    <string name="launch_cancelled">Inicialização cancelada</string>
+    <string name="custom_settings_failure_reasons">Não foi possível aplicar as definições solicitadas. Isto pode ser devido a controladores de GPU em falta ou problemas de configuração.</string>
+    <string name="custom_settings_applied">Definições personalizadas aplicadas</string>
+    <string name="launching_game">A iniciar %1$s...</string>
+    <string name="failed_to_initialize_game">Falha ao inicializar o jogo</string>
+    <string name="custom_intent_launch_message_with_settings">Deseja iniciar %1$s com definições personalizadas?</string>
+    <string name="custom_intent_launch_message">Deseja iniciar %1$s?</string>
+    <string name="custom_intent_launch_title">Iniciar Jogo</string>
+    <string name="launch">Iniciar</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Falha ao escrever ficheiro de configuração</string>
+    <string name="config_apply_failed">Falha ao aplicar configuração</string>
+    <string name="config_already_exists_title">Configuração Já Existe</string>
+    <string name="config_already_exists_message">Definições personalizadas já existem para %1$s.\n\nDeseja substituir a configuração existente?\n\nEsta ação não pode ser desfeita.</string>
+    <string name="config_exists_prompt">A verificar configuração existente...</string>
+    <string name="overwrite_cancelled">Substituição cancelada</string>
+    <string name="checking_driver">A verificar controlador personalizado: %1$s</string>
+    <string name="driver_unavailable">Controlador personalizado não disponível para este dispositivo</string>
+    <string name="overwrite">Substituir</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Controlador de GPU em Falta</string>
+    <string name="missing_gpu_driver_message">O controlador personalizado selecionado \"%s\" não está instalado. Deseja transferir e instalá-lo agora?</string>
+    <string name="downloading_driver">A transferir controlador...</string>
+    <string name="driver_installed">Controlador instalado com sucesso</string>
+    <string name="driver_installation_failed_title">Instalação do Controlador Falhou</string>
+    <string name="driver_installation_failed_message">Falha ao instalar o controlador da GPU: %s</string>
+    <string name="driver_not_available_title">Controlador Não Disponível</string>
+    <string name="driver_not_available_message">O controlador selecionado não está disponível para transferência.</string>
+    <string name="driver_not_found">Controlador necessário não instalado: %s</string>
+    <string name="invalid_driver_file">Ficheiro de controlador inválido: %s</string>
+    <string name="network_unavailable">Nenhuma ligação de rede disponível. Verifique a sua ligação à internet e tente novamente.</string>
+    <string name="driver_missing_title">Controlador de GPU Necessário</string>
+    <string name="driver_missing_message">A configuração do jogo requer o controlador de GPU \"%s\" que não está instalado no seu dispositivo.\n\nDeseja transferir e instalá-lo agora?</string>
+    <string name="driver_download_cancelled">Transferência do controlador cancelada. O jogo não pode ser iniciado sem o controlador necessário.</string>
+    <string name="download">Transferir</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Parar emulação</string>
     <string name="emulation_done">Feito</string>
@@ -807,7 +857,8 @@ uma tentativa de mapeamento automático</string>
     <string name="emulation_rel_stick_center">Centro Relativo de Analógico</string>
     <string name="emulation_dpad_slide">Deslizamento dos Botões Direcionais</string>
     <string name="emulation_haptics">Vibração ao tocar</string>
-    <string name="emulation_show_overlay">Mostrar overlay</string>
+    <string name="emulation_show_overlay">Mostrar comando</string>
+    <string name="emulation_hide_overlay">Ocultar comando</string>
     <string name="emulation_toggle_all">Marcar/Desmarcar tudo</string>
     <string name="emulation_control_adjust">Ajustar overlay</string>
     <string name="emulation_control_scale">Escala</string>
@@ -868,6 +919,12 @@ uma tentativa de mapeamento automático</string>
     <string name="renderer_accuracy_high">Alto</string>
     <string name="renderer_accuracy_extreme">Estremo (Lento)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Predefinido</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">Alto</string>
+    <string name="dma_accuracy_extreme">Extremo</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Включить LRU-кеш</string>
     <string name="use_lru_cache_description">Включите или отключите кэш LRU (наименее недавно использованный), повышая производительность за счёт снижения нагрузки на ЦП. Некоторые игры могут работать с ним некорректно (например, TotK 1.2.1), поэтому отключите, если игра не запускается или случайно вылетает.</string>
     <string name="dyna_state">Расширенное динамическое состояние</string>
-    <string name="dyna_state_description">Включает функции Vulkan для улучшения производительности, рендеринга и экономии ресурсов при создании конвейера, сохраняя низкое использование ЦП/ГПУ. Эти расширения могут увеличить температуру устройства, а ГПУ из старой линейки A6XX могут работать некорректно. Отключите для эмуляции масштабируемых форматов.</string>
+    <string name="dyna_state_description">Управляет количеством функций, которые можно использовать в расширенном динамическом состоянии. Более высокие значения позволяют использовать больше функций и могут повысить производительность, но могут вызвать проблемы с некоторыми драйверами и производителями. Значение по умолчанию может варьироваться в зависимости от вашей системы и возможностей оборудования. Это значение можно изменять до достижения стабильности и лучшего визуального качества.</string>
     <string name="disabled">Отключено</string>
     <string name="use_sync_core">Синхронизация скорости ядра</string>
     <string name="use_sync_core_description">Синхронизирует скорость ядра с максимальным процентом скорости для улучшения производительности без изменения фактической скорости игры.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Такты</string>
     <string name="skip_cpu_inner_invalidation">Пропустить внутреннюю инвалидацию ЦП</string>
     <string name="skip_cpu_inner_invalidation_description">Пропускает некоторые инвалидации кэша на стороне ЦП при обновлениях памяти, уменьшая нагрузку на процессор и повышая производительность. Может вызывать сбои в некоторых играх.</string>
+    <string name="cpuopt_unsafe_host_mmu">Включить эмуляцию MMU хоста</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Эта оптимизация ускоряет доступ к памяти гостевой программой. При включении операции чтения/записи памяти гостя выполняются напрямую в памяти с использованием MMU хоста. Отключение заставляет все обращения к памяти использовать программную эмуляцию MMU.</string>
+    <string name="dma_accuracy">Уровень DMA</string>
+    <string name="dma_accuracy_description">Управляет точностью DMA. Более высокий уровень может исправить проблемы в некоторых играх, но также может повлиять на производительность. Если не уверены, оставьте значение «По умолчанию».</string>
 
     <string name="memory_4gb">4 ГБ (Рекомендуется)</string>
     <string name="memory_6gb">6 ГБ (Небезопасно)</string>
@@ -504,6 +508,8 @@
     <string name="use_custom_rtc">Пользовательский RTC</string>
     <string name="use_custom_rtc_description">Позволяет установить пользовательские часы реального времени отдельно от текущего системного времени.</string>
     <string name="set_custom_rtc">Установить пользовательский RTC</string>
+    <string name="disable_nca_verification">Отключить проверку NCA</string>
+    <string name="disable_nca_verification_description">Отключает проверку целостности архивов содержимого NCA. Может улучшить скорость загрузки, но есть риск повреждения данных или того, что недействительные файлы останутся незамеченными. Необходимо для работы игр и обновлений, требующих прошивку 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Создать</string>
@@ -672,7 +678,7 @@
     <string name="delete">Удалить</string>
     <string name="edit">Редактировать</string>
     <string name="export_success">Экспорт успешно выполнен</string>
-    <string name="start">Start</string>
+    <string name="start">Запуск</string>
     <string name="clear">Очистить</string>
     <string name="global">Глобальный</string>
     <string name="custom">Другое</string>
@@ -799,6 +805,50 @@
     <string name="loader_requires_firmware">Игре требуется прошивка</string>
     <string name="loader_requires_firmware_description"><![CDATA[Для запуска этой игры или прохождения начального меню требуется прошивка. Пожалуйста, <a href="https://yuzu-mirror.github.io/help/quickstart">сохраните и установите прошивку</a> или нажмите "OK" для запуска в любом случае.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Поиск игры...</string>
+    <string name="game_not_found_for_title_id">Игра не найдена для ID заголовка: %1$s</string>
+    <string name="custom_settings_failed_title">Пользовательские настройки не применены</string>
+    <string name="custom_settings_failed_message">Не удалось применить пользовательские настройки для %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Запустить с настройками по умолчанию</string>
+    <string name="launch_cancelled">Запуск отменен</string>
+    <string name="custom_settings_failure_reasons">Не удалось применить запрошенные настройки. Это может быть связано с отсутствием драйверов GPU или проблемами конфигурации.</string>
+    <string name="custom_settings_applied">Пользовательские настройки применены</string>
+    <string name="launching_game">Запуск %1$s...</string>
+    <string name="failed_to_initialize_game">Не удалось инициализировать игру</string>
+    <string name="custom_intent_launch_message_with_settings">Хотите запустить %1$s с пользовательскими настройками?</string>
+    <string name="custom_intent_launch_message">Хотите запустить %1$s?</string>
+    <string name="custom_intent_launch_title">Запуск игры</string>
+    <string name="launch">Запустить</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Не удалось записать файл конфигурации</string>
+    <string name="config_apply_failed">Не удалось применить конфигурацию</string>
+    <string name="config_already_exists_title">Конфигурация уже существует</string>
+    <string name="config_already_exists_message">Пользовательские настройки уже существуют для %1$s.\n\nХотите перезаписать существующую конфигурацию?\n\nЭто действие нельзя отменить.</string>
+    <string name="config_exists_prompt">Проверка существующей конфигурации...</string>
+    <string name="overwrite_cancelled">Перезапись отменена</string>
+    <string name="checking_driver">Проверка пользовательского драйвера: %1$s</string>
+    <string name="driver_unavailable">Пользовательский драйвер недоступен для этого устройства</string>
+    <string name="overwrite">Перезаписать</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Отсутствует драйвер GPU</string>
+    <string name="missing_gpu_driver_message">Выбранный пользовательский драйвер \"%s\" не установлен. Хотите скачать и установить его сейчас?</string>
+    <string name="downloading_driver">Загрузка драйвера...</string>
+    <string name="driver_installed">Драйвер успешно установлен</string>
+    <string name="driver_installation_failed_title">Ошибка установки драйвера</string>
+    <string name="driver_installation_failed_message">Не удалось установить драйвер GPU: %s</string>
+    <string name="driver_not_available_title">Драйвер недоступен</string>
+    <string name="driver_not_available_message">Выбранный драйвер недоступен для загрузки.</string>
+    <string name="driver_not_found">Необходимый драйвер не установлен: %s</string>
+    <string name="invalid_driver_file">Неверный файл драйвера: %s</string>
+    <string name="network_unavailable">Сетевое соединение недоступно. Проверьте подключение к интернету и попробуйте снова.</string>
+    <string name="driver_missing_title">Требуется драйвер GPU</string>
+    <string name="driver_missing_message">Конфигурация игры требует драйвер GPU \"%s\", который не установлен на вашем устройстве.\n\nХотите скачать и установить его сейчас?</string>
+    <string name="driver_download_cancelled">Загрузка драйвера отменена. Игра не может быть запущена без необходимого драйвера.</string>
+    <string name="download">Скачать</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Выход из эмуляции</string>
     <string name="emulation_done">Готово</string>
@@ -808,7 +858,8 @@
     <string name="emulation_rel_stick_center">Относительный центр стика</string>
     <string name="emulation_dpad_slide">Слайд крестовиной</string>
     <string name="emulation_haptics">Обратная связь от нажатий</string>
-    <string name="emulation_show_overlay">Показать оверлей</string>
+    <string name="emulation_show_overlay">Показать контроллер</string>
+    <string name="emulation_hide_overlay">Скрыть контроллер</string>
     <string name="emulation_toggle_all">Переключить всё</string>
     <string name="emulation_control_adjust">Регулировка оверлея</string>
     <string name="emulation_control_scale">Масштаб</string>
@@ -869,6 +920,12 @@
     <string name="renderer_accuracy_high">Высокая</string>
     <string name="renderer_accuracy_extreme">Экстрим (медленный)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">По умолчанию</string>
+    <string name="dma_accuracy_normal">Нормальный</string>
+    <string name="dma_accuracy_high">Высокий</string>
+    <string name="dma_accuracy_extreme">Экстремальный</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -73,7 +73,7 @@
 
     <string name="veil_extensions">ГПУ екстензије</string>
     <string name="dyna_state">Проширена динамичка држава</string>
-    <string name="dyna_state_description">Омогућава функције Вулкана да побољшају перформансе, приказивање и уштеде ресурсе за креирање на цевоводама, задржавајући нижи ЦПУ / ГПУ коришћење. Ови продужеци могу повећати температуру уређаја и ГПУ који припадају старијој А6кк линији не могу правилно реаговати. Искључите за емулацију скалираних формата.</string>
+    <string name="dyna_state_description">Управља бројем функција које се могу користити у Проширеном динамичком стању. Веће вредности омогућавају више функција и могу повећати перформансе, али могу изазвати проблеме са неким драјверима и произвођачима. Подразумевана вредност може се разликовати у зависности од вашег система и хардверских могућности. Ова вредност се може мењати док се не постигне стабилност и бољи визуелни квалитет.</string>
     <string name="disabled">Искључено</string>
     <string name="provoking_vertex">Провоцирајући врх</string>
     <string name="provoking_vertex_description">Побољшава осветљење и вертификат руковања у одређеним играма. Подржан само на Вулкану 1.0+ ГПУ-у.</string>
@@ -119,6 +119,10 @@
     <string name="cpu_ticks">Тактови</string>
     <string name="skip_cpu_inner_invalidation">Preskoči unutrašnje poništavanje CPU-a</string>
     <string name="skip_cpu_inner_invalidation_description">Preskače određena poništavanja keša na strani CPU-a tokom ažuriranja memorije, smanjujući opterećenje procesora i poboljšavajući performanse. Može izazvati greške u nekim igrama.</string>
+    <string name="cpuopt_unsafe_host_mmu">Омогући емулацију MMU домаћина</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Ова оптимизација убрзава приступ меморији од стране гостујућег програма. Укључивање изазива да се читања/уписа меморије госта обављају директно у меморији и користе MMU домаћина. Искључивање присиљава све приступе меморији да користе софтверску емулацију MMU.</string>
+    <string name="dma_accuracy">DMA ниво</string>
+    <string name="dma_accuracy_description">Контролише тачност DMA прецизности. Виши ниво може да поправи проблеме у неким играма, али може и да утиче на перформансе. Ако нисте сигурни, оставите на «Подразумевано».</string>
 
     <!-- Shader Backend -->
     <string name="shader_backend">Схадер Бацкенд</string>
@@ -453,6 +457,8 @@
     <string name="use_custom_rtc">Цустом РТЦ</string>
     <string name="use_custom_rtc_description">Омогућава вам да поставите прилагођени сат у реалном времену одвојено од тренутног времена система.</string>
     <string name="set_custom_rtc">Подесите прилагођени РТЦ</string>
+    <string name="disable_nca_verification">Искључи верификацију НЦА</string>
+    <string name="disable_nca_verification_description">Искључује верификацију интегритета НЦА архива садржаја. Ово може побољшати брзину учитавања, али ризикује оштећење података или да неважећи фајлови прођу незапажено. Неопходно је да би игре и ажурирања која захтевају firmware 20+ радили.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Генериши</string>
@@ -755,6 +761,50 @@
     <string name="loader_requires_firmware">Игра захтева firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Игра коју покушавате да покренете захтева firmware за покретање или прелазак почетног менија. Молимо <a href="https://yuzu-mirror.github.io/help/quickstart"> направите дамп и инсталирајте firmware</a>, или притисните "OK" да бисте наставили у сваком случају.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Тражење игре...</string>
+    <string name="game_not_found_for_title_id">Игра није пронађена за ID наслова: %1$s</string>
+    <string name="custom_settings_failed_title">Прилагођена подешавања нису успела</string>
+    <string name="custom_settings_failed_message">Неуспело применљивање прилагођених подешавања за %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Покрени са подразумеваним подешавањима</string>
+    <string name="launch_cancelled">Покретање отказано</string>
+    <string name="custom_settings_failure_reasons">Није могуће применити тражена подешавања. Ово може бити услед недостајућих GPU драјвера или проблема са конфигурацијом.</string>
+    <string name="custom_settings_applied">Прилагођена подешавања применљена</string>
+    <string name="launching_game">Покрећем %1$s...</string>
+    <string name="failed_to_initialize_game">Неуспела иницијализација игре</string>
+    <string name="custom_intent_launch_message_with_settings">Да ли желите да покренете %1$s са прилагођеним подешавањима?</string>
+    <string name="custom_intent_launch_message">Да ли желите да покренете %1$s?</string>
+    <string name="custom_intent_launch_title">Покрени игру</string>
+    <string name="launch">Покрени</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Неуспело писање конфигурационе датотеке</string>
+    <string name="config_apply_failed">Неуспела примена конфигурације</string>
+    <string name="config_already_exists_title">Конфигурација већ постоји</string>
+    <string name="config_already_exists_message">Прилагођена подешавања већ постоје за %1$s.\n\nДа ли желите да препишете постојећу конфигурацију?\n\nОву радњу није могуће поништити.</string>
+    <string name="config_exists_prompt">Провера постојеће конфигурације...</string>
+    <string name="overwrite_cancelled">Преписивање отказано</string>
+    <string name="checking_driver">Провера прилагођеног драјвера: %1$s</string>
+    <string name="driver_unavailable">Прилагођени драјвер није доступан за овај уређај</string>
+    <string name="overwrite">Препиши</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">GPU драјвер недостаје</string>
+    <string name="missing_gpu_driver_message">Одабрани прилагођени драјвер \"%s\" није инсталиран. Да ли желите да га преузмете и инсталирате сада?</string>
+    <string name="downloading_driver">Преузимање драјвера...</string>
+    <string name="driver_installed">Драјвер успешно инсталиран</string>
+    <string name="driver_installation_failed_title">Инсталација драјвера није успела</string>
+    <string name="driver_installation_failed_message">Неуспела инсталација GPU драјвера: %s</string>
+    <string name="driver_not_available_title">Драјвер није доступан</string>
+    <string name="driver_not_available_message">Одабрани драјвер није доступан за преузимање.</string>
+    <string name="driver_not_found">Потребни драјвер није инсталиран: %s</string>
+    <string name="invalid_driver_file">Неисправна датотека драјвера: %s</string>
+    <string name="network_unavailable">Мрежна веза није доступна. Проверите интернет конекцију и покушајте поново.</string>
+    <string name="driver_missing_title">GPU драјвер је потребан</string>
+    <string name="driver_missing_message">Конфигурација игре захтева GPU драјвер \"%s\" који није инсталиран на вашем уређају.\n\nДа ли желите да га преузмете и инсталирате сада?</string>
+    <string name="driver_download_cancelled">Преузимање драјвера отказано. Игра се не може покренути без потребног драјвера.</string>
+    <string name="download">Преузми</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Излазни емулација</string>
     <string name="emulation_done">Доношен</string>
@@ -764,7 +814,8 @@
     <string name="emulation_rel_stick_center">Релативни центар за штапић</string>
     <string name="emulation_dpad_slide">Д-Пад Слиде</string>
     <string name="emulation_haptics">Додирните ХАптицс</string>
-    <string name="emulation_show_overlay">Приказати прекривање</string>
+    <string name="emulation_show_overlay">Приказати контролер</string>
+    <string name="emulation_hide_overlay">Сакрити контролер</string>
     <string name="emulation_toggle_all">Пребацивати све</string>
     <string name="emulation_control_adjust">Подесити прекривање</string>
     <string name="emulation_control_scale">Скала</string>
@@ -864,6 +915,12 @@
     <string name="renderer_accuracy_high">Високо</string>
     <string name="renderer_accuracy_extreme">Екстремни (спор)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Подразумевано</string>
+    <string name="dma_accuracy_normal">Нормално</string>
+    <string name="dma_accuracy_high">Високо</string>
+    <string name="dma_accuracy_extreme">Екстремно</string>
+
     <!-- ASTC Decoding Method -->
     <string name="accelerate_astc">АСТЦ метода декодирања</string>
     <string name="accelerate_astc_description">Изаберите како су текстуре са компримираним текстовима декодиране за приказивање: ЦПУ (споро, сигуран), ГПУ (Фаст, Препоручи) или ЦПУ АСИНЦ (без затезача, могу да изазове питања)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Увімкнути LRU-кеш</string>
     <string name="use_lru_cache_description">Увімкніть або вимкніть кеш LRU (Least Recently Used) для покращення продуктивності шляхом зменшення навантаження на CPU. Деякі ігри (зокрема TotK 1.2.1) можуть працювати некоректно - вимкніть, якщо гра не запускається або раптово вилітає.</string>
     <string name="dyna_state">Розширений динамічний стан</string>
-    <string name="dyna_state_description">Активує функції Vulkan для покращення продуктивності, поліпшеня рендерингу та економії ресурсів під час створення конвеєрів (pipeline), зберігаючи низьке використання CPU/GPU. Ці розширення можуть підвищити температуру пристрою, а старі GPU серії A6XX можуть реагувати некоректно. Вимкніть для емуляції масштабованих форматів.</string>
+    <string name="dyna_state_description">Керує кількістю функцій, які можна використовувати в розширеному динамічному стані. Вищі значення дозволяють більше функцій і можуть підвищити продуктивність, але можуть спричинити проблеми з деякими драйверами та постачальниками. Значення за замовчуванням може відрізнятися залежно від вашої системи та апаратних можливостей. Це значення можна змінювати, док не буде досягнуто стабільності та кращої якості зображення.</string>
     <string name="disabled">Вимкнено</string>
     <string name="use_sync_core">Синхронізувати швидкість ядра</string>
     <string name="use_sync_core_description">Синхронізує швидкість ядра з максимальним відсотком швидкості для покращення продуктивності без зміни реальної швидкості гри.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Такти</string>
     <string name="skip_cpu_inner_invalidation">Пропустити внутрішнє інвалідування CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Пропускає деякі інвалідації кешу на стороні CPU під час оновлення пам\'яті, зменшуючи навантаження на процесор і покращуючи продуктивність. Може спричинити збої в деяких іграх.</string>
+    <string name="cpuopt_unsafe_host_mmu">Увімкнути емуляцію MMU хоста</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Ця оптимізація пришвидшує доступ до пам\'яті гостьовою програмою. Увімкнення призводить до того, що читання/запис пам\'яті гостя виконуються безпосередньо в пам\'яті та використовують MMU хоста. Вимкнення змушує всі звернення до пам\'яті використовувати програмну емуляцію MMU.</string>
+    <string name="dma_accuracy">Рівень DMA</string>
+    <string name="dma_accuracy_description">Керує точністю DMA. Вищий рівень може виправити проблеми в деяких іграх, але також може вплинути на продуктивність. Якщо не впевнені, залиште значення «Типово».</string>
 
     <string name="memory_4gb">4 ГБ (Рекомендовано)</string>
     <string name="memory_6gb">6 ГБ (Небезпечно)</string>
@@ -491,6 +495,8 @@
     <string name="use_custom_rtc">Свій RTC</string>
     <string name="use_custom_rtc_description">Дозволяє встановити власний час (Real-time clock, або RTC), відмінний від системного.</string>
     <string name="set_custom_rtc">Встановити RTC</string>
+    <string name="disable_nca_verification">Вимкнути перевірку NCA</string>
+    <string name="disable_nca_verification_description">Вимкає перевірку цілісності архівів вмісту NCA. Може покращити швидкість завантаження, але ризикує пошкодженням даних або тим, що недійсні файли залишаться непоміченими. Необхідно для роботи ігор та оновлень, які вимагають прошивки 20+.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Створити</string>
@@ -692,10 +698,78 @@
     <string name="loader_requires_firmware">Гра вимагає прошивки</string>
     <string name="loader_requires_firmware_description"><![CDATA[Гра, яку ви намагаєтеся запустити, вимагає прошивки для завантаження або пропуску початкового меню. Будь ласка, <a href="https://yuzu-mirror.github.io/help/quickstart"> зробіть дамп і встановіть прошивку</a>, або натисніть "OK", щоб продовжити в будь-якому разі.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Пошук гри...</string>
+    <string name="game_not_found_for_title_id">Гру не знайдено для ID заголовку: %1$s</string>
+    <string name="custom_settings_failed_title">Користувацькі налаштування не застосовано</string>
+    <string name="custom_settings_failed_message">Не вдалося застосувати користувацькі налаштування для %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Запустити з налаштуваннями за замовчуванням</string>
+    <string name="launch_cancelled">Запуск скасовано</string>
+    <string name="custom_settings_failure_reasons">Не вдалося застосувати запитувані налаштування. Це може бути пов\'язано з відсутністю драйверів GPU або проблемами конфігурації.</string>
+    <string name="custom_settings_applied">Користувацькі налаштування застосовано</string>
+    <string name="launching_game">Запуск %1$s...</string>
+    <string name="failed_to_initialize_game">Не вдалося ініціалізувати гру</string>
+    <string name="custom_intent_launch_message_with_settings">Бажаєте запустити %1$s з користувацькими налаштуваннями?</string>
+    <string name="custom_intent_launch_message">Бажаєте запустити %1$s?</string>
+    <string name="custom_intent_launch_title">Запустити гру</string>
+    <string name="launch">Запустити</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Не вдалося записати файл конфігурації</string>
+    <string name="config_apply_failed">Не вдалося застосувати конфігурацію</string>
+    <string name="config_already_exists_title">Конфігурація вже існує</string>
+    <string name="config_already_exists_message">Користувацькі налаштування вже існують для %1$s.\n\nБажаєте перезаписати існуючу конфігурацію?\n\nЦю дію не можна скасувати.</string>
+    <string name="config_exists_prompt">Перевірка наявної конфігурації...</string>
+    <string name="overwrite_cancelled">Перезапис скасовано</string>
+    <string name="checking_driver">Перевірка користувацького драйвера: %1$s</string>
+    <string name="driver_unavailable">Користувацький драйвер недоступний для цього пристрою</string>
+    <string name="overwrite">Перезаписати</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Відсутній драйвер GPU</string>
+    <string name="missing_gpu_driver_message">Обраний користувацький драйвер \"%s\" не встановлено. Бажаєте завантажити та встановити його зараз?</string>
+    <string name="downloading_driver">Завантаження драйвера...</string>
+    <string name="driver_installed">Драйвер успішно встановлено</string>
+    <string name="driver_installation_failed_title">Помилка встановлення драйвера</string>
+    <string name="driver_installation_failed_message">Не вдалося встановити драйвер GPU: %s</string>
+    <string name="driver_not_available_title">Драйвер недоступний</string>
+    <string name="driver_not_available_message">Обраний драйвер недоступний для завантаження.</string>
+    <string name="driver_not_found">Необхідний драйвер не встановлено: %s</string>
+    <string name="invalid_driver_file">Недійсний файл драйвера: %s</string>
+    <string name="network_unavailable">Мережеве з\'єднання недоступне. Перевірте підключення до інтернету та спробуйте ще раз.</string>
+    <string name="driver_missing_title">Потрібен драйвер GPU</string>
+    <string name="driver_missing_message">Конфігурація гри вимагає драйвер GPU \"%s\", який не встановлено на вашому пристрої.\n\nБажаєте завантажити та встановити його зараз?</string>
+    <string name="driver_download_cancelled">Завантаження драйвера скасовано. Гру не можна запустити без необхідного драйвера.</string>
+    <string name="download">Завантажити</string>
+
+    <!-- Emulation Menu -->
+    <string name="emulation_exit">Вийти з емуляції</string>
     <string name="emulation_done">Готово</string>
+    <string name="emulation_fps_counter">Лічильник FPS</string>
+    <string name="emulation_thermal_indicator">Індикатор температури</string>
+    <string name="emulation_toggle_controls">Перемкнути елементи керування</string>
+    <string name="emulation_rel_stick_center">Відносний центр джойстика</string>
+    <string name="emulation_dpad_slide">Ковзання D-pad</string>
+    <string name="emulation_haptics">Тактильний відгук</string>
+    <string name="emulation_show_overlay">Показати контролер</string>
+    <string name="emulation_hide_overlay">Сховати контролер</string>
+    <string name="emulation_toggle_all">Перемкнути все</string>
+    <string name="emulation_control_adjust">Налаштувати накладання</string>
     <string name="emulation_control_scale">Масштаб</string>
     <string name="emulation_control_opacity">Непрозорість</string>
+    <string name="emulation_touch_overlay_reset">Скинути накладання</string>
+    <string name="emulation_touch_overlay_edit">Редагувати накладання</string>
+    <string name="emulation_pause">Призупинити емуляцію</string>
+    <string name="emulation_unpause">Продовжити емуляцію</string>
+    <string name="emulation_input_overlay">Опції накладання</string>
     <string name="touchscreen">Сенсорний екран</string>
+    <string name="lock_drawer">Заблокувати панель</string>
+    <string name="unlock_drawer">Розблокувати панель</string>
+
+    <string name="load_settings">Завантаження налаштувань…</string>
+
+    <!-- Software keyboard -->
+    <string name="software_keyboard">Програмна клавіатура</string>
 
     <!-- Errors and warnings -->
     <string name="abort_button">Зупинити</string>
@@ -735,6 +809,12 @@
     <string name="renderer_accuracy_high">Висока</string>
     <string name="renderer_accuracy_extreme">Екстрим (повільно)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Типово</string>
+    <string name="dma_accuracy_normal">Нормальний</string>
+    <string name="dma_accuracy_high">Високий</string>
+    <string name="dma_accuracy_extreme">Екстремальний</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">Bật bộ nhớ đệm LRU</string>
     <string name="use_lru_cache_description">Bật hoặc tắt bộ nhớ đệm LRU để cải thiện hiệu suất bằng cách tiết kiệm quy trình sử dụng CPU. Một số trò chơi như TotK 1.2.1 có vấn đề - hãy tắt nếu trò chơi không khởi động hoặc bị treo ngẫu nhiên.</string>
     <string name="dyna_state">Trạng thái động mở rộng</string>
-    <string name="dyna_state_description">Kích hoạt tính năng Vulkan để cải thiện hiệu suất, kết xuất và tiết kiệm tài nguyên khi tạo pipeline trong khi vẫn duy trì mức sử dụng CPU/GPU thấp. Các tiện ích mở rộng này có thể làm tăng nhiệt độ thiết bị và GPU thuộc dòng A6XX cũ có thể không phản ứng đúng. Tắt để mô phỏng các định dạng tỷ lệ.</string>
+    <string name="dyna_state_description">Điều khiển số tính năng có thể được sử dụng trong Trạng thái Động Mở rộng. Giá trị cao hơn cho phép nhiều tính năng hơn và có thể tăng hiệu suất, nhưng có thể gây ra sự cố với một số trình điều khiển và nhà cung cấp. Giá trị mặc định có thể thay đổi tùy thuộc vào hệ thống và khả năng phần cứng của bạn. Giá trị này có thể được thay đổi cho đến khi đạt được độ ổn định và chất lượng hình ảnh tốt hơn.</string>
     <string name="disabled">Đã tắt</string>
     <string name="use_sync_core">Đồng bộ tốc độ lõi</string>
     <string name="use_sync_core_description">Đồng bộ tốc độ lõi với tỷ lệ phần trăm tốc độ tối đa để cải thiện hiệu suất mà không làm thay đổi tốc độ thực tế của trò chơi.</string>
@@ -126,6 +126,10 @@
     <string name="cpu_ticks">Tích</string>
     <string name="skip_cpu_inner_invalidation">Bỏ qua vô hiệu hóa bên trong CPU</string>
     <string name="skip_cpu_inner_invalidation_description">Bỏ qua một số lần vô hiệu hóa bộ nhớ đệm phía CPU trong khi cập nhật bộ nhớ, giảm mức sử dụng CPU và cải thiện hiệu suất. Có thể gây ra lỗi hoặc treo máy trong một số trò chơi.</string>
+    <string name="cpuopt_unsafe_host_mmu">Bật giả lập MMU Máy chủ</string>
+    <string name="cpuopt_unsafe_host_mmu_description">Tối ưu hóa này tăng tốc độ truy cập bộ nhớ của chương trình khách. Bật nó lên khiến các thao tác đọc/ghi bộ nhớ khách được thực hiện trực tiếp vào bộ nhớ và sử dụng MMU của Máy chủ. Tắt tính năng này buộc tất cả quyền truy cập bộ nhớ phải sử dụng Giả lập MMU Phần mềm.</string>
+    <string name="dma_accuracy">Cấp độ DMA</string>
+    <string name="dma_accuracy_description">Điều khiển độ chính xác của DMA. Độ chính xác cao hơn có thể sửa lỗi trong một số trò chơi, nhưng cũng có thể ảnh hưởng đến hiệu suất trong một số trường hợp. Nếu không chắc chắn, hãy để ở Mặc định.</string>
 
     <string name="memory_4gb">4GB (Được đề xuất)</string>
     <string name="memory_6gb">6GB (Không an toàn)</string>
@@ -478,6 +482,8 @@
     <string name="use_custom_rtc">RTC tuỳ chỉnh</string>
     <string name="use_custom_rtc_description">Cho phép bạn thiết lập một đồng hồ thời gian thực tùy chỉnh riêng biệt so với thời gian hệ thống hiện tại.</string>
     <string name="set_custom_rtc">Thiết lập RTC tùy chỉnh</string>
+    <string name="disable_nca_verification">Tắt xác minh NCA</string>
+    <string name="disable_nca_verification_description">Tắt xác minh tính toàn vẹn của kho lưu trữ nội dung NCA. Có thể cải thiện tốc độ tải nhưng có nguy cơ hỏng dữ liệu hoặc các tệp không hợp lệ không bị phát hiện. Cần thiết để các trò chơi và bản cập nhật yêu cầu firmware 20+ hoạt động.</string>
 
     <!-- Network settings strings -->
     <string name="generate">Tạo</string>
@@ -667,6 +673,50 @@
     <string name="loader_requires_firmware">Trò chơi yêu cầu firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[Trò chơi bạn đang cố khởi chạy yêu cầu firmware để khởi động hoặc vượt qua menu mở đầu. Vui lòng <a href="https://yuzu-mirror.github.io/help/quickstart"> dump và cài đặt firmware</a>, hoặc nhấn "OK" để tiếp tục dù sao đi nữa.]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">Đang tìm kiếm trò chơi...</string>
+    <string name="game_not_found_for_title_id">Không tìm thấy trò chơi cho ID Tiêu đề: %1$s</string>
+    <string name="custom_settings_failed_title">Cài đặt Tùy chỉnh Thất bại</string>
+    <string name="custom_settings_failed_message">Không thể áp dụng cài đặt tùy chỉnh cho %1$s: %2$s</string>
+    <string name="launch_with_default_settings">Khởi chạy với Cài đặt Mặc định</string>
+    <string name="launch_cancelled">Đã hủy khởi chạy</string>
+    <string name="custom_settings_failure_reasons">Không thể áp dụng các cài đặt được yêu cầu. Điều này có thể do thiếu trình điều khiển GPU hoặc sự cố cấu hình.</string>
+    <string name="custom_settings_applied">Đã áp dụng cài đặt tùy chỉnh</string>
+    <string name="launching_game">Đang khởi chạy %1$s...</string>
+    <string name="failed_to_initialize_game">Không thể khởi tạo trò chơi</string>
+    <string name="custom_intent_launch_message_with_settings">Bạn có muốn khởi chạy %1$s với cài đặt tùy chỉnh không?</string>
+    <string name="custom_intent_launch_message">Bạn có muốn khởi chạy %1$s không?</string>
+    <string name="custom_intent_launch_title">Khởi chạy Trò chơi</string>
+    <string name="launch">Khởi chạy</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">Không thể ghi tệp cấu hình</string>
+    <string name="config_apply_failed">Không thể áp dụng cấu hình</string>
+    <string name="config_already_exists_title">Cấu hình Đã Tồn tại</string>
+    <string name="config_already_exists_message">Cài đặt tùy chỉnh đã tồn tại cho %1$s.\n\nBạn có muốn ghi đè cấu hình hiện có không?\n\nHành động này không thể hoàn tác.</string>
+    <string name="config_exists_prompt">Đang kiểm tra cấu hình hiện có...</string>
+    <string name="overwrite_cancelled">Đã hủy ghi đè</string>
+    <string name="checking_driver">Đang kiểm tra trình điều khiển tùy chỉnh: %1$s</string>
+    <string name="driver_unavailable">Trình điều khiển tùy chỉnh không khả dụng cho thiết bị này</string>
+    <string name="overwrite">Ghi đè</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">Thiếu Trình điều khiển GPU</string>
+    <string name="missing_gpu_driver_message">Trình điều khiển tùy chỉnh được chọn \"%s\" chưa được cài đặt. Bạn có muốn tải xuống và cài đặt ngay bây giờ không?</string>
+    <string name="downloading_driver">Đang tải xuống trình điều khiển...</string>
+    <string name="driver_installed">Đã cài đặt trình điều khiển thành công</string>
+    <string name="driver_installation_failed_title">Cài đặt Trình điều khiển Thất bại</string>
+    <string name="driver_installation_failed_message">Không thể cài đặt trình điều khiển GPU: %s</string>
+    <string name="driver_not_available_title">Trình điều khiển Không khả dụng</string>
+    <string name="driver_not_available_message">Trình điều khiển được chọn không có sẵn để tải xuống.</string>
+    <string name="driver_not_found">Không tìm thấy trình điều khiển bắt buộc: %s</string>
+    <string name="invalid_driver_file">Tệp trình điều khiển không hợp lệ: %s</string>
+    <string name="network_unavailable">Không có kết nối mạng khả dụng. Vui lòng kiểm tra kết nối internet của bạn và thử lại.</string>
+    <string name="driver_missing_title">Yêu cầu Trình điều khiển GPU</string>
+    <string name="driver_missing_message">Cấu hình trò chơi yêu cầu trình điều khiển GPU \"%s\" chưa được cài đặt trên thiết bị của bạn.\n\nBạn có muốn tải xuống và cài đặt ngay bây giờ không?</string>
+    <string name="driver_download_cancelled">Đã hủy tải xuống trình điều khiển. Không thể khởi chạy trò chơi nếu thiếu trình điều khiển bắt buộc.</string>
+    <string name="download">Tải xuống</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">Thoát giả lập</string>
     <string name="emulation_done">Hoàn tất</string>
@@ -675,7 +725,8 @@
     <string name="emulation_rel_stick_center">Trung tâm nút cần xoay tương đối</string>
     <string name="emulation_dpad_slide">Trượt D-pad</string>
     <string name="emulation_haptics">Chạm haptics</string>
-    <string name="emulation_show_overlay">Hiện lớp phủ</string>
+    <string name="emulation_show_overlay">Hiện bộ điều khiển</string>
+    <string name="emulation_hide_overlay">Ẩn bộ điều khiển</string>
     <string name="emulation_toggle_all">Chuyển đổi tất cả</string>
     <string name="emulation_control_adjust">Điều chỉnh lớp phủ</string>
     <string name="emulation_control_scale">Tỉ lệ thu phóng</string>
@@ -701,6 +752,7 @@
     <string name="fatal_error">Lỗi nghiêm trọng</string>
     <string name="fatal_error_message">Đã xảy ra lỗi nghiêm trọng. Kiểm tra nhật ký để biết chi tiết.\nViệc tiếp tục giả lập có thể dẫn đến sự cố và lỗi.</string>
     <string name="performance_warning">Tắt cài đặt này sẽ làm giảm đáng kể hiệu suất giả lập! Để có trải nghiệm tốt nhất, bạn nên bật cài này.</string>
+
     <!-- Region Names -->
     <string name="region_japan">Nhật Bản</string>
     <string name="region_usa">Hoa Kỳ</string>
@@ -712,6 +764,7 @@
 
     <string name="memory_byte_shorthand">B</string>
     <string name="memory_gigabyte">GB</string>
+
     <!-- Renderer APIs -->
     <string name="renderer_vulkan">Vulkan</string>
     <string name="renderer_none">Trống</string>
@@ -721,6 +774,12 @@
     <string name="renderer_accuracy_high">Khỏe</string>
     <string name="renderer_accuracy_extreme">Tối đa (Chậm)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Mặc định</string>
+    <string name="dma_accuracy_normal">Bình thường</string>
+    <string name="dma_accuracy_high">Cao</string>
+    <string name="dma_accuracy_extreme">Cực cao</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -84,7 +84,7 @@
     <string name="use_lru_cache">启用LRU缓存</string>
     <string name="use_lru_cache_description">启用或禁用LRU缓存，通过节省CPU进程使用来提高性能。某些游戏可能存在问题，特别是TotK 1.2.1，如果游戏无法启动或随机崩溃，请禁用此选项。</string>
     <string name="dyna_state">扩展动态状态</string>
-    <string name="dyna_state_description">启用Vulkan功能以提高性能、渲染效果，并在创建管道时节省资源，同时保持较低的CPU/GPU使用率。这些扩展可能会提高设备温度，旧款A6XX系列GPU可能无法正常工作。禁用可模拟缩放格式。</string>
+    <string name="dyna_state_description">控制扩展动态状态中可使用的功能数量。数值越高，允许的功能越多，并可能提高性能，但可能会导致某些驱动程序和供应商出现问题。默认值可能因系统和硬件能力而异。可以更改此值，直到实现稳定性和更好的视觉质量。</string>
     <string name="disabled">已禁用</string>
     <string name="use_sync_core">同步核心速度</string>
     <string name="use_sync_core_description">将核心速度与最大速度百分比同步，在不改变游戏实际速度的情况下提高性能。</string>
@@ -125,6 +125,10 @@
     <string name="cpu_ticks">时钟</string>
     <string name="skip_cpu_inner_invalidation">跳过CPU内部无效化</string>
     <string name="skip_cpu_inner_invalidation_description">在内存更新期间跳过某些CPU端缓存无效化，减少CPU使用率并提高其性能。可能会导致某些游戏出现故障或崩溃。</string>
+    <string name="cpuopt_unsafe_host_mmu">启用主机 MMU 模拟</string>
+    <string name="cpuopt_unsafe_host_mmu_description">此优化可加速来宾程序的内存访问。启用后，来宾内存读取/写入将直接在内存中执行并利用主机的 MMU。禁用此功能将强制所有内存访问使用软件 MMU 模拟。</string>
+    <string name="dma_accuracy">DMA 级别</string>
+    <string name="dma_accuracy_description">控制 DMA 精度。更高的精度可以修复某些游戏中的问题，但在某些情况下也可能影响性能。如果不确定，请保留为“默认”。</string>
 
     <string name="memory_4gb">4GB (推荐)</string>
     <string name="memory_6gb">6GB (不安全)</string>
@@ -496,6 +500,8 @@
     <string name="use_custom_rtc">自定义系统时间</string>
     <string name="use_custom_rtc_description">此选项允许您设置与目前系统时间相独立的自定义系统时钟。</string>
     <string name="set_custom_rtc">设置自定义系统时间</string>
+<string name="disable_nca_verification">禁用NCA验证</string>
+<string name="disable_nca_verification_description">禁用NCA内容存档的完整性验证。可能会提高加载速度，但存在数据损坏或无效文件未被检测到的风险。对于需要固件20+的游戏和更新是必需的。</string>
 
     <!-- Network settings strings -->
     <string name="generate">生成</string>
@@ -791,6 +797,50 @@
     <string name="loader_requires_firmware">游戏需要固件</string>
     <string name="loader_requires_firmware_description"><![CDATA[您尝试启动的游戏需要固件才能引导或通过启动菜单。请<a href="https://yuzu-mirror.github.io/help/quickstart">转储并安装固件</a>，或点击"确定"继续。]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">正在搜索游戏...</string>
+    <string name="game_not_found_for_title_id">未找到标题ID的游戏: %1$s</string>
+    <string name="custom_settings_failed_title">自定义设置失败</string>
+    <string name="custom_settings_failed_message">无法应用自定义设置 %1$s: %2$s</string>
+    <string name="launch_with_default_settings">使用默认设置启动</string>
+    <string name="launch_cancelled">启动已取消</string>
+    <string name="custom_settings_failure_reasons">无法应用请求的设置。这可能是由于缺少GPU驱动程序或配置问题。</string>
+    <string name="custom_settings_applied">已应用自定义设置</string>
+    <string name="launching_game">正在启动 %1$s...</string>
+    <string name="failed_to_initialize_game">无法初始化游戏</string>
+    <string name="custom_intent_launch_message_with_settings">是否要使用自定义设置启动 %1$s？</string>
+    <string name="custom_intent_launch_message">是否要启动 %1$s？</string>
+    <string name="custom_intent_launch_title">启动游戏</string>
+    <string name="launch">启动</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">无法写入配置文件</string>
+    <string name="config_apply_failed">无法应用配置</string>
+    <string name="config_already_exists_title">配置已存在</string>
+    <string name="config_already_exists_message">%1$s 的自定义设置已存在。\n\n是否要覆盖现有配置？\n\n此操作无法撤消。</string>
+    <string name="config_exists_prompt">正在检查现有配置...</string>
+    <string name="overwrite_cancelled">覆盖已取消</string>
+    <string name="checking_driver">正在检查自定义驱动程序: %1$s</string>
+    <string name="driver_unavailable">自定义驱动程序不适用于此设备</string>
+    <string name="overwrite">覆盖</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">缺少GPU驱动程序</string>
+    <string name="missing_gpu_driver_message">选定的自定义驱动程序 \"%s\" 未安装。是否要立即下载并安装？</string>
+    <string name="downloading_driver">正在下载驱动程序...</string>
+    <string name="driver_installed">驱动程序安装成功</string>
+    <string name="driver_installation_failed_title">驱动程序安装失败</string>
+    <string name="driver_installation_failed_message">无法安装GPU驱动程序: %s</string>
+    <string name="driver_not_available_title">驱动程序不可用</string>
+    <string name="driver_not_available_message">选定的驱动程序不可下载。</string>
+    <string name="driver_not_found">未安装所需的驱动程序: %s</string>
+    <string name="invalid_driver_file">无效的驱动程序文件: %s</string>
+    <string name="network_unavailable">无可用网络连接。请检查您的互联网连接并重试。</string>
+    <string name="driver_missing_title">需要GPU驱动程序</string>
+    <string name="driver_missing_message">游戏配置需要GPU驱动程序 \"%s\"，但您的设备上未安装。\n\n是否要立即下载并安装？</string>
+    <string name="driver_download_cancelled">驱动程序下载已取消。没有所需的驱动程序无法启动游戏。</string>
+    <string name="download">下载</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">退出模拟</string>
     <string name="emulation_done">完成</string>
@@ -800,7 +850,8 @@
     <string name="emulation_rel_stick_center">相对摇杆中心</string>
     <string name="emulation_dpad_slide">十字方向键滑动</string>
     <string name="emulation_haptics">触觉反馈</string>
-    <string name="emulation_show_overlay">显示虚拟按键</string>
+    <string name="emulation_show_overlay">显示控制器</string>
+    <string name="emulation_hide_overlay">隐藏控制器</string>
     <string name="emulation_toggle_all">全部切换</string>
     <string name="emulation_control_adjust">调整虚拟按键</string>
     <string name="emulation_control_scale">缩放</string>
@@ -861,6 +912,12 @@
     <string name="renderer_accuracy_high">高</string>
     <string name="renderer_accuracy_extreme">极高 (慢速)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">默认</string>
+    <string name="dma_accuracy_normal">普通</string>
+    <string name="dma_accuracy_high">高</string>
+    <string name="dma_accuracy_extreme">极高</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -85,7 +85,7 @@
     <string name="use_lru_cache">啟用LRU快取</string>
     <string name="use_lru_cache_description">啟用或停用LRU快取，透過節省CPU進程使用來提高效能。某些遊戲可能存在問題，特別是TotK 1.2.1，如果遊戲無法啟動或隨機崩潰，請停用此選項。</string>
     <string name="dyna_state">擴展動態狀態</string>
-    <string name="dyna_state_description">啟用Vulkan功能以提高效能、渲染效果，並在創建管線時節省資源，同時保持較低的CPU/GPU使用率。這些擴充功能可能會提高裝置溫度，舊款A6XX系列GPU可能無法正常運作。停用可模擬縮放格式。</string>
+    <string name="dyna_state_description">控制擴展動態狀態中可使用的功能數量。數值越高，允許的功能越多，並可能提高效能，但可能會導致某些驅動程式和供應商出現問題。預設值可能因系統和硬體能力而異。可以變更此值，直到實現穩定性和更好的視覺品質。</string>
     <string name="disabled">已停用</string>
     <string name="use_sync_core">同步核心速度</string>
     <string name="use_sync_core_description">將核心速度與最大速度百分比同步，在不改變遊戲實際速度的情況下提高效能。</string>
@@ -118,6 +118,10 @@
     <string name="cpu_ticks">時脈</string>
     <string name="skip_cpu_inner_invalidation">跳過CPU內部無效化</string>
     <string name="skip_cpu_inner_invalidation_description">在記憶體更新期間跳過某些CPU端快取無效化，減少CPU使用率並提高其性能。可能會導致某些遊戲出現故障或崩潰。</string>
+    <string name="cpuopt_unsafe_host_mmu">啟用主機 MMU 模擬</string>
+    <string name="cpuopt_unsafe_host_mmu_description">此最佳化可加速來賓程式的記憶體存取。啟用後，來賓記憶體讀取/寫入將直接在記憶體中執行並利用主機的 MMU。停用此功能將強制所有記憶體存取使用軟體 MMU 模擬。</string>
+    <string name="dma_accuracy">DMA 級別</string>
+    <string name="dma_accuracy_description">控制 DMA 精確度。更高的精確度可以修復某些遊戲中的問題，但在某些情況下也可能影響效能。如果不確定，請保留為「預設」。</string>
 
     <!-- Memory Layouts -->
     <string name="memory_4gb">4GB (推薦)</string>
@@ -501,6 +505,8 @@
     <string name="use_custom_rtc">自訂 RTC</string>
     <string name="use_custom_rtc_description">允許您設定與您的目前系統時間相互獨立的自訂即時時鐘。</string>
     <string name="set_custom_rtc">設定自訂 RTC</string>
+    <string name="disable_nca_verification">停用NCA驗證</string>
+    <string name="disable_nca_verification_description">停用NCA內容存檔的完整性驗證。可能會提高載入速度，但存在資料損毀或無效檔案未被偵測到的風險。對於需要韌體20+的遊戲和更新是必需的。</string>
 
     <!-- Network settings strings -->
     <string name="generate">生成</string>
@@ -796,6 +802,50 @@
     <string name="loader_requires_firmware">遊戲需要韌體</string>
     <string name="loader_requires_firmware_description"><![CDATA[您嘗試啟動的遊戲需要韌體才能引導或通過啟動選單。請<a href="https://yuzu-mirror.github.io/help/quickstart">轉儲並安裝韌體</a>，或點擊"確定"繼續。]]></string>
 
+    <!-- Intent Launch strings -->
+    <string name="searching_for_game">正在搜尋遊戲...</string>
+    <string name="game_not_found_for_title_id">找不到標題ID的遊戲: %1$s</string>
+    <string name="custom_settings_failed_title">自訂設定失敗</string>
+    <string name="custom_settings_failed_message">無法套用自訂設定 %1$s: %2$s</string>
+    <string name="launch_with_default_settings">使用預設設定啟動</string>
+    <string name="launch_cancelled">啟動已取消</string>
+    <string name="custom_settings_failure_reasons">無法套用請求的設定。這可能是由於缺少GPU驅動程式或設定問題。</string>
+    <string name="custom_settings_applied">已套用自訂設定</string>
+    <string name="launching_game">正在啟動 %1$s...</string>
+    <string name="failed_to_initialize_game">無法初始化遊戲</string>
+    <string name="custom_intent_launch_message_with_settings">是否要使用自訂設定啟動 %1$s？</string>
+    <string name="custom_intent_launch_message">是否要啟動 %1$s？</string>
+    <string name="custom_intent_launch_title">啟動遊戲</string>
+    <string name="launch">啟動</string>
+
+    <!-- Custom Config strings -->
+    <string name="config_write_failed">無法寫入設定檔</string>
+    <string name="config_apply_failed">無法套用設定</string>
+    <string name="config_already_exists_title">設定已存在</string>
+    <string name="config_already_exists_message">%1$s 的自訂設定已存在。\n\n是否要覆蓋現有設定？\n\n此操作無法復原。</string>
+    <string name="config_exists_prompt">正在檢查現有設定...</string>
+    <string name="overwrite_cancelled">覆蓋已取消</string>
+    <string name="checking_driver">正在檢查自訂驅動程式: %1$s</string>
+    <string name="driver_unavailable">自訂驅動程式不適用於此裝置</string>
+    <string name="overwrite">覆蓋</string>
+
+    <!-- Driver strings -->
+    <string name="missing_gpu_driver_title">缺少GPU驅動程式</string>
+    <string name="missing_gpu_driver_message">選定的自訂驅動程式 \"%s\" 未安裝。是否要立即下載並安裝？</string>
+    <string name="downloading_driver">正在下載驅動程式...</string>
+    <string name="driver_installed">驅動程式安裝成功</string>
+    <string name="driver_installation_failed_title">驅動程式安裝失敗</string>
+    <string name="driver_installation_failed_message">無法安裝GPU驅動程式: %s</string>
+    <string name="driver_not_available_title">驅動程式不可用</string>
+    <string name="driver_not_available_message">選定的驅動程式無法下載。</string>
+    <string name="driver_not_found">未安裝所需的驅動程式: %s</string>
+    <string name="invalid_driver_file">無效的驅動程式檔案: %s</string>
+    <string name="network_unavailable">無可用網路連線。請檢查您的網路連線並重試。</string>
+    <string name="driver_missing_title">需要GPU驅動程式</string>
+    <string name="driver_missing_message">遊戲設定需要GPU驅動程式 \"%s\"，但您的裝置上未安裝。\n\n是否要立即下載並安裝？</string>
+    <string name="driver_download_cancelled">驅動程式下載已取消。沒有所需的驅動程式無法啟動遊戲。</string>
+    <string name="download">下載</string>
+
     <!-- Emulation Menu -->
     <string name="emulation_exit">結束模擬</string>
     <string name="emulation_done">完成</string>
@@ -805,7 +855,8 @@
     <string name="emulation_rel_stick_center">相對搖桿中心</string>
     <string name="emulation_dpad_slide">方向鍵滑動</string>
     <string name="emulation_haptics">觸覺回饋技術</string>
-    <string name="emulation_show_overlay">顯示覆疊</string>
+    <string name="emulation_show_overlay">顯示控制器</string>
+    <string name="emulation_hide_overlay">隱藏控制器</string>
     <string name="emulation_toggle_all">全部切換</string>
     <string name="emulation_control_adjust">調整覆疊</string>
     <string name="emulation_control_scale">縮放</string>
@@ -866,6 +917,12 @@
     <string name="renderer_accuracy_high">高</string>
     <string name="renderer_accuracy_extreme">極高 (慢)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">預設</string>
+    <string name="dma_accuracy_normal">普通</string>
+    <string name="dma_accuracy_high">高</string>
+    <string name="dma_accuracy_extreme">極高</string>
+
     <!-- Resolutions -->
     <string name="resolution_quarter">0.25X (180p/270p)</string>
     <string name="resolution_half">0.5X (360p/540p)</string>

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

@@ -452,6 +452,19 @@
         <item>2</item>
     </integer-array>
 
+    <string-array name="dmaAccuracyNames">
+        <item>@string/dma_accuracy_default</item>
+        <item>@string/dma_accuracy_normal</item>
+        <item>@string/dma_accuracy_high</item>
+        <item>@string/dma_accuracy_extreme</item>
+    </string-array>
+    <integer-array name="dmaAccuracyValues">
+        <item>0</item>
+        <item>1</item>
+        <item>2</item>
+        <item>3</item>
+    </integer-array>
+
     <string-array name="appletEntries">
         <item>@string/applet_hle</item>
         <item>@string/applet_lle</item>

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

@@ -74,7 +74,7 @@
 
     <string name="veil_extensions">GPU Extensions</string>
     <string name="dyna_state">Extended Dynamic State</string>
-    <string name="dyna_state_description">Enables Vulkan features to improve performance, rendering, and save resources on pipeline creation while maintaining lower CPU/GPU usage. These extensions may increase device temperature, and GPUs belonging to the older A6XX line may not react properly. Disable to emulate scaled formats.</string>
+    <string name="dyna_state_description">Controls the number of features that can be used in Extended Dynamic State. Higher numbers allow for more features and can increase performance, but may cause issues with some drivers and vendors. The default value may vary depending on your system and hardware capabilities. This value can be changed until stability and a better visual quality are achieved.</string>
     <string name="disabled">Disabled</string>
     <string name="provoking_vertex">Provoking Vertex</string>
     <string name="provoking_vertex_description">Improves lighting and vertex handling in certain games. Only supported on Vulkan 1.0+ GPUs.</string>
@@ -109,10 +109,14 @@
     <string name="cpu_ticks">Ticks</string>
     <string name="skip_cpu_inner_invalidation">Skip CPU Inner Invalidation</string>
     <string name="skip_cpu_inner_invalidation_description">Skips certain CPU-side cache invalidations during memory updates, reducing CPU usage and improving it\'s performance. This may cause glitches or crashes on some games.</string>
+    <string name="cpuopt_unsafe_host_mmu">Enable Host MMU Emulation</string>
+    <string name="cpuopt_unsafe_host_mmu_description">This optimization speeds up memory accesses by the guest program. Enabling it causes guest memory reads/writes to be done directly into memory and make use of Host\'s MMU. Disabling this forces all memory accesses to use Software MMU Emulation.</string>
     <string name="fast_cpu_time">CPU Clock</string>
     <string name="fast_cpu_time_description">Use Boost (1700MHz) to run at the Switch\'s highest native clock, or Fast (2000MHz) to run at 2x clock.</string>
     <string name="memory_layout">Memory Layout</string>
     <string name="memory_layout_description">(EXPERIMENTAL) Change the emulated memory layout. This setting will not increase performance, but may help with games utilizing high resolutions via mods. Do not use on phones with 8GB of RAM or less. Only works on the Dynarmic (JIT) backend.</string>
+    <string name="dma_accuracy">DMA Level</string>
+    <string name="dma_accuracy_description">Controls the DMA precision accuracy. Higher precision can fix issues in some games, but it can also impact performance in some cases. If unsure, leave it at Default.</string>
 
     <!-- Shader Backend -->
     <string name="shader_backend">Shader Backend</string>
@@ -470,6 +474,8 @@
     <string name="use_custom_rtc">Custom RTC</string>
     <string name="use_custom_rtc_description">Allows you to set a custom real-time clock separate from your current system time.</string>
     <string name="set_custom_rtc">Set custom RTC</string>
+    <string name="disable_nca_verification">Disable NCA Verification</string>
+    <string name="disable_nca_verification_description">Disables integrity verification of NCA content archives. This may improve loading speed but risks data corruption or invalid files going undetected. Some games that require firmware versions 20+ may need this as well.</string>
 
     <string name="generate">Generate</string>
 
@@ -778,6 +784,9 @@
     <string name="loader_requires_firmware">Game Requires Firmware</string>
     <string name="loader_requires_firmware_description"><![CDATA[The game you are trying to launch requires firmware to boot or to get past the opening menu. Please <a href="https://yuzu-mirror.github.io/help/quickstart"> dump and install firmware</a>, or press "OK" to launch anyways.]]></string>
 
+    <string name="nca_verification_disabled">NCA Verification Disabled</string>
+    <string name="nca_verification_disabled_description">This is required to run new games and updates, but may cause instability or crashes if NCA files are corrupt, modified, or tampered with. If unsure, re-enable verification in Advanced Settings -> System, and use firmware versions of 19.0.1 or below.</string>
+
     <!-- Intent Launch strings -->
     <string name="searching_for_game">Searching for game...</string>
     <string name="game_not_found_for_title_id">Game not found for Title ID: %1$s</string>
@@ -816,6 +825,11 @@
     <string name="driver_not_available_message">The selected driver is not available for download.</string>
     <string name="driver_not_found">Required driver not installed: %s</string>
     <string name="invalid_driver_file">Invalid driver file: %s</string>
+    <string name="network_unavailable">No network connection available. Please check your internet connection and try again.</string>
+    <string name="driver_missing_title">GPU Driver Required</string>
+    <string name="driver_missing_message">The game configuration requires GPU driver \"%s\" which is not installed on your device.\n\nWould you like to download and install it now?</string>
+    <string name="driver_download_cancelled">Driver download cancelled. The game cannot be launched without the required driver.</string>
+    <string name="download">Download</string>
 
     <!-- Emulation Menu -->
     <string name="emulation_exit">Exit emulation</string>
@@ -826,7 +840,8 @@
     <string name="emulation_rel_stick_center">Relative stick center</string>
     <string name="emulation_dpad_slide">D-pad slide</string>
     <string name="emulation_haptics">Touch haptics</string>
-    <string name="emulation_show_overlay">Show overlay</string>
+    <string name="emulation_show_overlay">Show controller</string>
+    <string name="emulation_hide_overlay">Hide controller</string>
     <string name="emulation_toggle_all">Toggle all</string>
     <string name="emulation_control_adjust">Adjust overlay</string>
     <string name="emulation_control_scale">Scale</string>
@@ -927,6 +942,12 @@
     <string name="renderer_accuracy_high">High</string>
     <string name="renderer_accuracy_extreme">Extreme (Slow)</string>
 
+    <!-- DMA Accuracy -->
+    <string name="dma_accuracy_default">Default</string>
+    <string name="dma_accuracy_normal">Normal</string>
+    <string name="dma_accuracy_high">High</string>
+    <string name="dma_accuracy_extreme">Extreme</string>
+
     <!-- ASTC Decoding Method -->
     <string name="accelerate_astc">ASTC Decoding Method</string>
     <string name="accelerate_astc_description">Pick how ASTC-compressed textures are decoded for rendering: CPU (slow, safe), GPU (fast, recommended), or CPU Async (no stutters, may cause issues)</string>

src/audio_core/common/feature_support.h

@@ -13,7 +13,7 @@
 #include "common/polyfill_ranges.h"
 
 namespace AudioCore {
-constexpr u32 CurrentRevision = 13;
+constexpr u32 CurrentRevision = 15;
 
 enum class SupportTags {
     CommandProcessingTimeEstimatorVersion4,

src/audio_core/opus/decoder.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -148,7 +151,7 @@ Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out
     auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
     OpusPacketHeader header{ReverseHeader(*header_p)};
 
-    LOG_TRACE(Service_Audio, "header size 0x{:X} input data size 0x{:X} in_data size 0x{:X}",
+    LOG_TRACE(Service_Audio, "header size {:#X} input data size 0x{:X} in_data size 0x{:X}",
               header.size, input_data.size_bytes(), in_data.size_bytes());
 
     R_UNLESS(in_data.size_bytes() >= header.size &&

src/common/CMakeLists.txt

@@ -272,13 +272,7 @@ if (lz4_ADDED)
 endif()
 
 target_link_libraries(common PUBLIC fmt::fmt stb::headers Threads::Threads)
-target_link_libraries(common PRIVATE lz4::lz4 LLVM::Demangle)
-
-if (TARGET libzstd_static)
-  target_link_libraries(common PRIVATE libzstd_static)
-else()
-  target_link_libraries(common PRIVATE zstd)
-endif()
+target_link_libraries(common PRIVATE lz4::lz4 LLVM::Demangle zstd::zstd)
 
 if(ANDROID)
   # For ASharedMemory_create

src/common/fs/path_util.cpp

@@ -517,24 +517,4 @@ std::string_view GetPathWithoutTop(std::string_view path) {
     return path.substr(std::min(name_bck_index, name_fwd_index) + 1);
 }
 
-std::string_view GetFilename(std::string_view path) {
-    const auto name_index = path.find_last_of("\\/");
-
-    if (name_index == std::string_view::npos) {
-        return {};
-    }
-
-    return path.substr(name_index + 1);
-}
-
-std::string_view GetExtensionFromFilename(std::string_view name) {
-    const std::size_t index = name.rfind('.');
-
-    if (index == std::string_view::npos) {
-        return {};
-    }
-
-    return name.substr(index + 1);
-}
-
 } // namespace Common::FS

src/common/fs/path_util.h

@@ -352,9 +352,17 @@ enum class DirectorySeparator {
 [[nodiscard]] std::string_view GetPathWithoutTop(std::string_view path);
 
 // Gets the filename of the path
-[[nodiscard]] std::string_view GetFilename(std::string_view path);
+[[nodiscard]] inline std::string_view GetFilename(const std::string_view path) noexcept {
+    if (auto const name_index = path.find_last_of("\\/"); name_index != std::string_view::npos)
+        return path.substr(name_index + 1);
+    return {};
+}
 
 // Gets the extension of the filename
-[[nodiscard]] std::string_view GetExtensionFromFilename(std::string_view name);
+[[nodiscard]] inline std::string_view GetExtensionFromFilename(const std::string_view name) noexcept {
+    if (auto const index = name.rfind('.'); index != std::string_view::npos)
+        return name.substr(index + 1);
+    return {};
+}
 
 } // namespace Common::FS

src/common/heap_tracker.cpp

@@ -2,10 +2,9 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <fstream>
-#include <vector>
-
 #include "common/heap_tracker.h"
 #include "common/logging/log.h"
+#include "common/assert.h"
 
 namespace Common {
 

src/common/host_memory.cpp

@@ -12,7 +12,7 @@
 #include <windows.h>
 #include "common/dynamic_library.h"
 
-#elif defined(__linux__) || defined(__FreeBSD__) || defined(__sun__) // ^^^ Windows ^^^ vvv Linux vvv
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__sun__) || defined(__APPLE__) // ^^^ Windows ^^^ vvv POSIX vvv
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
@@ -20,10 +20,18 @@
 #include <boost/icl/interval_set.hpp>
 #include <fcntl.h>
 #include <sys/mman.h>
-#include <sys/random.h>
 #include <unistd.h>
 #include "common/scope_exit.h"
 
+#if defined(__linux__)
+#include <sys/random.h>
+#elif defined(__APPLE__)
+#include <sys/types.h>
+#include <sys/random.h>
+#include <mach/vm_map.h>
+#include <mach/mach.h>
+#endif
+
 // FreeBSD
 #ifndef MAP_NORESERVE
 #define MAP_NORESERVE 0
@@ -32,8 +40,12 @@
 #ifndef MAP_ALIGNED_SUPER
 #define MAP_ALIGNED_SUPER 0
 #endif
+// macOS
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
 
-#endif // ^^^ Linux ^^^
+#endif // ^^^ POSIX ^^^
 
 #include <mutex>
 #include <random>
@@ -372,7 +384,7 @@ private:
     std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };
 
-#elif defined(__linux__) || defined(__FreeBSD__) || defined(__sun__) // ^^^ Windows ^^^ vvv Linux vvv
+#elif defined(__linux__) || defined(__FreeBSD__) || defined(__sun__) || defined(__APPLE__) // ^^^ Windows ^^^ vvv POSIX vvv
 
 #ifdef ARCHITECTURE_arm64
 
@@ -417,11 +429,12 @@ static void* ChooseVirtualBase(size_t virtual_size) {
 #else
 
 static void* ChooseVirtualBase(size_t virtual_size) {
+#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__managarm__) || defined(__AIX__)
     void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
     if (virtual_base != MAP_FAILED)
         return virtual_base;
-    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE,
-                MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
+#endif
+    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }
 
 #endif
@@ -477,19 +490,9 @@ class HostMemory::Impl {
 public:
     explicit Impl(size_t backing_size_, size_t virtual_size_)
         : backing_size{backing_size_}, virtual_size{virtual_size_} {
-        bool good = false;
-        SCOPE_EXIT {
-            if (!good) {
-                Release();
-            }
-        };
-
         long page_size = sysconf(_SC_PAGESIZE);
-        if (page_size != 0x1000) {
-            LOG_CRITICAL(HW_Memory, "page size {:#x} is incompatible with 4K paging", page_size);
-            throw std::bad_alloc{};
-        }
-
+        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging",
+                   page_size);
         // Backing memory initialization
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
         fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
@@ -498,41 +501,33 @@ public:
 #elif defined(__FreeBSD__) && __FreeBSD__ < 13
         // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30
         fd = shm_open(SHM_ANON, O_RDWR, 0600);
+#elif defined(__APPLE__)
+        // macOS doesn't have memfd_create, use anonymous temporary file
+        char template_path[] = "/tmp/eden_mem_XXXXXX";
+        fd = mkstemp(template_path);
+        if (fd >= 0) {
+            unlink(template_path);
+        }
 #else
         fd = memfd_create("HostMemory", 0);
 #endif
-        if (fd < 0) {
-            LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
+        ASSERT_MSG(fd >= 0, "memfd_create failed: {}", strerror(errno));
 
         // Defined to extend the file with zeros
         int ret = ftruncate(fd, backing_size);
-        if (ret != 0) {
-            LOG_CRITICAL(HW_Memory, "ftruncate failed with {}, are you out-of-memory?",
-                         strerror(errno));
-            throw std::bad_alloc{};
-        }
+        ASSERT_MSG(ret == 0, "ftruncate failed with {}, are you out-of-memory?", strerror(errno));
 
         backing_base = static_cast<u8*>(
             mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
-        if (backing_base == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
+        ASSERT_MSG(backing_base != MAP_FAILED, "mmap failed: {}", strerror(errno));
 
         // Virtual memory initialization
         virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
-        if (virtual_base == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
-            throw std::bad_alloc{};
-        }
+        ASSERT_MSG(virtual_base != MAP_FAILED, "mmap failed: {}", strerror(errno));
 #if defined(__linux__)
         madvise(virtual_base, virtual_size, MADV_HUGEPAGE);
 #endif
-
         free_manager.SetAddressSpace(virtual_base, virtual_size);
-        good = true;
     }
 
     ~Impl() {
@@ -669,14 +664,13 @@ private:
     FreeRegionManager free_manager{};
 };
 
-#else // ^^^ Linux ^^^ vvv Generic vvv
+#else // ^^^ POSIX ^^^ vvv Generic vvv
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t /*backing_size */, size_t /* virtual_size */) {
+    explicit Impl([[maybe_unused]] size_t backing_size, [[maybe_unused]] size_t virtual_size) {
         // This is just a place holder.
-        // Please implement fastmem in a proper way on your platform.
-        throw std::bad_alloc{};
+        ASSERT_MSG(false, "Please implement fastmem in a proper way on your platform.");
     }
 
     void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perm) {}

src/common/logging/backend.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -121,7 +124,7 @@ public:
         bytes_written += file->WriteString(message);
 
         // Option to log each line rather than 4k buffers
-        if (Settings::values.log_flush_lines.GetValue()) {
+        if (Settings::values.log_flush_line.GetValue()) {
             file->Flush();
         }
 

src/common/ring_buffer.h

@@ -1,3 +1,5 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,6 +15,7 @@
 #include <span>
 #include <type_traits>
 #include <vector>
+#include <mutex>
 
 namespace Common {
 
@@ -37,10 +40,10 @@ public:
     /// @param slot_count  Number of slots to push
     /// @returns The number of slots actually pushed
     std::size_t Push(const void* new_slots, std::size_t slot_count) {
-        const std::size_t write_index = m_write_index.load();
-        const std::size_t slots_free = capacity + m_read_index.load() - write_index;
-        const std::size_t push_count = std::min(slot_count, slots_free);
+        std::lock_guard lock(rb_mutex);
 
+        const std::size_t slots_free = capacity + read_index - write_index;
+        const std::size_t push_count = std::min(slot_count, slots_free);
         const std::size_t pos = write_index % capacity;
         const std::size_t first_copy = std::min(capacity - pos, push_count);
         const std::size_t second_copy = push_count - first_copy;
@@ -50,8 +53,7 @@ public:
         in += first_copy * slot_size;
         std::memcpy(m_data.data(), in, second_copy * slot_size);
 
-        m_write_index.store(write_index + push_count);
-
+        write_index = write_index + push_count;
         return push_count;
     }
 
@@ -64,10 +66,10 @@ public:
     /// @param max_slots  Maximum number of slots to pop
     /// @returns The number of slots actually popped
     std::size_t Pop(void* output, std::size_t max_slots = ~std::size_t(0)) {
-        const std::size_t read_index = m_read_index.load();
-        const std::size_t slots_filled = m_write_index.load() - read_index;
-        const std::size_t pop_count = std::min(slots_filled, max_slots);
+        std::lock_guard lock(rb_mutex);
 
+        const std::size_t slots_filled = write_index - read_index;
+        const std::size_t pop_count = std::min(slots_filled, max_slots);
         const std::size_t pos = read_index % capacity;
         const std::size_t first_copy = std::min(capacity - pos, pop_count);
         const std::size_t second_copy = pop_count - first_copy;
@@ -77,8 +79,7 @@ public:
         out += first_copy * slot_size;
         std::memcpy(out, m_data.data(), second_copy * slot_size);
 
-        m_read_index.store(read_index + pop_count);
-
+        read_index = read_index + pop_count;
         return pop_count;
     }
 
@@ -90,29 +91,21 @@ public:
     }
 
     /// @returns Number of slots used
-    [[nodiscard]] std::size_t Size() const {
-        return m_write_index.load() - m_read_index.load();
+    [[nodiscard]] inline std::size_t Size() const {
+        return write_index - read_index;
     }
 
     /// @returns Maximum size of ring buffer
-    [[nodiscard]] constexpr std::size_t Capacity() const {
+    [[nodiscard]] consteval std::size_t Capacity() const {
         return capacity;
     }
 
 private:
-    // It is important to align the below variables for performance reasons:
-    // Having them on the same cache-line would result in false-sharing between them.
-    // TODO: Remove this ifdef whenever clang and GCC support
-    //       std::hardware_destructive_interference_size.
-#ifdef __cpp_lib_hardware_interference_size
-    alignas(std::hardware_destructive_interference_size) std::atomic_size_t m_read_index{0};
-    alignas(std::hardware_destructive_interference_size) std::atomic_size_t m_write_index{0};
-#else
-    alignas(128) std::atomic_size_t m_read_index{0};
-    alignas(128) std::atomic_size_t m_write_index{0};
-#endif
-
     std::array<T, capacity> m_data;
+    // This is wrong, a thread-safe ringbuffer is impossible.
+    std::size_t read_index{0};
+    std::size_t write_index{0};
+    std::mutex rb_mutex;
 };
 
 } // namespace Common

src/common/settings.cpp

@@ -158,7 +158,14 @@ bool IsFastmemEnabled() {
     if (values.cpu_debug_mode) {
         return static_cast<bool>(values.cpuopt_fastmem);
     }
+    if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Unsafe) {
+        return static_cast<bool>(values.cpuopt_unsafe_host_mmu);
+    }
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__)
+    return false;
+#else
     return true;
+#endif
 }
 
 static bool is_nce_enabled = false;

src/common/settings.h

@@ -217,7 +217,8 @@ struct Values {
                                              true,
                                              true,
                                              &use_speed_limit};
-    SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core, Specialization::Default};
+    SwitchableSetting<bool> sync_core_speed{linkage, false, "sync_core_speed", Category::Core,
+                                            Specialization::Default};
 
     // Memory
 #ifdef HAS_NCE
@@ -299,6 +300,15 @@ struct Values {
                                               Category::CpuDebug};
     Setting<bool> cpuopt_ignore_memory_aborts{linkage, true, "cpuopt_ignore_memory_aborts",
                                               Category::CpuDebug};
+
+    SwitchableSetting<bool> cpuopt_unsafe_host_mmu{linkage,
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__)
+                                        false,
+#else
+                                        true,
+#endif
+                                        "cpuopt_unsafe_host_mmu",
+                                        Category::CpuUnsafe};
     SwitchableSetting<bool> cpuopt_unsafe_unfuse_fma{linkage, true, "cpuopt_unsafe_unfuse_fma",
                                                      Category::CpuUnsafe};
     SwitchableSetting<bool> cpuopt_unsafe_reduce_fp_error{
@@ -427,7 +437,19 @@ struct Values {
                                                       Specialization::Default,
                                                       true,
                                                       true};
+
     GpuAccuracy current_gpu_accuracy{GpuAccuracy::High};
+
+    SwitchableSetting<DmaAccuracy, true> dma_accuracy{linkage,
+                                                      DmaAccuracy::Default,
+                                                      DmaAccuracy::Default,
+                                                      DmaAccuracy::Extreme,
+                                                      "dma_accuracy",
+                                                      Category::RendererAdvanced,
+                                                      Specialization::Default,
+                                                      true,
+                                                      true};
+
     SwitchableSetting<AnisotropyMode, true> max_anisotropy{linkage,
 #ifdef ANDROID
                                                            AnisotropyMode::Default,
@@ -466,7 +488,13 @@ struct Values {
                                                  true,
                                                  true};
 #endif
-    SwitchableSetting<bool> sync_memory_operations{linkage, false, "sync_memory_operations", Category::RendererAdvanced, true, true};
+    SwitchableSetting<bool> sync_memory_operations{linkage,
+                                                   false,
+                                                   "sync_memory_operations",
+                                                   Category::RendererAdvanced,
+                                                   Specialization::Default,
+                                                   true,
+                                                   true};
     SwitchableSetting<bool> async_presentation{linkage,
 #ifdef ANDROID
                                                true,
@@ -518,7 +546,17 @@ struct Values {
                                                    Category::RendererAdvanced};
 
     SwitchableSetting<u8, true> dyna_state{linkage,
+#if defined (_WIN32)
+                                           3,
+#elif defined (__FreeBSD__)
+                                           3,
+#elif defined (ANDROID)
                                            0,
+#elif defined (__APPLE__)
+                                           0,
+#else
+                                           2,
+#endif
                                            0,
                                            3,
                                            "dyna_state",
@@ -548,8 +586,11 @@ struct Values {
                                                     linkage, false, "disable_shader_loop_safety_checks", Category::RendererDebug};
     Setting<bool> enable_renderdoc_hotkey{linkage, false, "renderdoc_hotkey",
                                           Category::RendererDebug};
-    Setting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
-                                         Category::RendererDebug};
+    SwitchableSetting<bool> disable_buffer_reorder{linkage, false, "disable_buffer_reorder",
+                                         Category::RendererDebug,
+                                         Specialization::Default,
+                                                         true,
+                                                         true};
 
     // System
     SwitchableSetting<Language, true> language_index{linkage,
@@ -584,7 +625,11 @@ struct Values {
                                     linkage, 0,    "rng_seed",       Category::System, Specialization::Hex,
                                     true,    true, &rng_seed_enabled};
     Setting<std::string> device_name{
-                                     linkage, "Eden", "device_name", Category::System, Specialization::Default, true, true};
+        linkage, "Eden", "device_name", Category::System, Specialization::Default, true, true};
+    SwitchableSetting<bool> disable_nca_verification{linkage, true, "disable_nca_verification",
+                                                     Category::System, Specialization::Default};
+    Setting<bool> hide_nca_verification_popup{
+        linkage, false, "hide_nca_verification_popup", Category::System, Specialization::Default};
 
     Setting<s32> current_user{linkage, 0, "current_user", Category::System};
 
@@ -715,7 +760,7 @@ struct Values {
 
     // Miscellaneous
     Setting<std::string> log_filter{linkage, "*:Info", "log_filter", Category::Miscellaneous};
-    Setting<bool> log_flush_lines{linkage, true, "flush_lines", Category::Miscellaneous, Specialization::Default, true, true};
+    Setting<bool> log_flush_line{linkage, false, "flush_line", Category::Miscellaneous, Specialization::Default, true, true};
     Setting<bool> censor_username{linkage, true, "censor_username", Category::Miscellaneous};
     Setting<bool> use_dev_keys{linkage, false, "use_dev_keys", Category::Miscellaneous};
     Setting<bool> first_launch{linkage, true, "first_launch", Category::Miscellaneous};

src/common/settings_enums.h

@@ -136,6 +136,8 @@ ENUM(ShaderBackend, Glsl, Glasm, SpirV);
 
 ENUM(GpuAccuracy, Normal, High, Extreme);
 
+ENUM(DmaAccuracy, Default, Normal, High, Extreme);
+
 ENUM(CpuBackend, Dynarmic, Nce);
 
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);

src/common/string_util.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
@@ -7,6 +10,7 @@
 #include <codecvt>
 #include <locale>
 #include <sstream>
+#include <string_view>
 
 #include "common/string_util.h"
 
@@ -21,51 +25,21 @@
 namespace Common {
 
 /// Make a string lowercase
-std::string ToLower(std::string str) {
+std::string ToLower(const std::string_view sv) {
+    std::string str{sv};
     std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                   [](auto const c) { return char(std::tolower(c)); });
     return str;
 }
 
 /// Make a string uppercase
-std::string ToUpper(std::string str) {
+std::string ToUpper(const std::string_view sv) {
+    std::string str{sv};
     std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+                   [](auto const c) { return char(std::toupper(c)); });
     return str;
 }
 
-std::string StringFromBuffer(std::span<const u8> data) {
-    return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
-}
-
-std::string StringFromBuffer(std::span<const char> data) {
-    return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
-}
-
-// Turns "  hej " into "hej". Also handles tabs.
-std::string StripSpaces(const std::string& str) {
-    const std::size_t s = str.find_first_not_of(" \t\r\n");
-
-    if (str.npos != s)
-        return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1);
-    else
-        return "";
-}
-
-// "\"hello\"" is turned to "hello"
-// This one assumes that the string has already been space stripped in both
-// ends, as done by StripSpaces above, for example.
-std::string StripQuotes(const std::string& s) {
-    if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
-        return s.substr(1, s.size() - 2);
-    else
-        return s;
-}
-
-std::string StringFromBool(bool value) {
-    return value ? "True" : "False";
-}
-
 bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename,
                std::string* _pExtension) {
     if (full_path.empty())

src/common/string_util.h

@@ -1,9 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
 // SPDX-FileCopyrightText: 2014 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #pragma once
 
+#include <algorithm>
 #include <cstddef>
 #include <span>
 #include <string>
@@ -13,18 +17,38 @@
 namespace Common {
 
 /// Make a string lowercase
-[[nodiscard]] std::string ToLower(std::string str);
+[[nodiscard]] std::string ToLower(const std::string_view sv);
 
 /// Make a string uppercase
-[[nodiscard]] std::string ToUpper(std::string str);
+[[nodiscard]] std::string ToUpper(const std::string_view sv);
 
-[[nodiscard]] std::string StringFromBuffer(std::span<const u8> data);
-[[nodiscard]] std::string StringFromBuffer(std::span<const char> data);
+[[nodiscard]] inline std::string StringFromBuffer(std::span<const u8> data) noexcept {
+    return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
+}
+[[nodiscard]] inline std::string StringFromBuffer(std::span<const char> data) noexcept {
+    return std::string(data.begin(), std::find(data.begin(), data.end(), '\0'));
+}
 
-[[nodiscard]] std::string StripSpaces(const std::string& s);
-[[nodiscard]] std::string StripQuotes(const std::string& s);
+/// Turns "  hej " into "hej". Also handles tabs.
+[[nodiscard]] inline std::string StripSpaces(const std::string_view str) noexcept {
+    const std::size_t s = str.find_first_not_of(" \t\r\n");
+    if (str.npos != s)
+        return std::string{str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1)};
+    return {};
+}
 
-[[nodiscard]] std::string StringFromBool(bool value);
+/// "\"hello\"" is turned to "hello"
+/// This one assumes that the string has already been space stripped in both
+/// ends, as done by StripSpaces above, for example.
+[[nodiscard]] inline std::string StripQuotes(const std::string_view s) noexcept {
+    if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
+        return std::string{s.substr(1, s.size() - 2)};
+    return std::string{s};
+}
+
+[[nodiscard]] inline std::string StringFromBool(bool value) noexcept {
+    return value ? "True" : "False";
+}
 
 [[nodiscard]] std::string TabsToSpaces(int tab_size, std::string in);
 
@@ -54,7 +78,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
  * `other` for equality.
  */
 template <typename InIt>
-[[nodiscard]] bool ComparePartialString(InIt begin, InIt end, const char* other) {
+[[nodiscard]] inline bool ComparePartialString(InIt begin, InIt end, const char* other) noexcept {
     for (; begin != end && *other != '\0'; ++begin, ++other) {
         if (*begin != *other) {
             return false;
@@ -64,18 +88,14 @@ template <typename InIt>
     return (begin == end) == (*other == '\0');
 }
 
-/**
- * Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
- * NUL-terminated then the string ends at max_len characters.
- */
+/// Creates a std::string from a fixed-size NUL-terminated char buffer. If the buffer isn't
+/// NUL-terminated then the string ends at max_len characters.
 [[nodiscard]] std::string StringFromFixedZeroTerminatedBuffer(std::string_view buffer,
                                                               std::size_t max_len);
 
-/**
- * Creates a UTF-16 std::u16string from a fixed-size NUL-terminated char buffer. If the buffer isn't
- * null-terminated, then the string ends at the greatest multiple of two less then or equal to
- * max_len_bytes.
- */
+/// Creates a UTF-16 std::u16string from a fixed-size NUL-terminated char buffer. If the buffer isn't
+/// null-terminated, then the string ends at the greatest multiple of two less then or equal to
+/// max_len_bytes.
 [[nodiscard]] std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buffer,
                                                                       std::size_t max_len);
 

src/common/x64/xbyak_abi.h

@@ -47,6 +47,7 @@ constexpr std::bitset<32> BuildRegSet(std::initializer_list<Xbyak::Reg> regs) {
 constexpr inline std::bitset<32> ABI_ALL_GPRS(0x0000FFFF);
 constexpr inline std::bitset<32> ABI_ALL_XMMS(0xFFFF0000);
 
+constexpr inline Xbyak::Reg ABI_JIT_REG = Xbyak::util::rbx;
 #ifdef _WIN32
 
 // Microsoft x64 ABI

src/core/CMakeLists.txt

@@ -88,6 +88,8 @@ add_library(core STATIC
     file_sys/fssystem/fssystem_crypto_configuration.h
     file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp
     file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.h
+    file_sys/fssystem/fssystem_hierarchical_sha3_storage.cpp
+    file_sys/fssystem/fssystem_hierarchical_sha3_storage.h
     file_sys/fssystem/fssystem_hierarchical_sha256_storage.cpp
     file_sys/fssystem/fssystem_hierarchical_sha256_storage.h
     file_sys/fssystem/fssystem_indirect_storage.cpp
@@ -102,6 +104,7 @@ add_library(core STATIC
     file_sys/fssystem/fssystem_nca_header.cpp
     file_sys/fssystem/fssystem_nca_header.h
     file_sys/fssystem/fssystem_nca_reader.cpp
+    file_sys/fssystem/fssystem_passthrough_storage.h
     file_sys/fssystem/fssystem_pooled_buffer.cpp
     file_sys/fssystem/fssystem_pooled_buffer.h
     file_sys/fssystem/fssystem_sparse_storage.cpp
@@ -1251,11 +1254,7 @@ if(ENABLE_OPENSSL)
 
     find_package(OpenSSL REQUIRED)
 
-    if (OpenSSL_ADDED)
-        link_openssl(core)
-    else()
-        target_link_libraries(core PRIVATE OpenSSL::SSL)
-    endif()
+    target_link_libraries(core PRIVATE OpenSSL::SSL OpenSSL::Crypto)
 elseif (APPLE)
     target_sources(core PRIVATE
         hle/service/ssl/ssl_backend_securetransport.cpp)

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -88,7 +88,7 @@ public:
     void InterpreterFallback(u32 pc, std::size_t num_instructions) override {
         m_parent.LogBacktrace(m_process);
         LOG_ERROR(Core_ARM,
-                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                  "Unimplemented instruction @ {:#X} for {} instructions (instr = {:08X})", pc,
                   num_instructions, m_memory.Read32(pc));
     }
 
@@ -175,7 +175,6 @@ public:
     Kernel::KProcess* m_process{};
     const bool m_debugger_enabled{};
     const bool m_check_memory_access{};
-    static constexpr u64 MinimumRunCycles = 10000U;
 };
 
 std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* page_table) const {
@@ -272,6 +271,10 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
         // Unsafe optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Unsafe) {
             config.unsafe_optimizations = true;
+            if (!Settings::values.cpuopt_unsafe_host_mmu) {
+                config.fastmem_pointer = std::nullopt;
+                config.fastmem_exclusive_access = false;
+            }
             if (Settings::values.cpuopt_unsafe_unfuse_fma) {
                 config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
             }
@@ -292,13 +295,17 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
         // Curated optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Auto) {
             config.unsafe_optimizations = true;
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__)
+            config.fastmem_pointer = std::nullopt;
+            config.fastmem_exclusive_access = false;
+#endif
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
         }
 
-        // Paranoia mode for debugging optimizations
+        // Paranoid mode for debugging optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Paranoid) {
             config.unsafe_optimizations = false;
             config.optimizations = Dynarmic::no_optimizations;

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -102,7 +102,7 @@ public:
     void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
         m_parent.LogBacktrace(m_process);
         LOG_ERROR(Core_ARM,
-                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                  "Unimplemented instruction @ {:#X} for {} instructions (instr = {:08X})", pc,
                   num_instructions, m_memory.Read32(pc));
         ReturnException(pc, PrefetchAbort);
     }
@@ -136,6 +136,7 @@ public:
         case Dynarmic::A64::Exception::SendEvent:
         case Dynarmic::A64::Exception::SendEventLocal:
         case Dynarmic::A64::Exception::Yield:
+            LOG_TRACE(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})", static_cast<std::size_t>(exception), pc, m_memory.Read32(pc));
             return;
         case Dynarmic::A64::Exception::NoExecuteFault:
             LOG_CRITICAL(Core_ARM, "Cannot execute instruction at unmapped address {:#016x}", pc);
@@ -144,12 +145,10 @@ public:
         default:
             if (m_debugger_enabled) {
                 ReturnException(pc, InstructionBreakpoint);
-                return;
+            } else {
+                m_parent.LogBacktrace(m_process);
+                LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})", static_cast<std::size_t>(exception), pc, m_memory.Read32(pc));
             }
-
-            m_parent.LogBacktrace(m_process);
-            LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                         static_cast<std::size_t>(exception), pc, m_memory.Read32(pc));
         }
     }
 
@@ -331,6 +330,10 @@ std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* pa
         // Unsafe optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Unsafe) {
             config.unsafe_optimizations = true;
+            if (!Settings::values.cpuopt_unsafe_host_mmu) {
+                config.fastmem_pointer = std::nullopt;
+                config.fastmem_exclusive_access = false;
+            }
             if (Settings::values.cpuopt_unsafe_unfuse_fma) {
                 config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
             }
@@ -351,6 +354,10 @@ std::shared_ptr<Dynarmic::A64::Jit> ArmDynarmic64::MakeJit(Common::PageTable* pa
         // Curated optimizations
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CpuAccuracy::Auto) {
             config.unsafe_optimizations = true;
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__)
+            config.fastmem_pointer = std::nullopt;
+            config.fastmem_exclusive_access = false;
+#endif
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
             config.fastmem_address_space_bits = 64;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;

src/core/debugger/gdbstub.cpp

@@ -554,32 +554,31 @@ void GDBStub::HandleVCont(std::string_view command, std::vector<DebuggerAction>&
     }
 }
 
-constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
-    {"----- Free ------", Kernel::Svc::MemoryState::Free},
-    {"Io               ", Kernel::Svc::MemoryState::Io},
-    {"Static           ", Kernel::Svc::MemoryState::Static},
-    {"Code             ", Kernel::Svc::MemoryState::Code},
-    {"CodeData         ", Kernel::Svc::MemoryState::CodeData},
-    {"Normal           ", Kernel::Svc::MemoryState::Normal},
-    {"Shared           ", Kernel::Svc::MemoryState::Shared},
-    {"AliasCode        ", Kernel::Svc::MemoryState::AliasCode},
-    {"AliasCodeData    ", Kernel::Svc::MemoryState::AliasCodeData},
-    {"Ipc              ", Kernel::Svc::MemoryState::Ipc},
-    {"Stack            ", Kernel::Svc::MemoryState::Stack},
-    {"ThreadLocal      ", Kernel::Svc::MemoryState::ThreadLocal},
-    {"Transferred      ", Kernel::Svc::MemoryState::Transferred},
-    {"SharedTransferred", Kernel::Svc::MemoryState::SharedTransferred},
-    {"SharedCode       ", Kernel::Svc::MemoryState::SharedCode},
-    {"Inaccessible     ", Kernel::Svc::MemoryState::Inaccessible},
-    {"NonSecureIpc     ", Kernel::Svc::MemoryState::NonSecureIpc},
-    {"NonDeviceIpc     ", Kernel::Svc::MemoryState::NonDeviceIpc},
-    {"Kernel           ", Kernel::Svc::MemoryState::Kernel},
-    {"GeneratedCode    ", Kernel::Svc::MemoryState::GeneratedCode},
-    {"CodeOut          ", Kernel::Svc::MemoryState::CodeOut},
-    {"Coverage         ", Kernel::Svc::MemoryState::Coverage},
-}};
-
 static constexpr const char* GetMemoryStateName(Kernel::Svc::MemoryState state) {
+    constexpr std::array<std::pair<const char*, Kernel::Svc::MemoryState>, 22> MemoryStateNames{{
+        {"----- Free ------", Kernel::Svc::MemoryState::Free},
+        {"Io               ", Kernel::Svc::MemoryState::Io},
+        {"Static           ", Kernel::Svc::MemoryState::Static},
+        {"Code             ", Kernel::Svc::MemoryState::Code},
+        {"CodeData         ", Kernel::Svc::MemoryState::CodeData},
+        {"Normal           ", Kernel::Svc::MemoryState::Normal},
+        {"Shared           ", Kernel::Svc::MemoryState::Shared},
+        {"AliasCode        ", Kernel::Svc::MemoryState::AliasCode},
+        {"AliasCodeData    ", Kernel::Svc::MemoryState::AliasCodeData},
+        {"Ipc              ", Kernel::Svc::MemoryState::Ipc},
+        {"Stack            ", Kernel::Svc::MemoryState::Stack},
+        {"ThreadLocal      ", Kernel::Svc::MemoryState::ThreadLocal},
+        {"Transferred      ", Kernel::Svc::MemoryState::Transferred},
+        {"SharedTransferred", Kernel::Svc::MemoryState::SharedTransferred},
+        {"SharedCode       ", Kernel::Svc::MemoryState::SharedCode},
+        {"Inaccessible     ", Kernel::Svc::MemoryState::Inaccessible},
+        {"NonSecureIpc     ", Kernel::Svc::MemoryState::NonSecureIpc},
+        {"NonDeviceIpc     ", Kernel::Svc::MemoryState::NonDeviceIpc},
+        {"Kernel           ", Kernel::Svc::MemoryState::Kernel},
+        {"GeneratedCode    ", Kernel::Svc::MemoryState::GeneratedCode},
+        {"CodeOut          ", Kernel::Svc::MemoryState::CodeOut},
+        {"Coverage         ", Kernel::Svc::MemoryState::Coverage},
+    }};
     for (size_t i = 0; i < MemoryStateNames.size(); i++) {
         if (std::get<1>(MemoryStateNames[i]) == state) {
             return std::get<0>(MemoryStateNames[i]);
@@ -611,13 +610,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 
     auto* process = GetProcess();
     auto& page_table = process->GetPageTable();
-
-    const char* commands = "Commands:\n"
-                           "  get fastmem\n"
-                           "  get info\n"
-                           "  get mappings\n";
-
-    if (command_str == "get fastmem") {
+    if (command_str == "fastmem" || command_str == "get fastmem") {
         if (Settings::IsFastmemEnabled()) {
             const auto& impl = page_table.GetImpl();
             const auto region = reinterpret_cast<uintptr_t>(impl.fastmem_arena);
@@ -630,7 +623,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
         } else {
             reply = "Fastmem is not enabled.\n";
         }
-    } else if (command_str == "get info") {
+    } else if (command_str == "info" || command_str == "get info") {
         auto modules = Core::FindModules(process);
 
         reply = fmt::format("Process:     {:#x} ({})\n"
@@ -648,8 +641,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
             GetInteger(page_table.GetHeapRegionStart()),
             GetInteger(page_table.GetHeapRegionStart()) + page_table.GetHeapRegionSize() - 1,
             GetInteger(page_table.GetAliasCodeRegionStart()),
-            GetInteger(page_table.GetAliasCodeRegionStart()) + page_table.GetAliasCodeRegionSize() -
-                1,
+            GetInteger(page_table.GetAliasCodeRegionStart()) + page_table.GetAliasCodeRegionSize() - 1,
             GetInteger(page_table.GetStackRegionStart()),
             GetInteger(page_table.GetStackRegionStart()) + page_table.GetStackRegionSize() - 1);
 
@@ -657,7 +649,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
             reply += fmt::format("  {:#012x} - {:#012x} {}\n", vaddr,
                                  GetInteger(Core::GetModuleEnd(process, vaddr)), name);
         }
-    } else if (command_str == "get mappings") {
+    } else if (command_str == "mappings" || command_str == "get mappings") {
         reply = "Mappings:\n";
         VAddr cur_addr = 0;
 
@@ -675,15 +667,11 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
                     std::numeric_limits<u64>::max()) {
                 const char* state = GetMemoryStateName(svc_mem_info.state);
                 const char* perm = GetMemoryPermissionString(svc_mem_info);
-
                 const char l = True(svc_mem_info.attribute & MemoryAttribute::Locked) ? 'L' : '-';
-                const char i =
-                    True(svc_mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
-                const char d =
-                    True(svc_mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
+                const char i = True(svc_mem_info.attribute & MemoryAttribute::IpcLocked) ? 'I' : '-';
+                const char d = True(svc_mem_info.attribute & MemoryAttribute::DeviceShared) ? 'D' : '-';
                 const char u = True(svc_mem_info.attribute & MemoryAttribute::Uncached) ? 'U' : '-';
-                const char p =
-                    True(svc_mem_info.attribute & MemoryAttribute::PermissionLocked) ? 'P' : '-';
+                const char p =True(svc_mem_info.attribute & MemoryAttribute::PermissionLocked) ? 'P' : '-';
 
                 reply += fmt::format(
                     "  {:#012x} - {:#012x} {} {} {}{}{}{}{} [{}, {}]\n", svc_mem_info.base_address,
@@ -698,11 +686,8 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 
             cur_addr = next_address;
         }
-    } else if (command_str == "help") {
-        reply = commands;
     } else {
-        reply = "Unknown command.\n";
-        reply += commands;
+        reply += "Commands: fastmem, info, mappings\n";
     }
 
     std::span<const u8> reply_span{reinterpret_cast<u8*>(&reply.front()), reply.size()};

src/core/file_sys/fssystem/fssystem_bucket_tree.cpp

@@ -1,6 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
+#include "common/settings.h"
 #include "core/file_sys/errors.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree.h"
 #include "core/file_sys/fssystem/fssystem_bucket_tree_utils.h"
@@ -233,7 +237,10 @@ Result BucketTree::Initialize(VirtualFile node_storage, VirtualFile entry_storag
 void BucketTree::Initialize(size_t node_size, s64 end_offset) {
     ASSERT(NodeSizeMin <= node_size && node_size <= NodeSizeMax);
     ASSERT(Common::IsPowerOfTwo(node_size));
-    ASSERT(end_offset > 0);
+
+    if (!Settings::values.disable_nca_verification.GetValue()) {
+        ASSERT(end_offset > 0);
+    }
     ASSERT(!this->IsInitialized());
 
     m_node_size = node_size;

src/core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.cpp

@@ -5,23 +5,10 @@
 #include "common/scope_exit.h"
 #include "core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h"
 
+#include <cmath>
+
 namespace FileSys {
 
-namespace {
-
-s32 Log2(s32 value) {
-    ASSERT(value > 0);
-    ASSERT(Common::IsPowerOfTwo(value));
-
-    s32 log = 0;
-    while ((value >>= 1) > 0) {
-        ++log;
-    }
-    return log;
-}
-
-} // namespace
-
 Result HierarchicalSha256Storage::Initialize(VirtualFile* base_storages, s32 layer_count,
                                              size_t htbs, void* hash_buf, size_t hash_buf_size) {
     // Validate preconditions.
@@ -31,7 +18,8 @@ Result HierarchicalSha256Storage::Initialize(VirtualFile* base_storages, s32 lay
 
     // Set size tracking members.
     m_hash_target_block_size = static_cast<s32>(htbs);
-    m_log_size_ratio = Log2(m_hash_target_block_size / HashSize);
+    m_log_size_ratio =
+        static_cast<s32>(std::log2(static_cast<double>(m_hash_target_block_size) / HashSize));
 
     // Get the base storage size.
     m_base_storage_size = base_storages[2]->GetSize();

src/core/file_sys/fssystem/fssystem_hierarchical_sha3_storage.cpp

@@ -0,0 +1,57 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/alignment.h"
+#include "common/scope_exit.h"
+#include "core/file_sys/fssystem/fssystem_hierarchical_sha3_storage.h"
+
+#include <cmath>
+
+namespace FileSys {
+
+Result HierarchicalSha3Storage::Initialize(VirtualFile* base_storages, s32 layer_count, size_t htbs,
+                                           void* hash_buf, size_t hash_buf_size) {
+    ASSERT(layer_count == LayerCount);
+    ASSERT(Common::IsPowerOfTwo(htbs));
+    ASSERT(hash_buf != nullptr);
+
+    m_hash_target_block_size = static_cast<s32>(htbs);
+    m_log_size_ratio =
+        static_cast<s32>(std::log2(static_cast<double>(m_hash_target_block_size) / HashSize));
+
+    m_base_storage_size = base_storages[2]->GetSize();
+    {
+        auto size_guard = SCOPE_GUARD {
+            m_base_storage_size = 0;
+        };
+        R_UNLESS(m_base_storage_size <= static_cast<s64>(HashSize)
+                                            << m_log_size_ratio << m_log_size_ratio,
+                 ResultHierarchicalSha256BaseStorageTooLarge);
+        size_guard.Cancel();
+    }
+
+    m_base_storage = base_storages[2];
+    m_hash_buffer = static_cast<char*>(hash_buf);
+    m_hash_buffer_size = hash_buf_size;
+
+    std::array<u8, HashSize> master_hash{};
+    base_storages[0]->ReadObject(std::addressof(master_hash));
+
+    s64 hash_storage_size = base_storages[1]->GetSize();
+    ASSERT(Common::IsAligned(hash_storage_size, HashSize));
+    ASSERT(hash_storage_size <= m_hash_target_block_size);
+    ASSERT(hash_storage_size <= static_cast<s64>(m_hash_buffer_size));
+
+    base_storages[1]->Read(reinterpret_cast<u8*>(m_hash_buffer),
+                           static_cast<size_t>(hash_storage_size), 0);
+    R_SUCCEED();
+}
+
+size_t HierarchicalSha3Storage::Read(u8* buffer, size_t size, size_t offset) const {
+    if (size == 0)
+        return size;
+    ASSERT(buffer != nullptr);
+    return m_base_storage->Read(buffer, size, offset);
+}
+
+} // namespace FileSys

src/core/file_sys/fssystem/fssystem_hierarchical_sha3_storage.h

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <mutex>
+
+#include "core/file_sys/errors.h"
+#include "core/file_sys/fssystem/fs_i_storage.h"
+#include "core/file_sys/vfs/vfs.h"
+
+namespace FileSys {
+
+class HierarchicalSha3Storage : public IReadOnlyStorage {
+    YUZU_NON_COPYABLE(HierarchicalSha3Storage);
+    YUZU_NON_MOVEABLE(HierarchicalSha3Storage);
+
+public:
+    static constexpr s32 LayerCount = 3;
+    static constexpr size_t HashSize = 256 / 8; // SHA3-256
+
+public:
+    HierarchicalSha3Storage() : m_mutex() {}
+
+    Result Initialize(VirtualFile* base_storages, s32 layer_count, size_t htbs, void* hash_buf,
+                      size_t hash_buf_size);
+
+    virtual size_t GetSize() const override {
+        return m_base_storage->GetSize();
+    }
+
+    virtual size_t Read(u8* buffer, size_t length, size_t offset) const override;
+
+private:
+    VirtualFile m_base_storage;
+    s64 m_base_storage_size{};
+    char* m_hash_buffer{};
+    size_t m_hash_buffer_size{};
+    s32 m_hash_target_block_size{};
+    s32 m_log_size_ratio{};
+    std::mutex m_mutex;
+};
+
+} // namespace FileSys

src/core/file_sys/fssystem/fssystem_nca_file_system_driver.cpp

@@ -1,6 +1,10 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
+#include "common/settings.h"
 #include "core/file_sys/fssystem/fssystem_aes_ctr_counter_extended_storage.h"
 #include "core/file_sys/fssystem/fssystem_aes_ctr_storage.h"
 #include "core/file_sys/fssystem/fssystem_aes_xts_storage.h"
@@ -10,10 +14,12 @@
 #include "core/file_sys/fssystem/fssystem_hierarchical_sha256_storage.h"
 #include "core/file_sys/fssystem/fssystem_indirect_storage.h"
 #include "core/file_sys/fssystem/fssystem_integrity_romfs_storage.h"
+#include "core/file_sys/fssystem/fssystem_passthrough_storage.h"
 #include "core/file_sys/fssystem/fssystem_memory_resource_buffer_hold_storage.h"
 #include "core/file_sys/fssystem/fssystem_nca_file_system_driver.h"
 #include "core/file_sys/fssystem/fssystem_sparse_storage.h"
 #include "core/file_sys/fssystem/fssystem_switch_storage.h"
+#include "core/file_sys/fssystem/fssystem_hierarchical_sha3_storage.h"
 #include "core/file_sys/vfs/vfs_offset.h"
 #include "core/file_sys/vfs/vfs_vector.h"
 
@@ -299,18 +305,24 @@ Result NcaFileSystemDriver::CreateStorageByRawStorage(VirtualFile* out,
     // Process hash/integrity layer.
     switch (header_reader->GetHashType()) {
     case NcaFsHeader::HashType::HierarchicalSha256Hash:
-        R_TRY(this->CreateSha256Storage(std::addressof(storage), std::move(storage),
-                                        header_reader->GetHashData().hierarchical_sha256_data));
+        R_TRY(CreateSha256Storage(&storage, std::move(storage),
+                                  header_reader->GetHashData().hierarchical_sha256_data));
         break;
     case NcaFsHeader::HashType::HierarchicalIntegrityHash:
-        R_TRY(this->CreateIntegrityVerificationStorage(
-            std::addressof(storage), std::move(storage),
-            header_reader->GetHashData().integrity_meta_info));
+        R_TRY(CreateIntegrityVerificationStorage(&storage, std::move(storage),
+                                                 header_reader->GetHashData().integrity_meta_info));
+        break;
+    case NcaFsHeader::HashType::HierarchicalSha3256Hash:
+        R_TRY(CreateSha3Storage(&storage, std::move(storage),
+                                header_reader->GetHashData().hierarchical_sha256_data));
         break;
     default:
+        LOG_ERROR(Loader, "Unhandled Fs HashType enum={}",
+                  static_cast<int>(header_reader->GetHashType()));
         R_THROW(ResultInvalidNcaFsHeaderHashType);
     }
 
+
     // Process compression layer.
     if (header_reader->ExistsCompressionLayer()) {
         R_TRY(this->CreateCompressedStorage(
@@ -679,6 +691,7 @@ Result NcaFileSystemDriver::CreateSparseStorageMetaStorageWithVerification(
 
     // Create the verification storage.
     VirtualFile integrity_storage;
+
     Result rc = this->CreateIntegrityVerificationStorageForMeta(
         std::addressof(integrity_storage), out_layer_info_storage, std::move(decrypted_storage),
         meta_offset, meta_data_hash_data_info);
@@ -734,8 +747,26 @@ Result NcaFileSystemDriver::CreateSparseStorageWithVerification(
                                  NcaHeader::CtrBlockSize)));
 
         // Check the meta data hash type.
-        R_UNLESS(meta_data_hash_type == NcaFsHeader::MetaDataHashType::HierarchicalIntegrity,
-                 ResultRomNcaInvalidSparseMetaDataHashType);
+        if (meta_data_hash_type != NcaFsHeader::MetaDataHashType::HierarchicalIntegrity) {
+            LOG_ERROR(Loader, "Sparse meta hash type {} not supported for verification; mounting sparse data WITHOUT verification (temporary).", static_cast<int>(meta_data_hash_type));
+
+            R_TRY(this->CreateBodySubStorage(std::addressof(body_substorage),
+                                             sparse_info.physical_offset,
+                                             sparse_info.GetPhysicalSize()));
+
+            // Create sparse core directly (no meta verification)
+            std::shared_ptr<SparseStorage> sparse_storage_fallback;
+            R_TRY(this->CreateSparseStorageCore(std::addressof(sparse_storage_fallback),
+                                                body_substorage, sparse_info.GetPhysicalSize(),
+                                                /*meta_storage*/ body_substorage, // dummy; not used
+                                                sparse_info, false));
+
+            if (out_sparse_storage)
+                *out_sparse_storage = sparse_storage_fallback;
+            *out_fs_data_offset = fs_offset;
+            *out = std::move(sparse_storage_fallback);
+            R_SUCCEED();
+        }
 
         // Create the meta storage.
         VirtualFile meta_storage;
@@ -1093,6 +1124,56 @@ Result NcaFileSystemDriver::CreatePatchMetaStorage(
     R_SUCCEED();
 }
 
+Result NcaFileSystemDriver::CreateSha3Storage(
+    VirtualFile* out, VirtualFile base_storage,
+    const NcaFsHeader::HashData::HierarchicalSha256Data& hash_data) {
+    ASSERT(out != nullptr);
+    ASSERT(base_storage != nullptr);
+
+    using VerificationStorage = HierarchicalSha3Storage;
+
+    R_UNLESS(Common::IsPowerOfTwo(hash_data.hash_block_size),
+             ResultInvalidHierarchicalSha256BlockSize);
+    R_UNLESS(hash_data.hash_layer_count == VerificationStorage::LayerCount - 1,
+             ResultInvalidHierarchicalSha256LayerCount);
+
+    const auto& hash_region = hash_data.hash_layer_region[0];
+    const auto& data_region = hash_data.hash_layer_region[1];
+
+    constexpr s32 CacheBlockCount = 2;
+    const auto hash_buffer_size = static_cast<size_t>(hash_region.size);
+    const auto cache_buffer_size = CacheBlockCount * hash_data.hash_block_size;
+    const auto total_buffer_size = hash_buffer_size + cache_buffer_size;
+
+    auto buffer_hold_storage = std::make_shared<MemoryResourceBufferHoldStorage>(
+        std::move(base_storage), total_buffer_size);
+    R_UNLESS(buffer_hold_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
+    R_UNLESS(buffer_hold_storage->IsValid(), ResultAllocationMemoryFailedInNcaFileSystemDriverI);
+
+    s64 base_size = buffer_hold_storage->GetSize();
+    R_UNLESS(hash_region.offset + hash_region.size <= base_size, ResultNcaBaseStorageOutOfRangeC);
+    R_UNLESS(data_region.offset + data_region.size <= base_size, ResultNcaBaseStorageOutOfRangeC);
+
+    auto master_hash_storage =
+        std::make_shared<ArrayVfsFile<sizeof(Hash)>>(hash_data.fs_data_master_hash.value);
+
+    auto verification_storage = std::make_shared<VerificationStorage>();
+    R_UNLESS(verification_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
+
+    std::array<VirtualFile, VerificationStorage::LayerCount> layer_storages{
+        std::make_shared<OffsetVfsFile>(master_hash_storage, sizeof(Hash), 0),
+        std::make_shared<OffsetVfsFile>(buffer_hold_storage, hash_region.size, hash_region.offset),
+        std::make_shared<OffsetVfsFile>(buffer_hold_storage, data_region.size, data_region.offset),
+    };
+
+    R_TRY(verification_storage->Initialize(layer_storages.data(), VerificationStorage::LayerCount,
+                                           hash_data.hash_block_size,
+                                           buffer_hold_storage->GetBuffer(), hash_buffer_size));
+
+    *out = std::move(verification_storage);
+    R_SUCCEED();
+}
+
 Result NcaFileSystemDriver::CreateSha256Storage(
     VirtualFile* out, VirtualFile base_storage,
     const NcaFsHeader::HashData::HierarchicalSha256Data& hash_data) {
@@ -1160,6 +1241,7 @@ Result NcaFileSystemDriver::CreateSha256Storage(
 Result NcaFileSystemDriver::CreateIntegrityVerificationStorage(
     VirtualFile* out, VirtualFile base_storage,
     const NcaFsHeader::HashData::IntegrityMetaInfo& meta_info) {
+
     R_RETURN(this->CreateIntegrityVerificationStorageImpl(
         out, base_storage, meta_info, 0, IntegrityDataCacheCount, IntegrityHashCacheCount,
         HierarchicalIntegrityVerificationStorage::GetDefaultDataCacheBufferLevel(
@@ -1209,63 +1291,96 @@ Result NcaFileSystemDriver::CreateIntegrityVerificationStorageImpl(
     VirtualFile* out, VirtualFile base_storage,
     const NcaFsHeader::HashData::IntegrityMetaInfo& meta_info, s64 layer_info_offset,
     int max_data_cache_entries, int max_hash_cache_entries, s8 buffer_level) {
-    // Validate preconditions.
+    // Preconditions
     ASSERT(out != nullptr);
     ASSERT(base_storage != nullptr);
     ASSERT(layer_info_offset >= 0);
 
-    // Define storage types.
-    using VerificationStorage = HierarchicalIntegrityVerificationStorage;
-    using StorageInfo = VerificationStorage::HierarchicalStorageInformation;
+    if (!Settings::values.disable_nca_verification.GetValue()) {
+        // Define storage types.
+        using VerificationStorage = HierarchicalIntegrityVerificationStorage;
+        using StorageInfo = VerificationStorage::HierarchicalStorageInformation;
 
-    // Validate the meta info.
-    HierarchicalIntegrityVerificationInformation level_hash_info;
-    std::memcpy(std::addressof(level_hash_info), std::addressof(meta_info.level_hash_info),
-                sizeof(level_hash_info));
+        // Validate the meta info.
+        HierarchicalIntegrityVerificationInformation level_hash_info;
+        std::memcpy(std::addressof(level_hash_info), std::addressof(meta_info.level_hash_info),
+                    sizeof(level_hash_info));
 
-    R_UNLESS(IntegrityMinLayerCount <= level_hash_info.max_layers,
-             ResultInvalidNcaHierarchicalIntegrityVerificationLayerCount);
-    R_UNLESS(level_hash_info.max_layers <= IntegrityMaxLayerCount,
-             ResultInvalidNcaHierarchicalIntegrityVerificationLayerCount);
+        R_UNLESS(IntegrityMinLayerCount <= level_hash_info.max_layers,
+                 ResultInvalidNcaHierarchicalIntegrityVerificationLayerCount);
+        R_UNLESS(level_hash_info.max_layers <= IntegrityMaxLayerCount,
+                 ResultInvalidNcaHierarchicalIntegrityVerificationLayerCount);
 
-    // Get the base storage size.
-    s64 base_storage_size = base_storage->GetSize();
+        // Get the base storage size.
+        s64 base_storage_size = base_storage->GetSize();
 
-    // Create storage info.
-    StorageInfo storage_info;
-    for (s32 i = 0; i < static_cast<s32>(level_hash_info.max_layers - 2); ++i) {
-        const auto& layer_info = level_hash_info.info[i];
-        R_UNLESS(layer_info_offset + layer_info.offset + layer_info.size <= base_storage_size,
+        // Create storage info.
+        StorageInfo storage_info;
+        for (s32 i = 0; i < static_cast<s32>(level_hash_info.max_layers - 2); ++i) {
+            const auto& layer_info = level_hash_info.info[i];
+            R_UNLESS(layer_info_offset + layer_info.offset + layer_info.size <= base_storage_size,
+                     ResultNcaBaseStorageOutOfRangeD);
+
+            storage_info[i + 1] = std::make_shared<OffsetVfsFile>(
+                base_storage, layer_info.size, layer_info_offset + layer_info.offset);
+        }
+
+        // Set the last layer info.
+        const auto& layer_info = level_hash_info.info[level_hash_info.max_layers - 2];
+        const s64 last_layer_info_offset = layer_info_offset > 0 ? 0LL : layer_info.offset.Get();
+        R_UNLESS(last_layer_info_offset + layer_info.size <= base_storage_size,
                  ResultNcaBaseStorageOutOfRangeD);
+        if (layer_info_offset > 0) {
+            R_UNLESS(last_layer_info_offset + layer_info.size <= layer_info_offset,
+                     ResultRomNcaInvalidIntegrityLayerInfoOffset);
+        }
+        storage_info.SetDataStorage(std::make_shared<OffsetVfsFile>(
+            std::move(base_storage), layer_info.size, last_layer_info_offset));
 
-        storage_info[i + 1] = std::make_shared<OffsetVfsFile>(
-            base_storage, layer_info.size, layer_info_offset + layer_info.offset);
+        // Make the integrity romfs storage.
+        auto integrity_storage = std::make_shared<IntegrityRomFsStorage>();
+        R_UNLESS(integrity_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
+
+        // Initialize the integrity storage.
+        R_TRY(integrity_storage->Initialize(level_hash_info, meta_info.master_hash, storage_info,
+                                            max_data_cache_entries, max_hash_cache_entries,
+                                            buffer_level));
+
+        // Set the output.
+        *out = std::move(integrity_storage);
+        R_SUCCEED();
+    } else {
+        // Read IVFC layout
+        HierarchicalIntegrityVerificationInformation lhi{};
+        std::memcpy(std::addressof(lhi), std::addressof(meta_info.level_hash_info), sizeof(lhi));
+
+        R_UNLESS(IntegrityMinLayerCount <= lhi.max_layers,
+                 ResultInvalidNcaHierarchicalIntegrityVerificationLayerCount);
+        R_UNLESS(lhi.max_layers <= IntegrityMaxLayerCount,
+                 ResultInvalidNcaHierarchicalIntegrityVerificationLayerCount);
+
+        const auto& data_li = lhi.info[lhi.max_layers - 2];
+
+        const s64 base_size = base_storage->GetSize();
+
+        // Compute the data layer window
+        const s64 data_off = (layer_info_offset > 0) ? 0LL : data_li.offset.Get();
+        R_UNLESS(data_off + data_li.size <= base_size, ResultNcaBaseStorageOutOfRangeD);
+        if (layer_info_offset > 0) {
+            R_UNLESS(data_off + data_li.size <= layer_info_offset,
+                     ResultRomNcaInvalidIntegrityLayerInfoOffset);
+        }
+
+        // TODO: Passthrough (temporary compatibility: integrity disabled)
+        auto data_view = std::make_shared<OffsetVfsFile>(base_storage, data_li.size, data_off);
+        R_UNLESS(data_view != nullptr, ResultAllocationMemoryFailedAllocateShared);
+
+        auto passthrough = std::make_shared<PassthroughStorage>(std::move(data_view));
+        R_UNLESS(passthrough != nullptr, ResultAllocationMemoryFailedAllocateShared);
+
+        *out = std::move(passthrough);
+        R_SUCCEED();
     }
-
-    // Set the last layer info.
-    const auto& layer_info = level_hash_info.info[level_hash_info.max_layers - 2];
-    const s64 last_layer_info_offset = layer_info_offset > 0 ? 0LL : layer_info.offset.Get();
-    R_UNLESS(last_layer_info_offset + layer_info.size <= base_storage_size,
-             ResultNcaBaseStorageOutOfRangeD);
-    if (layer_info_offset > 0) {
-        R_UNLESS(last_layer_info_offset + layer_info.size <= layer_info_offset,
-                 ResultRomNcaInvalidIntegrityLayerInfoOffset);
-    }
-    storage_info.SetDataStorage(std::make_shared<OffsetVfsFile>(
-        std::move(base_storage), layer_info.size, last_layer_info_offset));
-
-    // Make the integrity romfs storage.
-    auto integrity_storage = std::make_shared<IntegrityRomFsStorage>();
-    R_UNLESS(integrity_storage != nullptr, ResultAllocationMemoryFailedAllocateShared);
-
-    // Initialize the integrity storage.
-    R_TRY(integrity_storage->Initialize(level_hash_info, meta_info.master_hash, storage_info,
-                                        max_data_cache_entries, max_hash_cache_entries,
-                                        buffer_level));
-
-    // Set the output.
-    *out = std::move(integrity_storage);
-    R_SUCCEED();
 }
 
 Result NcaFileSystemDriver::CreateRegionSwitchStorage(VirtualFile* out,

src/core/file_sys/fssystem/fssystem_nca_file_system_driver.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -329,6 +332,10 @@ private:
                                   const NcaPatchInfo& patch_info,
                                   const NcaMetaDataHashDataInfo& meta_data_hash_data_info);
 
+
+    Result CreateSha3Storage(VirtualFile* out, VirtualFile base_storage,
+                             const NcaFsHeader::HashData::HierarchicalSha256Data& hash_data);
+
     Result CreateSha256Storage(VirtualFile* out, VirtualFile base_storage,
                                const NcaFsHeader::HashData::HierarchicalSha256Data& sha256_data);
 

src/core/file_sys/fssystem/fssystem_nca_header.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 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
 
@@ -10,11 +13,13 @@ u8 NcaHeader::GetProperKeyGeneration() const {
 }
 
 bool NcaPatchInfo::HasIndirectTable() const {
-    return this->indirect_size != 0;
+    static constexpr unsigned char BKTR[4] = {'B', 'K', 'T', 'R'};
+    return std::memcmp(indirect_header.data(), BKTR, sizeof(BKTR)) == 0;
 }
 
 bool NcaPatchInfo::HasAesCtrExTable() const {
-    return this->aes_ctr_ex_size != 0;
+    static constexpr unsigned char BKTR[4] = {'B', 'K', 'T', 'R'};
+    return std::memcmp(aes_ctr_ex_header.data(), BKTR, sizeof(BKTR)) == 0;
 }
 
 } // namespace FileSys

src/core/file_sys/fssystem/fssystem_passthrough_storage.h

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+#include "core/file_sys/fssystem/fs_i_storage.h"
+#include "core/file_sys/vfs/vfs.h"
+
+namespace FileSys {
+
+//TODO: No integrity verification.
+class PassthroughStorage final : public IReadOnlyStorage {
+    YUZU_NON_COPYABLE(PassthroughStorage);
+    YUZU_NON_MOVEABLE(PassthroughStorage);
+
+public:
+    explicit PassthroughStorage(VirtualFile base) : base_(std::move(base)) {}
+    ~PassthroughStorage() override = default;
+
+    size_t Read(u8* buffer, size_t size, size_t offset) const override {
+        if (!base_ || size == 0)
+            return 0;
+        return base_->Read(buffer, size, offset);
+    }
+    size_t GetSize() const override {
+        return base_ ? base_->GetSize() : 0;
+    }
+
+private:
+    VirtualFile base_{};
+};
+
+} // namespace FileSys

src/core/file_sys/program_metadata.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -180,7 +183,7 @@ void ProgramMetadata::Print() const {
     LOG_DEBUG(Service_FS, "Magic:                  {:.4}", npdm_header.magic.data());
     LOG_DEBUG(Service_FS, "Main thread priority:   0x{:02X}", npdm_header.main_thread_priority);
     LOG_DEBUG(Service_FS, "Main thread core:       {}", npdm_header.main_thread_cpu);
-    LOG_DEBUG(Service_FS, "Main thread stack size: 0x{:X} bytes", npdm_header.main_stack_size);
+    LOG_DEBUG(Service_FS, "Main thread stack size: {:#X} bytes", npdm_header.main_stack_size);
     LOG_DEBUG(Service_FS, "Process category:       {}", npdm_header.process_category);
     LOG_DEBUG(Service_FS, "Flags:                  0x{:02X}", npdm_header.flags);
     LOG_DEBUG(Service_FS, " > 64-bit instructions: {}",

src/core/file_sys/xts_archive.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -56,8 +59,8 @@ NAX::NAX(VirtualFile file_)
         return;
     }
 
-    const std::string two_dir = Common::ToUpper(match[1]);
-    const std::string nca_id = Common::ToLower(match[2]);
+    const std::string two_dir = Common::ToUpper(std::string{match[1]});
+    const std::string nca_id = Common::ToLower(std::string{match[2]});
     status = Parse(fmt::format("/registered/{}/{}.nca", two_dir, nca_id));
 }
 

src/core/hardware_properties.h

@@ -15,7 +15,7 @@ namespace Hardware {
 
 constexpr u64 BASE_CLOCK_RATE = 1'020'000'000; // Default CPU Frequency = 1020 MHz
 constexpr u64 CNTFREQ = 19'200'000;            // CNTPCT_EL0 Frequency = 19.2 MHz
-constexpr u32 NUM_CPU_CORES = 4;               // Number of CPU Cores
+constexpr u32 NUM_CPU_CORES = 4;               // Number of CPU Cores - sync with dynarmic exclusive_monitor.h
 
 // Virtual to Physical core map.
 constexpr std::array<s32, Common::BitSize<u64>()> VirtualToPhysicalCoreMap{