diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml
index ab91aca242..467849f761 100644
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -68,13 +68,18 @@ body:
     required: true
 
 - type: dropdown
-  id: game-region
+  id: game-disc
   attributes:
-    label: Game Region
-    description: The game region you are playing on
+    label: Game Disc
+    description: The game disc you are playing on
     options:
-    - NTSC-U (North America)
-    - PAL (Europe)
+    - GameCube NTSC-U (North America)
+    - GameCube PAL (Europe)
+    - GameCube NTSC-J (Japan)
+    - Wii NTSC-U (North America) Revision 0
+    - Wii NTSC-U (North America) Revision 2
+    - Wii PAL (Europe)
+    - Wii NTSC-J (Japan)
   validations:
     required: true
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 80257624c5..41758382cc 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -76,10 +76,11 @@ jobs:
       - name: Upload artifacts
         uses: actions/upload-artifact@v7
         with:
-          name: dusklight-${{env.DUSK_VERSION}}-linux-${{matrix.preset}}-${{matrix.artifact_arch}}
+          name: dusklight-${{env.APP_VERSION}}-linux-${{matrix.preset}}-${{matrix.artifact_arch}}
           path: |
             build/install/Dusklight-*.AppImage
             build/install/debug.tar.*
+            build/install/sdk/
 
   build-apple:
     name: Build Apple (${{matrix.name}})
@@ -144,10 +145,11 @@ jobs:
       - name: Upload artifacts
         uses: actions/upload-artifact@v7
         with:
-          name: dusklight-${{env.DUSK_VERSION}}-${{matrix.artifact_name}}
+          name: dusklight-${{env.APP_VERSION}}-${{matrix.artifact_name}}
           path: |
             build/install/Dusklight.app
             build/install/debug.tar.*
+            build/install/sdk/
 
   build-android:
     name: Build Android (${{matrix.name}})
@@ -203,18 +205,24 @@ jobs:
       - name: Build native library
         run: cmake --build --preset ${{matrix.preset}} --target dusklight
 
-      - name: Stage stripped JNI library
-        run: ANDROID_STAGE_ABIS="${{matrix.abi}}" platforms/android/scripts/stage-jni-libs.sh
+      - name: Build bundled mods
+        run: cmake --build --preset ${{matrix.preset}} --target dusklight_mods
 
       - name: Build APK
         working-directory: platforms/android
         run: ./gradlew :app:assembleRelease --rerun-tasks
 
+      - name: Stage artifacts
+        run: |
+          mkdir -p upload/sdk
+          cp build/*/stub-android-*.so upload/sdk/
+          cp platforms/android/app/build/outputs/apk/release/app-${{matrix.abi}}-release-unsigned.apk upload/
+
       - name: Upload artifacts
         uses: actions/upload-artifact@v7
         with:
-          name: dusklight-${{env.DUSK_VERSION}}-android-${{matrix.artifact_arch}}
-          path: platforms/android/app/build/outputs/apk/release/app-${{matrix.abi}}-release-unsigned.apk
+          name: dusklight-${{env.APP_VERSION}}-android-${{matrix.artifact_arch}}
+          path: upload/
 
   build-windows:
     name: Build Windows (${{matrix.name}})
@@ -275,9 +283,11 @@ jobs:
       - name: Upload artifacts
         uses: actions/upload-artifact@v7
         with:
-          name: dusklight-${{env.DUSK_VERSION}}-win32-msvc-${{matrix.artifact_arch}}
+          name: dusklight-${{env.APP_VERSION}}-win32-msvc-${{matrix.artifact_arch}}
           path: |
             build/install/*.exe
             build/install/*.dll
             build/install/res/
+            build/install/mods/
             build/install/debug.7z
+            build/install/sdk/
diff --git a/.gitmodules b/.gitmodules
index b386c1754a..881f8f524b 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,12 @@
 [submodule "extern/aurora"]
 	path = extern/aurora
 	url = https://github.com/encounter/aurora.git
+[submodule "extern/borealis"]
+	path = extern/borealis
+	url = https://github.com/encounter/borealis.git
+[submodule "mods/randomizer"]
+	path = mods/randomizer
+	url = https://github.com/TwilitRealm/dusklight-randomizer.git
+[submodule "mods/cosmetics"]
+	path = mods/cosmetics
+	url = https://github.com/TwilitRealm/dusklight-cosmetics
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e62704fe1c..ec18d422bc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,10 +5,11 @@ if (NOT CMAKE_BUILD_TYPE)
             "Build type options: Debug Release RelWithDebInfo MinSizeRel" FORCE)
 endif ()
 
-include(cmake/DetectVersion.cmake)
-detect_version()
+include(extern/borealis/cmake/DetectVersion.cmake)
+borealis_detect_version()
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
-project(dusklight LANGUAGES C CXX VERSION ${DUSK_VERSION_STRING})
+project(dusklight LANGUAGES C CXX VERSION ${BOREALIS_APP_VERSION})
+
 if (APPLE)
     enable_language(OBJC OBJCXX)
 endif ()
@@ -32,6 +33,7 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
+set(CMAKE_COLOR_DIAGNOSTICS ON)
 
 # Folder-based instead of target-based organization
 # in Visual Studio and Xcode generators
@@ -70,10 +72,13 @@ if (CMAKE_SYSTEM_NAME STREQUAL Linux)
 endif ()
 set(AURORA_ENABLE_DVD ON CACHE BOOL "Enable DVD API support" FORCE)
 set(AURORA_ENABLE_CARD ON CACHE BOOL "Enable CARD API support" FORCE)
+set(AURORA_ENABLE_THP ON CACHE BOOL "Enable THP decoder" FORCE)
 set(AURORA_ENABLE_RMLUI ON CACHE BOOL "Enable RmlUi UI support" FORCE)
 add_subdirectory(extern/aurora EXCLUDE_FROM_ALL)
 target_compile_definitions(aurora_mtx PRIVATE MTX_USE_PS=1)
 
+add_subdirectory(extern/borealis EXCLUDE_FROM_ALL)
+
 add_subdirectory(libs/freeverb)
 
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -84,12 +89,38 @@ endif ()
 
 option(DUSK_BUILD_WARNINGS "Enable compiler warnings (off by default)")
 option(DUSK_SELECTED_OPT "If on, selected parts of the project will be compiled with optimizations on Debug, intending to make the game run at 30 FPS. Note for MSVC: you will need to remove '/RTC1' from your debug flags in CMake.")
-option(DUSK_MOVIE_SUPPORT "If on, compile against libjpeg-turbo to enable THP file decoding" ON)
-option(DUSK_ENABLE_UPDATE_CHECKER "Enable update checking support" ON)
-option(DUSK_ENABLE_SENTRY_NATIVE "Enable sentry-native crash reporting support" OFF)
 option(DUSK_PACKAGE_INSTALL "Install Dusklight with a Linux-native file structure" OFF)
 option(DUSK_GFX_DEBUG_GROUPS "Report debug groups to the native graphics API" ${DUSK_GFX_DEBUG_GROUPS_DEFAULT})
-option(DUSK_ENABLE_CODE_MODS "Enable code mods" OFF)
+option(DUSK_ENABLE_CODE_MODS "Enable code mods" ON)
+
+set(DUSK_HAS_FUNCHOOK OFF)
+if (DUSK_ENABLE_CODE_MODS AND (NOT APPLE OR CMAKE_SYSTEM_NAME STREQUAL "Darwin"))
+    set(DUSK_HAS_FUNCHOOK ON)
+endif ()
+set(DUSK_HAS_FUNCHOOK ${DUSK_HAS_FUNCHOOK} CACHE INTERNAL "Enable funchook" FORCE)
+
+set(_target_architectures ${CMAKE_OSX_ARCHITECTURES})
+if (NOT _target_architectures)
+    set(_target_architectures ${CMAKE_SYSTEM_PROCESSOR})
+endif ()
+list(LENGTH _target_architectures _target_arch_count)
+set(DUSK_HAS_PREPATCH OFF)
+if (DUSK_ENABLE_CODE_MODS AND APPLE AND _target_arch_count EQUAL 1)
+    list(GET _target_architectures 0 _target_arch)
+    if (_target_arch STREQUAL "arm64")
+        set(DUSK_HAS_PREPATCH ON)
+    endif ()
+endif ()
+set(DUSK_HAS_PREPATCH ${DUSK_HAS_PREPATCH} CACHE INTERNAL "Enable symgen prepatch support" FORCE)
+
+if (DUSK_ENABLE_CODE_MODS AND CMAKE_SYSTEM_NAME MATCHES "^(iOS|tvOS)$")
+    list(LENGTH CMAKE_OSX_ARCHITECTURES _mobile_arch_count)
+    if (NOT _mobile_arch_count EQUAL 1 OR NOT CMAKE_OSX_ARCHITECTURES STREQUAL "arm64")
+        message(FATAL_ERROR
+                "iOS/tvOS code mods require a single arm64 architecture; got "
+                "CMAKE_OSX_ARCHITECTURES='${CMAKE_OSX_ARCHITECTURES}'")
+    endif ()
+endif ()
 
 # Edit & Continue
 if (MSVC)
@@ -102,86 +133,21 @@ if (MSVC)
     endif ()
 endif ()
 
-if (DUSK_MOVIE_SUPPORT)
-    find_package(libjpeg-turbo 3.0 CONFIG QUIET)
-    if (libjpeg-turbo_FOUND)
-        message(STATUS "dusklight: Using system libjpeg-turbo")
-    else ()
-        message(STATUS "dusklight: Fetching libjpeg-turbo")
-        include(ExternalProject)
-        set(_jpeg_install_dir ${CMAKE_BINARY_DIR}/libjpeg-turbo-install)
-        if (WIN32)
-            set(_jpeg_lib ${_jpeg_install_dir}/lib/turbojpeg-static.lib)
-        else ()
-            set(_jpeg_lib ${_jpeg_install_dir}/lib/libturbojpeg.a)
-        endif ()
-        set(_jpeg_cmake_args
-            -DCMAKE_INSTALL_PREFIX=${_jpeg_install_dir}
-            -DCMAKE_PROJECT_INCLUDE=${CMAKE_CURRENT_SOURCE_DIR}/cmake/WindowsTargetProcessor.cmake
-            -DENABLE_SHARED=OFF
-            -DWITH_TURBOJPEG=ON
-            -DWITH_JAVA=OFF
-        )
-        if (CMAKE_TOOLCHAIN_FILE)
-            get_filename_component(_jpeg_toolchain_file "${CMAKE_TOOLCHAIN_FILE}" ABSOLUTE BASE_DIR "${CMAKE_SOURCE_DIR}")
-            list(APPEND _jpeg_cmake_args -DCMAKE_TOOLCHAIN_FILE=${_jpeg_toolchain_file})
-        endif ()
-        set(_jpeg_passthrough_vars
-            ANDROID_ABI
-            ANDROID_PLATFORM
-            CMAKE_BUILD_TYPE
-            CMAKE_C_COMPILER
-            CMAKE_C_COMPILER_LAUNCHER
-            CMAKE_MAKE_PROGRAM
-            CMAKE_MSVC_RUNTIME_LIBRARY
-            CMAKE_MSVC_DEBUG_INFORMATION_FORMAT
-            CMAKE_OSX_ARCHITECTURES
-            CMAKE_OSX_DEPLOYMENT_TARGET
-            CMAKE_OSX_SYSROOT
-            DEPLOYMENT_TARGET
-            ENABLE_ARC
-            ENABLE_BITCODE
-            PLATFORM
-        )
-        foreach(_var IN LISTS _jpeg_passthrough_vars)
-            if (DEFINED ${_var})
-                list(APPEND _jpeg_cmake_args -D${_var}=${${_var}})
-            endif ()
-        endforeach ()
-        ExternalProject_Add(libjpeg-turbo-ext
-            URL https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.1.0.tar.gz
-            URL_HASH SHA256=35fec2e1ddfb05ecf6d93e50bc57c1e54bc81c16d611ddf6eff73fff266d8285
-            CMAKE_ARGS ${_jpeg_cmake_args}
-            BUILD_BYPRODUCTS ${_jpeg_lib}
-        )
-        file(MAKE_DIRECTORY ${_jpeg_install_dir}/include)
-        add_library(libjpeg-turbo::turbojpeg-static STATIC IMPORTED GLOBAL)
-        set_target_properties(libjpeg-turbo::turbojpeg-static PROPERTIES
-            IMPORTED_LOCATION ${_jpeg_lib}
-            INTERFACE_INCLUDE_DIRECTORIES ${_jpeg_install_dir}/include
-        )
-        add_dependencies(libjpeg-turbo::turbojpeg-static libjpeg-turbo-ext)
-    endif ()
-endif ()
-
-if (CMAKE_SYSTEM_NAME STREQUAL Linux)
+if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
     # -Wno-multichar: Multi-character constants ('ABCD') are implementation-defined but all compilers
     #   (CW, GCC, Clang, MSVC) encode them identically in big-endian order.
     #   For >4-char literals (which GCC/Clang truncate to int), use the MULTI_CHAR() macro.
     # -Wdeprecated-declarations: JSystem uses std::iterator, deprecated in C++17
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-multichar")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-multichar -Wno-trigraphs -Wno-deprecated-declarations")
-    set(CMAKE_INSTALL_RPATH "$ORIGIN")
-    set(CMAKE_BUILD_RPATH "$ORIGIN")
-elseif (APPLE)
-    add_compile_options(-Wno-declaration-after-statement -Wno-non-pod-varargs)
-    set(CMAKE_INSTALL_RPATH "$ORIGIN")
-    set(CMAKE_BUILD_RPATH "$ORIGIN")
-elseif (MSVC)
     add_compile_options(
-        $<$<COMPILE_LANGUAGE:C,CXX>:/bigobj>
-        $<$<COMPILE_LANGUAGE:C,CXX>:/MP>
-        $<$<COMPILE_LANGUAGE:C,CXX>:/FS>
+        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-multichar>
+        $<$<COMPILE_LANGUAGE:CXX>:-Wno-trigraphs>
+        $<$<COMPILE_LANGUAGE:CXX>:-Wno-deprecated-declarations>
+    )
+elseif (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+    add_compile_options(
+            $<$<COMPILE_LANGUAGE:C,CXX>:/bigobj>
+            $<$<COMPILE_LANGUAGE:C,CXX>:/MP>
+            $<$<COMPILE_LANGUAGE:C,CXX>:/FS>
     )
 
     if (NOT DUSK_BUILD_WARNINGS)
@@ -196,30 +162,34 @@ elseif (MSVC)
     add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/utf-8>)
 endif ()
 
+if (CMAKE_SYSTEM_NAME STREQUAL Linux)
+    set(CMAKE_INSTALL_RPATH "$ORIGIN")
+    set(CMAKE_BUILD_RPATH "$ORIGIN")
+elseif (APPLE)
+    add_compile_options(-Wno-declaration-after-statement -Wno-non-pod-varargs)
+    set(CMAKE_INSTALL_RPATH "@loader_path")
+    set(CMAKE_BUILD_RPATH "@loader_path")
+endif ()
+
 include(FetchContent)
 
 # Declare all dependencies first so CMake can download them in parallel
-message(STATUS "dusklight: Fetching cxxopts")
-FetchContent_Declare(cxxopts
-    URL https://github.com/jarro2783/cxxopts/archive/refs/tags/v3.3.1.tar.gz
-    URL_HASH SHA256=3bfc70542c521d4b55a46429d808178916a579b28d048bd8c727ee76c39e2072
-    DOWNLOAD_EXTRACT_TIMESTAMP FALSE
-)
-message(STATUS "dusklight: Fetching nlohmann/json")
-FetchContent_Declare(json
-    URL https://github.com/nlohmann/json/releases/download/v3.12.0/json.tar.xz
-    URL_HASH SHA256=42f6e95cad6ec532fd372391373363b62a14af6d771056dbfc86160e6dfff7aa
-    DOWNLOAD_EXTRACT_TIMESTAMP FALSE
-)
 message(STATUS "dusklight: Fetching miniz")
 FetchContent_Declare(miniz
     URL https://github.com/richgel999/miniz/releases/download/3.0.2/miniz-3.0.2.zip
     DOWNLOAD_EXTRACT_TIMESTAMP TRUE
     EXCLUDE_FROM_ALL
 )
+message(STATUS "dusklight: Fetching PicoSHA2")
+FetchContent_Declare(picosha2
+    URL https://github.com/okdshin/PicoSHA2/archive/refs/tags/v1.0.1.tar.gz
+    URL_HASH SHA256=9983136544234e573fe07cc1a22fdf978ad7979043e7be2e9082f6d4991ff8a8
+    DOWNLOAD_EXTRACT_TIMESTAMP TRUE
+    EXCLUDE_FROM_ALL
+)
 
-set(_fetch_content_deps cxxopts json miniz)
-if (DUSK_ENABLE_CODE_MODS)
+set(_fetch_content_deps miniz picosha2)
+if (DUSK_HAS_FUNCHOOK)
     message(STATUS "dusklight: Fetching funchook")
     # cmake/PatchFunchook.cmake patches funchook's cmake/capstone.cmake.in to inject a
     # PATCH_COMMAND into capstone's inner ExternalProject. That PATCH_COMMAND runs
@@ -253,30 +223,12 @@ if (DUSK_ENABLE_CODE_MODS)
 endif ()
 FetchContent_MakeAvailable(${_fetch_content_deps})
 
-if (DUSK_ENABLE_SENTRY_NATIVE)
-    message(STATUS "dusklight: Fetching sentry-native")
-    set(SENTRY_BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
-    set(SENTRY_BACKEND crashpad CACHE STRING "" FORCE)
-    if (WIN32)
-        set(SENTRY_TRANSPORT winhttp CACHE STRING "" FORCE)
-    endif ()
-    set(SENTRY_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-    set(SENTRY_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-    set(SENTRY_BUILD_BENCHMARKS OFF CACHE BOOL "" FORCE)
-    FetchContent_Declare(sentry_native
-        GIT_REPOSITORY https://github.com/getsentry/sentry-native.git
-        GIT_TAG 0.13.6
-        GIT_SHALLOW TRUE
-        GIT_PROGRESS TRUE
-        GIT_SUBMODULES_RECURSE TRUE
-    )
-    if (NOT sentry_native_POPULATED)
-        FetchContent_Populate(sentry_native)
-        set(_dusk_skip_install_rules ${CMAKE_SKIP_INSTALL_RULES})
-        set(CMAKE_SKIP_INSTALL_RULES ON)
-        add_subdirectory(${sentry_native_SOURCE_DIR} ${sentry_native_BINARY_DIR} EXCLUDE_FROM_ALL)
-        set(CMAKE_SKIP_INSTALL_RULES ${_dusk_skip_install_rules})
-    endif ()
+if (DUSK_HAS_FUNCHOOK AND APPLE)
+    target_sources(funchook-static PRIVATE src/dusk/mods/loader/code_patch_macos.cpp)
+    target_include_directories(funchook-static PRIVATE src/dusk/mods/loader)
+    set_source_files_properties(src/dusk/mods/loader/code_patch_macos.cpp
+            TARGET_DIRECTORY funchook-static PROPERTIES
+            COMPILE_OPTIONS "-O2;-fno-sanitize=all;-fno-stack-protector")
 endif ()
 
 # Use signed char on ARM to match the original game (and x86)
@@ -285,8 +237,6 @@ if(_arch MATCHES "^(arm|aarch64)" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQU
     add_compile_options(-fsigned-char)
 endif()
 
-configure_version_header()
-
 include(files.cmake)
 
 # TODO: version handling for res includes
@@ -299,87 +249,29 @@ set(DUSK_PRODUCT_NAME "Dusklight")
 set(DUSK_COPYRIGHT "Copyright (C) Twilit Realm contributors")
 
 source_group("dolzel" FILES ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${REL_FILES})
-source_group("dusklight" FILES ${DUSK_FILES} ${DUSK_HTTP_BACKEND_FILES})
+source_group("dusklight" FILES ${DUSK_FILES})
 
 include(cmake/GameABIConfig.cmake)
 
 find_package(Threads REQUIRED)
-set(GAME_LIBS aurora::core aurora::gx aurora::gd aurora::si aurora::vi aurora::pad aurora::mtx aurora::os aurora::dvd
-    aurora::card freeverb cxxopts::cxxopts absl::flat_hash_map nlohmann_json::nlohmann_json TracyClient fmt::fmt
-    Threads::Threads zstd::libzstd dusklight_game_headers)
-if (DUSK_ENABLE_CODE_MODS)
+set(GAME_COMPILE_DEFS DUSK_BUILDING_GAME=1)
+set(GAME_LIBS aurora::core aurora::gx aurora::gd aurora::si aurora::vi aurora::pad aurora::mtx aurora::os aurora::dvd aurora::thp
+    aurora::card borealis::http borealis::cli borealis::crash borealis::data borealis::disc borealis::discord borealis::file_select borealis::io borealis::log borealis::net borealis::presentation borealis::sentry borealis::update borealis::ws freeverb cxxopts::cxxopts absl::flat_hash_map nlohmann_json::nlohmann_json TracyClient fmt::fmt
+    Threads::Threads zstd::libzstd dusklight_game_headers picosha2 PNG::PNG)
+if (DUSK_HAS_FUNCHOOK)
     list(APPEND GAME_LIBS funchook-static)
 endif ()
 
-if (DUSK_ENABLE_SENTRY_NATIVE)
-    list(APPEND GAME_LIBS sentry)
-    list(APPEND GAME_COMPILE_DEFS DUSK_ENABLE_SENTRY_NATIVE=1 SENTRY_BUILD_STATIC=1)
-endif ()
-
 if (WIN32)
     list(APPEND GAME_LIBS Ws2_32)
-    if (CMAKE_BUILD_TYPE STREQUAL Debug)
-        list(APPEND GAME_LIBS dbghelp)
-        list(APPEND GAME_COMPILE_DEFS DUSK_CRASH_DBGHELP=1)
-    endif ()
-endif ()
-
-set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/no_backend.cpp)
-if (DUSK_ENABLE_UPDATE_CHECKER)
-    list(APPEND GAME_COMPILE_DEFS DUSK_ENABLE_UPDATE_CHECKER=1)
-    if (WIN32)
-        set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/winhttp.cpp)
-        list(APPEND GAME_LIBS winhttp)
-        list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_WINHTTP=1)
-        message(STATUS "dusklight: Enabled update checker (WinHTTP)")
-    elseif (ANDROID)
-        set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/android.cpp)
-        list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_ANDROID=1)
-        message(STATUS "dusklight: Enabled update checker (Android)")
-    elseif (APPLE)
-        find_library(FOUNDATION_FRAMEWORK Foundation REQUIRED)
-        set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/url_session.mm)
-        set_source_files_properties(src/dusk/http/url_session.mm PROPERTIES COMPILE_FLAGS -fobjc-arc)
-        list(APPEND GAME_LIBS ${FOUNDATION_FRAMEWORK})
-        list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_URLSESSION=1)
-        message(STATUS "dusklight: Enabled update checker (NSURLSession)")
-    elseif (CMAKE_SYSTEM_NAME STREQUAL Linux)
-        find_package(CURL QUIET OPTIONAL_COMPONENTS HTTPS SSL)
-        if (CURL_FOUND AND CURL_HTTPS_FOUND AND CURL_SSL_FOUND)
-            set(DUSK_HTTP_BACKEND_SOURCE src/dusk/http/curl.cpp)
-            list(APPEND GAME_LIBS CURL::libcurl)
-            list(APPEND GAME_COMPILE_DEFS DUSK_HTTP_BACKEND_LIBCURL=1)
-            message(STATUS "dusklight: Enabled update checker (libcurl)")
-        else ()
-            message(STATUS "dusklight: Disabled update checker (libcurl + HTTPS/SSL not found)")
-        endif ()
-    else ()
-        message(STATUS "dusklight: Disabled update checker (unsupported platform)")
-    endif ()
-endif ()
-list(APPEND DUSK_FILES ${DUSK_HTTP_BACKEND_SOURCE})
-
-if (DUSK_MOVIE_SUPPORT)
-    if (TARGET libjpeg-turbo::turbojpeg-static)
-        list(APPEND GAME_LIBS libjpeg-turbo::turbojpeg-static)
-    else ()
-        list(APPEND GAME_LIBS libjpeg-turbo::turbojpeg)
-    endif ()
-    list(APPEND GAME_COMPILE_DEFS MOVIE_SUPPORT=1)
-endif ()
-
-set(DUSK_ENABLE_DISCORD_DEFAULT ON)
-if (DEFINED DUSK_ENABLE_DISCORD_RPC AND NOT DEFINED DUSK_ENABLE_DISCORD)
-    set(DUSK_ENABLE_DISCORD_DEFAULT ${DUSK_ENABLE_DISCORD_RPC})
-endif ()
-option(DUSK_ENABLE_DISCORD "Enable Discord Rich Presence support" ${DUSK_ENABLE_DISCORD_DEFAULT})
-if (DUSK_ENABLE_DISCORD AND NOT ANDROID AND NOT IOS AND NOT TVOS)
-    list(APPEND GAME_COMPILE_DEFS DUSK_DISCORD=1)
 endif ()
 
 if (DUSK_ENABLE_CODE_MODS)
     list(APPEND GAME_COMPILE_DEFS DUSK_CODE_MODS=1)
 endif ()
+list(APPEND GAME_COMPILE_DEFS
+        DUSK_HAS_FUNCHOOK=$<BOOL:${DUSK_HAS_FUNCHOOK}>
+        DUSK_HAS_PREPATCH=$<BOOL:${DUSK_HAS_PREPATCH}>)
 
 if (DUSK_PACKAGE_INSTALL)
     include(GNUInstallDirs)
@@ -435,20 +327,31 @@ if (CMAKE_CXX_LINK_GROUP_USING_RESCAN_SUPPORTED OR CMAKE_LINK_GROUP_USING_RESCAN
     set(JSYSTEM_LINK_LIBRARIES "$<LINK_GROUP:RESCAN,${JSYSTEM_LIBRARIES}>")
 endif ()
 
-set(DUSK_FILES src/dusk/main.cpp ${GAME_BASE_FILES} ${GAME_DEBUG_FILES} ${miniz_SOURCE_DIR}/miniz.c)
-if(ANDROID)
-    add_library(dusklight SHARED ${DUSK_FILES})
-    set_target_properties(dusklight PROPERTIES OUTPUT_NAME main)
-else ()
-    add_executable(dusklight ${DUSK_FILES})
-endif ()
+set(_dusklight_all_files src/dusk/main.cpp ${GAME_BASE_FILES} ${GAME_DEBUG_FILES})
+set(DUSK_INTERNAL_FILES ${_dusklight_all_files})
+list(FILTER DUSK_INTERNAL_FILES INCLUDE REGEX "^src/dusk/")
+set(GAME_FILES ${_dusklight_all_files})
+list(FILTER GAME_FILES EXCLUDE REGEX "^src/dusk/")
+
+add_library(dusk_internal OBJECT ${DUSK_INTERNAL_FILES})
 if (ENABLE_ASAN)
-    target_sources(dusklight PRIVATE src/dusk/asan_options.c)
+    target_sources(dusk_internal PRIVATE src/dusk/asan_options.c)
 endif ()
+target_compile_definitions(dusk_internal PRIVATE ${GAME_COMPILE_DEFS})
+target_include_directories(dusk_internal PRIVATE ${miniz_SOURCE_DIR})
+target_link_libraries(dusk_internal PRIVATE aurora::main ${GAME_LIBS} ${JSYSTEM_LIBRARIES})
+target_precompile_headers(dusk_internal PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
+
+if(ANDROID)
+    add_library(dusklight SHARED ${GAME_FILES} ${miniz_SOURCE_DIR}/miniz.c)
+else ()
+    add_executable(dusklight ${GAME_FILES} ${miniz_SOURCE_DIR}/miniz.c)
+endif ()
+borealis_configure_android_application(dusklight)
 
 target_compile_definitions(dusklight PRIVATE ${GAME_COMPILE_DEFS})
 target_include_directories(dusklight PRIVATE ${miniz_SOURCE_DIR})
-target_link_libraries(dusklight PRIVATE aurora::main ${GAME_LIBS} ${JSYSTEM_LINK_LIBRARIES})
+target_link_libraries(dusklight PRIVATE dusk_internal aurora::main ${GAME_LIBS} ${JSYSTEM_LINK_LIBRARIES})
 target_precompile_headers(dusklight PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
 
 if (DUSK_ENABLE_CODE_MODS)
@@ -462,37 +365,89 @@ if (DUSK_ENABLE_CODE_MODS)
     setup_symbol_manifest(dusklight)
 endif ()
 
-# Hook reliability: guaranteed patchable entries on the game ABI surface, and no identical-code folding.
-if (MSVC)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-        set(DUSK_PATCHABLE_ENTRY_FLAG $<$<COMPILE_LANGUAGE:C,CXX>:/hotpatch>)
+# Hook reliability: prevent auto-inlining, guarantee patchable function entries,
+# and disable identical-code folding for game functions.
+if (DUSK_ENABLE_CODE_MODS)
+    set(DUSK_GAME_ABI_INLINE_OPTIONS)
+    if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
+        if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            list(APPEND DUSK_GAME_ABI_INLINE_OPTIONS
+                    $<$<COMPILE_LANGUAGE:CXX>:-finline-hint-functions>)
+        elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+            list(APPEND DUSK_GAME_ABI_INLINE_OPTIONS
+                    $<$<COMPILE_LANGUAGE:CXX>:-flive-patching=inline-clone>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-inline-functions>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-inline-small-functions>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-inline-functions-called-once>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-early-inlining>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-ipa-cp>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-ipa-cp-clone>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-ipa-sra>
+                    $<$<COMPILE_LANGUAGE:CXX>:-fno-partial-inlining>)
+        endif ()
     endif ()
-    if (CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64")
-        target_link_options(dusklight PRIVATE /FUNCTIONPADMIN:16 /OPT:NOICF)
-    else ()
-        target_link_options(dusklight PRIVATE /FUNCTIONPADMIN /OPT:NOICF)
+
+    if (DUSK_GAME_ABI_INLINE_OPTIONS)
+        target_compile_options(dusklight PRIVATE ${DUSK_GAME_ABI_INLINE_OPTIONS})
+
+        foreach(jsystem_lib IN LISTS JSYSTEM_LIBRARIES)
+            target_compile_options(${jsystem_lib} PRIVATE ${DUSK_GAME_ABI_INLINE_OPTIONS})
+        endforeach()
+        foreach(_sdk_lib aurora_card aurora_core aurora_dvd aurora_gd aurora_gx aurora_mtx
+                aurora_os aurora_pad aurora_si aurora_vi)
+            if (TARGET ${_sdk_lib})
+                get_target_property(_sdk_lib_imported ${_sdk_lib} IMPORTED)
+                if (NOT _sdk_lib_imported)
+                    target_compile_options(${_sdk_lib} PRIVATE ${DUSK_GAME_ABI_INLINE_OPTIONS})
+                endif ()
+            endif ()
+        endforeach ()
     endif ()
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    if (CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm64")
-        set(DUSK_PATCHABLE_ENTRY_FLAG $<$<COMPILE_LANGUAGE:C,CXX>:-fpatchable-function-entry=2,1>)
-    else ()
-        set(DUSK_PATCHABLE_ENTRY_FLAG $<$<COMPILE_LANGUAGE:C,CXX>:-fpatchable-function-entry=10,5>)
+
+    if (MSVC)
+        if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+            set(DUSK_PATCHABLE_ENTRY_FLAG $<$<COMPILE_LANGUAGE:C,CXX>:/hotpatch>)
+        endif ()
+        if (CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64")
+            target_link_options(dusklight PRIVATE /FUNCTIONPADMIN:16 /OPT:NOICF)
+        else ()
+            target_link_options(dusklight PRIVATE /FUNCTIONPADMIN /OPT:NOICF)
+        endif ()
+    elseif (CMAKE_CXX_COMPILER_ID MATCHES "^(AppleClang|Clang|GNU)$")
+        if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm64|aarch64)$" OR CMAKE_OSX_ARCHITECTURES MATCHES "arm64")
+            set(DUSK_PATCHABLE_ENTRY_FLAG $<$<COMPILE_LANGUAGE:C,CXX>:-fpatchable-function-entry=2,1>)
+        else ()
+            set(DUSK_PATCHABLE_ENTRY_FLAG $<$<COMPILE_LANGUAGE:C,CXX>:-fpatchable-function-entry=10,4>)
+        endif ()
+    endif ()
+
+    if (DEFINED DUSK_PATCHABLE_ENTRY_FLAG)
+        target_compile_options(dusklight PRIVATE ${DUSK_PATCHABLE_ENTRY_FLAG})
+        foreach(jsystem_lib IN LISTS JSYSTEM_LIBRARIES)
+            target_compile_options(${jsystem_lib} PRIVATE ${DUSK_PATCHABLE_ENTRY_FLAG})
+        endforeach()
+        foreach(_sdk_lib aurora_card aurora_core aurora_dvd aurora_gd aurora_gx aurora_mtx
+                aurora_os aurora_pad aurora_si aurora_vi)
+            if (TARGET ${_sdk_lib})
+                get_target_property(_sdk_lib_imported ${_sdk_lib} IMPORTED)
+                if (NOT _sdk_lib_imported)
+                    target_compile_options(${_sdk_lib} PRIVATE ${DUSK_PATCHABLE_ENTRY_FLAG})
+                endif ()
+            endif ()
+        endforeach ()
     endif ()
-endif ()
-if (DEFINED DUSK_PATCHABLE_ENTRY_FLAG)
-    target_compile_options(dusklight PRIVATE ${DUSK_PATCHABLE_ENTRY_FLAG})
-    foreach(jsystem_lib IN LISTS JSYSTEM_LIBRARIES)
-        target_compile_options(${jsystem_lib} PRIVATE ${DUSK_PATCHABLE_ENTRY_FLAG})
-    endforeach()
 endif ()
 
 if (WIN32)
     target_link_libraries(dusklight PRIVATE Psapi)
 endif ()
 if (APPLE)
-    # Mods resolve game symbols from the executable at dlopen time.
-    target_link_options(dusklight PRIVATE -Wl,-export_dynamic)
-elseif (UNIX AND NOT ANDROID)
+    include(cmake/AppleExports.cmake)
+    setup_apple_exports(dusklight)
+elseif (ANDROID)
+    include(cmake/AndroidExports.cmake)
+    setup_android_exports(dusklight)
+elseif (UNIX)
     target_link_options(dusklight PRIVATE -rdynamic)
 endif ()
 
@@ -506,12 +461,6 @@ if (TARGET crashpad_handler)
     )
 endif ()
 
-if (ANDROID)
-    # SDLActivity loads SDL_main via dlsym on Android. Since aurora::main is a static
-    # archive, force an undefined reference so the linker keeps the SDL_main object.
-    target_link_options(dusklight PRIVATE "-Wl,-u,SDL_main")
-endif ()
-
 if (CMAKE_SYSTEM_NAME STREQUAL Linux)
     target_link_options(dusklight PRIVATE "-Wl,--build-id=sha1")
     target_link_libraries(dusklight PRIVATE dl)
@@ -559,7 +508,15 @@ include(cmake/ModSDK.cmake)
 
 if (DUSK_ENABLE_CODE_MODS AND CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
     add_custom_target(dusklight_mods) # Aggregate target for all in-tree mods
-    add_subdirectory(tools/mod_template)
+    add_subdirectory(mods/luau_runtime)
+    add_subdirectory(mods/template_mod)
+    add_subdirectory(mods/ao_mod)
+    add_subdirectory(mods/shadow_mod)
+    add_subdirectory(mods/window_demo)
+    add_subdirectory(mods/flow_demo)
+    add_subdirectory(mods/custom_actor_demo)
+    add_subdirectory(mods/cosmetics)
+    add_subdirectory(mods/randomizer)
 endif ()
 
 if (APPLE)
@@ -593,8 +550,8 @@ if (APPLE)
         MACOSX_BUNDLE TRUE
         MACOSX_BUNDLE_BUNDLE_NAME ${DUSK_BUNDLE_NAME}
         MACOSX_BUNDLE_GUI_IDENTIFIER ${DUSK_BUNDLE_IDENTIFIER}
-        MACOSX_BUNDLE_BUNDLE_VERSION ${DUSK_VERSION_STRING}
-        MACOSX_BUNDLE_SHORT_VERSION_STRING ${DUSK_SHORT_VERSION_STRING}
+        MACOSX_BUNDLE_BUNDLE_VERSION ${BOREALIS_APP_VERSION}
+        MACOSX_BUNDLE_SHORT_VERSION_STRING ${BOREALIS_APP_SHORT_VERSION}
         MACOSX_BUNDLE_INFO_PLIST ${DUSK_INFO_PLIST}
         OUTPUT_NAME Dusklight
         XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "YES"
@@ -604,13 +561,13 @@ if (APPLE)
         list(APPEND _apple_bundle_properties
             XCODE_ATTRIBUTE_CODE_SIGN_ENTITLEMENTS ${DUSK_ENTITLEMENTS})
     endif ()
-    if (NOT IOS AND NOT TVOS)
+    if (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
         list(APPEND _apple_bundle_properties
             XCODE_ATTRIBUTE_ENABLE_HARDENED_RUNTIME "YES")
     endif ()
     set_target_properties(dusklight PROPERTIES ${_apple_bundle_properties})
 
-    if (NOT IOS AND NOT TVOS AND NOT "${CMAKE_GENERATOR}" STREQUAL "Xcode")
+    if (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT "${CMAKE_GENERATOR}" STREQUAL "Xcode")
         set(_sign_nested_commands)
         if (TARGET crashpad_handler)
             list(APPEND _sign_nested_commands
@@ -627,21 +584,6 @@ if (APPLE)
     endif ()
 endif ()
 
-if (APPLE AND NOT IOS AND NOT TVOS)
-    find_library(APPKIT_FRAMEWORK AppKit REQUIRED)
-    target_sources(dusklight PRIVATE src/dusk/file_select_macos.mm)
-    set_source_files_properties(src/dusk/file_select_macos.mm PROPERTIES COMPILE_FLAGS -fobjc-arc)
-    target_link_libraries(dusklight PRIVATE ${APPKIT_FRAMEWORK})
-endif ()
-
-if (IOS)
-    find_library(UIKIT_FRAMEWORK UIKit REQUIRED)
-    find_library(UNIFORM_TYPE_IDENTIFIERS_FRAMEWORK UniformTypeIdentifiers REQUIRED)
-    target_sources(dusklight PRIVATE src/dusk/ios/FileSelectDialog.m)
-    set_source_files_properties(src/dusk/ios/FileSelectDialog.m PROPERTIES COMPILE_FLAGS -fobjc-arc)
-    target_link_libraries(dusklight PRIVATE ${UIKIT_FRAMEWORK} ${UNIFORM_TYPE_IDENTIFIERS_FRAMEWORK})
-endif ()
-
 include(extern/aurora/cmake/AuroraCopyRuntimeDLLs.cmake)
 aurora_copy_runtime_dlls(dusklight)
 
diff --git a/CMakePresets.json b/CMakePresets.json
index 394a1ddef5..849e4161cd 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -22,30 +22,18 @@
         "CMAKE_MSVC_RUNTIME_LIBRARY": "MultiThreadedDLL"
       }
     },
-    {
-      "name": "release",
-      "hidden": true,
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_MSVC_RUNTIME_LIBRARY": "MultiThreadedDLL",
-        "CMAKE_INTERPROCEDURAL_OPTIMIZATION": {
-          "type": "BOOL",
-          "value": true
-        }
-      }
-    },
     {
       "name": "ci",
       "hidden": true,
       "cacheVariables": {
         "CMAKE_C_COMPILER_LAUNCHER": "sccache",
         "CMAKE_CXX_COMPILER_LAUNCHER": "sccache",
-        "DUSK_ENABLE_SENTRY_NATIVE": {
+        "BOREALIS_ENABLE_SENTRY": {
           "type": "BOOL",
           "value": true
         },
-        "DUSK_SENTRY_DSN": "$env{SENTRY_DSN}",
-        "DUSK_SENTRY_ENVIRONMENT": "production",
+        "BOREALIS_SENTRY_DSN": "$env{SENTRY_DSN}",
+        "BOREALIS_SENTRY_ENVIRONMENT": "production",
         "Rust_RUSTUP_INSTALL_MISSING_TARGET": {
           "type": "BOOL",
           "value": true
@@ -72,11 +60,7 @@
           "type": "BOOL",
           "value": false
         },
-        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
-        "DUSK_ENABLE_CODE_MODS": {
-          "type": "BOOL",
-          "value": true
-        }
+        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install"
       },
       "vendor": {
         "microsoft.com/VisualStudioSettings/CMake/1.0": {
@@ -163,10 +147,6 @@
         "CMAKE_C_COMPILER": "cl",
         "CMAKE_CXX_COMPILER": "cl",
         "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
-        "DUSK_ENABLE_CODE_MODS": {
-          "type": "BOOL",
-          "value": true
-        },
         "CMAKE_DISABLE_FIND_PACKAGE_PkgConfig": {
           "type": "BOOL",
           "value": true
@@ -208,17 +188,13 @@
     {
       "name": "windows-arm64-msvc",
       "displayName": "Windows ARM64 (MSVC)",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build/${presetName}",
+      "inherits": [
+        "windows-msvc"
+      ],
       "architecture": {
         "value": "arm64",
         "strategy": "external"
       },
-      "cacheVariables": {
-        "CMAKE_C_COMPILER": "cl",
-        "CMAKE_CXX_COMPILER": "cl",
-        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install"
-      },
       "vendor": {
         "microsoft.com/VisualStudioSettings/CMake/1.0": {
           "hostOS": [
@@ -270,11 +246,7 @@
           "type": "BOOL",
           "value": false
         },
-        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
-        "DUSK_ENABLE_CODE_MODS": {
-          "type": "BOOL",
-          "value": true
-        }
+        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install"
       },
       "vendor": {
         "microsoft.com/VisualStudioSettings/CMake/1.0": {
@@ -330,6 +302,10 @@
           "type": "BOOL",
           "value": false
         },
+        "ENABLE_VISIBILITY": {
+          "type": "BOOL",
+          "value": true
+        },
         "Rust_CARGO_TARGET": "aarch64-apple-ios",
         "BUILD_SHARED_LIBS": {
           "type": "BOOL",
@@ -370,6 +346,10 @@
           "type": "BOOL",
           "value": false
         },
+        "ENABLE_VISIBILITY": {
+          "type": "BOOL",
+          "value": true
+        },
         "Rust_CARGO_TARGET": "aarch64-apple-tvos",
         "Rust_TOOLCHAIN": "nightly",
         "BUILD_SHARED_LIBS": {
@@ -406,10 +386,6 @@
           "type": "BOOL",
           "value": false
         },
-        "DUSK_ENABLE_CODE_MODS": {
-          "type": "BOOL",
-          "value": true
-        },
         "CMAKE_DISABLE_FIND_PACKAGE_PkgConfig": {
           "type": "BOOL",
           "value": true
@@ -445,11 +421,10 @@
       "hidden": true,
       "inherits": [
         "android-base",
-        "ci",
-        "release"
+        "ci"
       ],
       "cacheVariables": {
-        "DUSK_ENABLE_SENTRY_NATIVE": {
+        "BOREALIS_ENABLE_SENTRY": {
           "type": "BOOL",
           "value": false
         }
diff --git a/README.md b/README.md
index 7584c09c46..7445e43ea9 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,9 @@ Dusklight is a reverse-engineered reimplementation of Twilight Princess.
 
 It aims to be as accurate as possible to the original while also providing new options, enhancements, and tools to customize your experience.
 
+> [!IMPORTANT]
+> Dusklight's official website is https://twilitrealm.dev/, any other website is not affiliated and may be promoting AI-generated misinformation.
+
 # Setup
 
 > [!IMPORTANT]
@@ -26,7 +29,10 @@ It aims to be as accurate as possible to the original while also providing new o
 
 You must dump your own copy of the game. Please see [this article](https://wiki.dolphin-emu.org/index.php?title=Ripping_Games) for instructions. After dumping, you can use a program like [Dolphin](https://dolphin-emu.org/) or [nodtool](https://github.com/encounter/nod/releases) to convert the `.iso` to `.rvz` to save space.
 
-Currently, only the GameCube USA and EUR releases are supported. Support for other versions of the game is planned in the future.
+Dusklight currently supports all commercial discs except for Wii's Korean release.
+
+> [!NOTE]
+> Dusklight is based on the [Twilight Princess decompilation](https://github.com/zeldaret/tp), which is currently only matching for GameCube. As a result, even when playing Dusklight with a Wii disc, you will be presented with the GameCube version's HUD and certain other specificities.
 
 ### 2. Install Dusklight
 
diff --git a/ci/build-appimage.sh b/ci/build-appimage.sh
index e12f1163b9..c4a0e82995 100755
--- a/ci/build-appimage.sh
+++ b/ci/build-appimage.sh
@@ -23,5 +23,5 @@ cp -r platforms/freedesktop/{16x16,32x32,48x48,64x64,128x128,256x256,512x512,102
 cp platforms/freedesktop/dev.twilitrealm.dusk.desktop build/appdir/usr/share/applications
 
 cd build/install
-VERSION="$DUSK_VERSION" NO_STRIP=1 "$linuxdeploy" \
+VERSION="$APP_VERSION" NO_STRIP=1 "$linuxdeploy" \
   -l "$lib_dir/libusb-1.0.so" --appdir "$build_dir/appdir" --output appimage
diff --git a/cmake/AndroidExports.cmake b/cmake/AndroidExports.cmake
new file mode 100644
index 0000000000..a71c18a02b
--- /dev/null
+++ b/cmake/AndroidExports.cmake
@@ -0,0 +1,61 @@
+include_guard(GLOBAL)
+
+get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
+
+# Android mod linking: symgen scans and filters the game's exports, generating a version script used for the executable
+# link step, and generates a shared object stub that mods can link against without having to build the whole game.
+function(setup_android_exports target)
+    include("${_dir}/SymbolManifest.cmake")
+    ensure_symgen(TRUE)
+    add_dependencies(${target} symgen)
+
+    set(_rsp_lines "$<TARGET_OBJECTS:${target}>")
+    foreach (_lib IN LISTS JSYSTEM_LIBRARIES)
+        list(APPEND _rsp_lines "$<TARGET_FILE:${_lib}>")
+    endforeach ()
+    list(JOIN _rsp_lines "\n" _rsp_content)
+    set(_rsp "${CMAKE_BINARY_DIR}/dusklight_exports_input.rsp")
+    file(GENERATE OUTPUT "${_rsp}" CONTENT "${_rsp_content}")
+
+    set(_sdk_args)
+    foreach (_lib aurora_card aurora_core aurora_dvd aurora_gd aurora_gx aurora_mtx
+            aurora_os aurora_pad aurora_si aurora_vi)
+        if (TARGET ${_lib})
+            list(APPEND _sdk_args --sdk-lib "$<TARGET_FILE:${_lib}>")
+        endif ()
+    endforeach ()
+    if (TARGET dawn::webgpu_dawn)
+        get_target_property(_dawn_type dawn::webgpu_dawn TYPE)
+        if (_dawn_type STREQUAL "STATIC_LIBRARY")
+            list(APPEND _sdk_args --sdk-lib "$<TARGET_FILE:dawn::webgpu_dawn>")
+        endif ()
+    endif ()
+
+    set(_vscript "${CMAKE_BINARY_DIR}/dusklight_exports.ver")
+    add_custom_command(TARGET ${target} PRE_LINK
+            COMMAND "${SYMGEN_EXE}" exports
+            "@${_rsp}"
+            --out "${_vscript}"
+            --format version-script
+            --exclude cmake_pch
+            --exclude miniz
+            # Resolved from the Java side; the SDL ones live in the statically-linked
+            # SDL archive, outside the provenance scan.
+            --extra-sym JNI_OnLoad
+            --extra-sym SDL_main
+            --extra-sym "Java_*"
+            ${_sdk_args}
+            COMMENT "Generating dusklight exports"
+            VERBATIM)
+    target_link_options(${target} PRIVATE "-Wl,--version-script=${_vscript}")
+
+    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _arch)
+    set(_stub "${CMAKE_BINARY_DIR}/stub-android-${_arch}.so")
+    add_custom_command(TARGET ${target} POST_BUILD
+            COMMAND "${SYMGEN_EXE}" stub -f elf "$<TARGET_FILE:${target}>" -o "${_stub}"
+            --soname "$<TARGET_FILE_NAME:${target}>" --arch "${_arch}"
+            BYPRODUCTS "${_stub}"
+            COMMENT "Generating dusklight link stub"
+            VERBATIM)
+    install(FILES "${_stub}" DESTINATION sdk)
+endfunction()
diff --git a/cmake/AppleExports.cmake b/cmake/AppleExports.cmake
new file mode 100644
index 0000000000..6397e353a5
--- /dev/null
+++ b/cmake/AppleExports.cmake
@@ -0,0 +1,88 @@
+include_guard(GLOBAL)
+
+get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
+
+# Apple mod linking: symgen scans and filters the game's exports, generating an exports list used for the executable
+# link step, and generates a MH_EXECUTE Mach-O stub that mods can link against without having to build the whole game.
+function(setup_apple_exports target)
+    include("${_dir}/SymbolManifest.cmake")
+    ensure_symgen(TRUE)
+    set(_symgen "${SYMGEN_EXE}")
+    add_dependencies(${target} symgen)
+
+    set(_config_subdir "")
+    if (CMAKE_CONFIGURATION_TYPES)
+        set(_config_subdir "$<CONFIG>/")
+    endif ()
+
+    set(_rsp_lines "$<TARGET_OBJECTS:${target}>")
+    foreach (_lib IN LISTS JSYSTEM_LIBRARIES)
+        list(APPEND _rsp_lines "$<TARGET_FILE:${_lib}>")
+    endforeach ()
+    list(JOIN _rsp_lines "\n" _rsp_content)
+    set(_rsp "${CMAKE_BINARY_DIR}/${_config_subdir}dusklight_exports_input.rsp")
+    file(GENERATE OUTPUT "${_rsp}" CONTENT "${_rsp_content}")
+
+    set(_sdk_args)
+    foreach (_lib aurora_card aurora_core aurora_dvd aurora_gd aurora_gx aurora_mtx
+            aurora_os aurora_pad aurora_si aurora_vi)
+        if (TARGET ${_lib})
+            list(APPEND _sdk_args --sdk-lib "$<TARGET_FILE:${_lib}>")
+        endif ()
+    endforeach ()
+
+    # Dawn is linked statically on Apple; mods reach wgpu* through the executable.
+    if (TARGET dawn::webgpu_dawn)
+        get_target_property(_dawn_type dawn::webgpu_dawn TYPE)
+        if (_dawn_type STREQUAL "STATIC_LIBRARY")
+            list(APPEND _sdk_args --sdk-lib "$<TARGET_FILE:dawn::webgpu_dawn>")
+        endif ()
+    endif ()
+
+    set(_exp "${CMAKE_BINARY_DIR}/${_config_subdir}dusklight_exports.exp")
+    add_custom_command(TARGET ${target} PRE_LINK
+            COMMAND "${_symgen}" exports
+            "@${_rsp}"
+            --out "${_exp}"
+            --exclude cmake_pch
+            --exclude miniz
+            ${_sdk_args}
+            COMMENT "Generating dusklight exports"
+            VERBATIM)
+    target_link_options(${target} PRIVATE -Xlinker -exported_symbols_list -Xlinker "${_exp}")
+
+    # Generate the stub executable mods link against via -bundle_loader.
+    set(_stub_args)
+    if (IOS)
+        set(_stub_platform "ios")
+        list(APPEND _stub_args --platform ios)
+    elseif (TVOS)
+        set(_stub_platform "tvos")
+        list(APPEND _stub_args --platform tvos)
+    else ()
+        set(_stub_platform "macos")
+    endif ()
+    if (CMAKE_OSX_DEPLOYMENT_TARGET)
+        list(APPEND _stub_args --min-os "${CMAKE_OSX_DEPLOYMENT_TARGET}")
+    endif ()
+    if (CMAKE_OSX_ARCHITECTURES)
+        set(_archs "${CMAKE_OSX_ARCHITECTURES}")
+    else ()
+        set(_archs "${CMAKE_SYSTEM_PROCESSOR}")
+    endif ()
+    set(_arch_names "")
+    foreach (_arch IN LISTS _archs)
+        string(TOLOWER "${_arch}" _arch)
+        list(APPEND _stub_args --arch "${_arch}")
+        list(APPEND _arch_names "${_arch}")
+    endforeach ()
+    list(JOIN _arch_names "_" _arch_name)
+
+    set(_stub "${CMAKE_BINARY_DIR}/${_config_subdir}dusklight-stub")
+    add_custom_command(TARGET ${target} POST_BUILD
+            COMMAND "${_symgen}" stub -f macho "${_exp}" -o "${_stub}" ${_stub_args}
+            BYPRODUCTS "${_stub}"
+            COMMENT "Generating dusklight link stub"
+            VERBATIM)
+    install(FILES "${_stub}" DESTINATION sdk RENAME "stub-${_stub_platform}-${_arch_name}")
+endfunction()
diff --git a/cmake/CopyModAssets.cmake b/cmake/CopyModAssets.cmake
new file mode 100644
index 0000000000..ca16da6018
--- /dev/null
+++ b/cmake/CopyModAssets.cmake
@@ -0,0 +1,10 @@
+# Copies a mod asset directory for packaging, skipping dotfiles and dot-directories
+# (.gitkeep, .DS_Store, ...). Usage: cmake -DSRC=<dir> -DDST=<dir> -P CopyModAssets.cmake
+file(MAKE_DIRECTORY "${DST}")
+file(GLOB_RECURSE _files RELATIVE "${SRC}" "${SRC}/*")
+foreach (_file IN LISTS _files)
+    if (NOT _file MATCHES "(^|/)\\.")
+        get_filename_component(_dir "${_file}" DIRECTORY)
+        file(COPY "${SRC}/${_file}" DESTINATION "${DST}/${_dir}")
+    endif ()
+endforeach ()
diff --git a/cmake/DetectVersion.cmake b/cmake/DetectVersion.cmake
deleted file mode 100644
index ec72a97a2e..0000000000
--- a/cmake/DetectVersion.cmake
+++ /dev/null
@@ -1,121 +0,0 @@
-# Version detection shared by the main build and the mod SDK (sdk/CMakeLists.txt)
-include_guard(GLOBAL)
-
-get_filename_component(_DUSK_VERSION_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE)
-
-set(DUSK_SENTRY_DSN "" CACHE STRING "Sentry DSN")
-set(DUSK_SENTRY_ENVIRONMENT "development" CACHE STRING "Sentry environment")
-
-set(DUSK_VERSION_OVERRIDE "" CACHE STRING "Override version string (skips git detection and format validation)")
-
-macro(detect_version)
-    if (DUSK_VERSION_OVERRIDE)
-        set(DUSK_WC_DESCRIBE "${DUSK_VERSION_OVERRIDE}")
-        set(DUSK_VERSION_STRING "0.0.0.0")
-        set(DUSK_SHORT_VERSION_STRING "0.0.0")
-        set(DUSK_VERSION_CODE "1")
-        set(DUSK_WC_REVISION "")
-        set(DUSK_WC_BRANCH "")
-        set(DUSK_WC_DATE "")
-        message(STATUS "Dusklight version overridden to ${DUSK_WC_DESCRIBE}")
-    else ()
-        # obtain revision info from git
-        find_package(Git)
-        if (GIT_FOUND)
-            # make sure version information gets re-run when the current Git HEAD changes
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT} COMMAND ${GIT_EXECUTABLE} rev-parse --git-path HEAD
-                    OUTPUT_VARIABLE dusk_git_head_filename
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-            get_filename_component(dusk_git_head_filename "${dusk_git_head_filename}" ABSOLUTE BASE_DIR "${_DUSK_VERSION_ROOT}")
-            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${dusk_git_head_filename}")
-
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT} COMMAND ${GIT_EXECUTABLE} rev-parse --symbolic-full-name HEAD
-                    OUTPUT_VARIABLE dusk_git_head_symbolic
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT}
-                    COMMAND ${GIT_EXECUTABLE} rev-parse --git-path ${dusk_git_head_symbolic}
-                    OUTPUT_VARIABLE dusk_git_head_symbolic_filename
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-            get_filename_component(dusk_git_head_symbolic_filename "${dusk_git_head_symbolic_filename}" ABSOLUTE BASE_DIR "${_DUSK_VERSION_ROOT}")
-            set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${dusk_git_head_symbolic_filename}")
-
-            # defines DUSK_WC_REVISION
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT} COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
-                    OUTPUT_VARIABLE DUSK_WC_REVISION
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-            # defines DUSK_WC_DESCRIBE
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT} COMMAND ${GIT_EXECUTABLE} describe --tags --long --dirty --match "v*"
-                    OUTPUT_VARIABLE DUSK_WC_DESCRIBE
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-            # remove the git hash, then collapse a clean "-0" suffix only
-            string(REGEX REPLACE "-[^-]+(-dirty|)$" "\\1" DUSK_WC_DESCRIBE "${DUSK_WC_DESCRIBE}")
-            string(REGEX REPLACE "-0$" "" DUSK_WC_DESCRIBE "${DUSK_WC_DESCRIBE}")
-
-            # defines DUSK_WC_BRANCH
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT} COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
-                    OUTPUT_VARIABLE DUSK_WC_BRANCH
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-            # defines DUSK_WC_DATE
-            execute_process(WORKING_DIRECTORY ${_DUSK_VERSION_ROOT} COMMAND ${GIT_EXECUTABLE} log -1 --format=%ad
-                    OUTPUT_VARIABLE DUSK_WC_DATE
-                    OUTPUT_STRIP_TRAILING_WHITESPACE)
-        else ()
-            message(STATUS "Unable to find git, commit information will not be available")
-        endif ()
-
-        if (DUSK_WC_DESCRIBE MATCHES "^v([0-9]+)\\.([0-9]+)\\.([0-9]+)([-+].*)?$")
-            set(DUSK_SHORT_VERSION_STRING "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
-            set(_ver_major ${CMAKE_MATCH_1})
-            set(_ver_minor ${CMAKE_MATCH_2})
-            set(_ver_patch ${CMAKE_MATCH_3})
-            set(DUSK_VERSION_TWEAK "0")
-            if (DUSK_WC_DESCRIBE MATCHES "^v[0-9]+\\.[0-9]+\\.[0-9]+-([0-9]+)(-dirty)?$")
-                set(DUSK_VERSION_TWEAK "${CMAKE_MATCH_1}")
-            elseif (DUSK_WC_DESCRIBE MATCHES "^v[0-9]+\\.[0-9]+\\.[0-9]+-[0-9A-Za-z.-]+-([0-9]+)(-dirty)?$")
-                set(DUSK_VERSION_TWEAK "${CMAKE_MATCH_1}")
-            endif ()
-            set(DUSK_VERSION_STRING "${DUSK_SHORT_VERSION_STRING}.${DUSK_VERSION_TWEAK}")
-            if (DUSK_VERSION_TWEAK GREATER 999)
-                set(_tweak 999)
-            else ()
-                set(_tweak ${DUSK_VERSION_TWEAK})
-            endif ()
-            # encoding: major*1e7 + minor*1e5 + patch*1e3 + tweak; collision-free for major<210, minor<100, patch<100, tweak<=999
-            math(EXPR DUSK_VERSION_CODE
-                    "${_ver_major} * 10000000 + ${_ver_minor} * 100000 + ${_ver_patch} * 1000 + ${_tweak}")
-        else ()
-            set(DUSK_WC_DESCRIBE "UNKNOWN-VERSION")
-            set(DUSK_VERSION_STRING "0.0.0.0")
-            set(DUSK_SHORT_VERSION_STRING "0.0.0")
-            set(DUSK_VERSION_CODE "1")
-        endif ()
-
-    endif ()
-
-    # Add version information to CI environment variables
-    if (DEFINED ENV{GITHUB_ENV})
-        file(APPEND "$ENV{GITHUB_ENV}" "DUSK_VERSION=${DUSK_WC_DESCRIBE}\n")
-        file(APPEND "$ENV{GITHUB_ENV}" "DUSK_VERSION_CODE=${DUSK_VERSION_CODE}\n")
-    endif ()
-    message(STATUS "Dusklight version set to ${DUSK_WC_DESCRIBE}")
-endmacro()
-
-# Sets PLATFORM_NAME and configures version.h into the caller's binary dir.
-macro(configure_version_header)
-    if (CMAKE_SYSTEM_NAME STREQUAL Windows)
-        set(PLATFORM_NAME win32)
-    elseif (CMAKE_SYSTEM_NAME STREQUAL Darwin)
-        if (IOS)
-            set(PLATFORM_NAME ios)
-        elseif (TVOS)
-            set(PLATFORM_NAME tvos)
-        else ()
-            set(PLATFORM_NAME macos)
-        endif ()
-    else ()
-        string(TOLOWER CMAKE_SYSTEM_NAME PLATFORM_NAME)
-    endif ()
-
-    configure_file(${_DUSK_VERSION_ROOT}/version.h.in ${CMAKE_CURRENT_BINARY_DIR}/version.h)
-endmacro()
diff --git a/cmake/GameABIConfig.cmake b/cmake/GameABIConfig.cmake
index 030f1181a0..ef3b5818dc 100644
--- a/cmake/GameABIConfig.cmake
+++ b/cmake/GameABIConfig.cmake
@@ -9,19 +9,60 @@ if (ANDROID)
     list(APPEND _game_compile_defs TARGET_ANDROID=1)
 endif ()
 
-set(_game_include_dirs
+# Public game headers
+set(_game_abi_include_dirs
         ${_game_root}/include
-        ${_game_root}/src
-        ${_game_root}/assets/GZ2E01 # TODO: make this dynamic if needed?
+        ${_game_root}/assets/GZ2E01
         ${_game_root}/libs/JSystem/include
-        ${_game_root}/libs
         ${_game_root}/extern/aurora/include/dolphin
         ${_game_root}/extern/aurora/include
+        ${_game_root}/sdk/include
+)
+
+# Internal game headers
+set(_game_include_dirs
+        ${_game_abi_include_dirs}
+        ${_game_root}/src
         ${_game_root}/extern
         ${CMAKE_CURRENT_BINARY_DIR}
 )
 
-# Interface target for mods and sub-projects to inherit game headers/defines.
+# Mod API, including services
+add_library(dusklight_mod_api INTERFACE)
+target_include_directories(dusklight_mod_api INTERFACE ${_game_root}/sdk/include)
+
+# Full internal headers used to build the game
 add_library(dusklight_game_headers INTERFACE)
 target_include_directories(dusklight_game_headers INTERFACE ${_game_include_dirs})
 target_compile_definitions(dusklight_game_headers INTERFACE ${_game_compile_defs})
+
+# Public game ABI for mods
+add_library(dusklight_game_abi_headers INTERFACE)
+target_include_directories(dusklight_game_abi_headers INTERFACE ${_game_abi_include_dirs})
+target_compile_definitions(dusklight_game_abi_headers INTERFACE ${_game_compile_defs})
+
+# Mod feature targets
+add_library(dusklight_mod_feature_game INTERFACE)
+target_link_libraries(dusklight_mod_feature_game INTERFACE
+        dusklight_mod_api
+        dusklight_game_abi_headers)
+target_compile_definitions(dusklight_mod_feature_game INTERFACE DUSK_MOD_FEATURE_GAME=1)
+# Game headers assume global.h comes first in the translation unit (it defines DUSK_GAME_DATA
+# and friends); force-include it so mods don't depend on include order.
+if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
+    target_compile_options(dusklight_mod_feature_game INTERFACE
+            "$<$<COMPILE_LANGUAGE:CXX>:/FIglobal.h>")
+else ()
+    target_compile_options(dusklight_mod_feature_game INTERFACE
+            "$<$<COMPILE_LANGUAGE:CXX>:SHELL:-include global.h>")
+endif ()
+target_sources(dusklight_mod_feature_game INTERFACE
+        ${_game_root}/sdk/src/game_feature.cpp)
+
+add_library(dusklight_mod_feature_webgpu INTERFACE)
+target_link_libraries(dusklight_mod_feature_webgpu INTERFACE dusklight_mod_api)
+target_compile_definitions(dusklight_mod_feature_webgpu INTERFACE DUSK_MOD_FEATURE_WEBGPU=1)
+
+add_library(dusklight_mod_feature_fmt INTERFACE)
+target_link_libraries(dusklight_mod_feature_fmt INTERFACE dusklight_mod_api)
+target_compile_definitions(dusklight_mod_feature_fmt INTERFACE DUSK_MOD_FEATURE_FMT=1)
diff --git a/cmake/ModExports.exp b/cmake/ModExports.exp
new file mode 100644
index 0000000000..3a9ec12942
--- /dev/null
+++ b/cmake/ModExports.exp
@@ -0,0 +1,5 @@
+_mod_ctx
+_mod_initialize
+_mod_meta
+_mod_shutdown
+_mod_update
diff --git a/cmake/ModExports.ver b/cmake/ModExports.ver
new file mode 100644
index 0000000000..9ddff1866c
--- /dev/null
+++ b/cmake/ModExports.ver
@@ -0,0 +1,10 @@
+{
+    global:
+        mod_ctx;
+        mod_initialize;
+        mod_meta;
+        mod_shutdown;
+        mod_update;
+    local:
+        *;
+};
diff --git a/cmake/ModSDK.cmake b/cmake/ModSDK.cmake
index c320dcb5f4..db3ca231d0 100644
--- a/cmake/ModSDK.cmake
+++ b/cmake/ModSDK.cmake
@@ -1,8 +1,11 @@
-# add_mod(<target> SOURCES <file>... MOD_JSON <mod.json> [RES_DIR <res>] [OVERLAY_DIR <overlay>]
+# add_mod(<target> [FEATURES <feature>...] SOURCES <file>... MOD_JSON <mod.json>
+#         [RUNTIME_LIBRARIES <file>...] [RES_DIR <res>] [OVERLAY_DIR <overlay>]
 #         [TEXTURES_DIR <textures>] [OUTPUT_DIR <dir>] [BUNDLE])
 set(DUSK_MODS_OUTPUT_DIR "${CMAKE_BINARY_DIR}/mods" CACHE PATH "Directory to write mod packages into")
+set(DUSKLIGHT_SDK_STUB_URL "https://github.com/encounter/dusklight/releases/download/sdk"
+        CACHE STRING "Base URL for game link stubs downloaded by out-of-tree mod builds")
 
-function(_mod_lib_name out_var)
+function(_mod_lib_info out_platform_var out_name_var)
     set(_arch "${CMAKE_SYSTEM_PROCESSOR}")
     if (APPLE AND CMAKE_OSX_ARCHITECTURES)
         list(LENGTH CMAKE_OSX_ARCHITECTURES _count)
@@ -10,20 +13,62 @@ function(_mod_lib_name out_var)
             message(FATAL_ERROR "add_mod: universal binaries are not supported")
         endif ()
         set(_arch "${CMAKE_OSX_ARCHITECTURES}")
+    elseif (WIN32)
+        set(_arch_id "${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}")
+        if (NOT _arch_id)
+            set(_arch_id "${CMAKE_C_COMPILER_ARCHITECTURE_ID}")
+        endif ()
+        if (_arch_id MATCHES "^ARM64(EC)?$")
+            set(_arch "arm64")
+        elseif (_arch_id STREQUAL "x64")
+            set(_arch "amd64")
+        elseif (_arch_id STREQUAL "X86")
+            set(_arch "x86")
+        endif ()
     endif ()
     string(TOLOWER "${CMAKE_SYSTEM_NAME}" _platform)
+    if (_platform STREQUAL "darwin")
+        set(_platform "macos")
+    endif ()
     string(TOLOWER "${_arch}" _arch)
     if (_arch MATCHES "^(i[3-6]86|x86)$")
         set(_arch "x86")
     endif ()
     if (WIN32)
         set(_ext ".dll")
-    elseif (APPLE)
-        set(_ext ".dylib")
     else ()
         set(_ext ".so")
     endif ()
-    set(${out_var} "${_platform}-${_arch}${_ext}" PARENT_SCOPE)
+    set(${out_platform_var} "${_platform}-${_arch}" PARENT_SCOPE)
+    set(${out_name_var} "mod${_ext}" PARENT_SCOPE)
+endfunction()
+
+# For out-of-tree builds without a game binary: download the version-independent link stub
+# (generated by symgen) for the target platform.
+function(_mod_download_link_stub out_var)
+    _mod_lib_info(_platform _lib_name)
+    if (WIN32)
+        set(_asset "${_platform}.lib")
+    elseif (ANDROID)
+        set(_asset "stub-${_platform}.so")
+    else ()
+        set(_asset "stub-${_platform}")
+    endif ()
+    set(_stub "${CMAKE_BINARY_DIR}/dusklight-sdk-stubs/${_asset}")
+    if (NOT EXISTS "${_stub}")
+        message(STATUS "Mod SDK: downloading link stub ${_asset}")
+        file(DOWNLOAD "${DUSKLIGHT_SDK_STUB_URL}/${_asset}" "${_stub}.tmp" STATUS _status)
+        list(GET _status 0 _code)
+        if (NOT _code EQUAL 0)
+            list(GET _status 1 _error)
+            file(REMOVE "${_stub}.tmp")
+            message(FATAL_ERROR
+                    "Mod SDK: failed to download ${DUSKLIGHT_SDK_STUB_URL}/${_asset}: ${_error}\n"
+                    "Set DUSK_GAME_EXE to a game binary or link stub to skip the download.")
+        endif ()
+        file(RENAME "${_stub}.tmp" "${_stub}")
+    endif ()
+    set(${out_var} "${_stub}" PARENT_SCOPE)
 endfunction()
 
 function(_mod_resolve_source_path out_var path)
@@ -41,11 +86,62 @@ function(_mod_collect_assets out_var dir)
     endif ()
 
     file(GLOB_RECURSE _files CONFIGURE_DEPENDS LIST_DIRECTORIES false "${dir}/*")
-    set(${out_var} ${_files} PARENT_SCOPE)
+    # Dotfiles (.gitkeep, .DS_Store, ...) are not packaged; see CopyModAssets.cmake.
+    set(_assets "")
+    foreach (_file IN LISTS _files)
+        file(RELATIVE_PATH _rel "${dir}" "${_file}")
+        if (NOT _rel MATCHES "(^|/)\\.")
+            list(APPEND _assets "${_file}")
+        endif ()
+    endforeach ()
+    set(${out_var} ${_assets} PARENT_SCOPE)
+endfunction()
+
+function(_mod_add_webgpu_headers target_name)
+    if (NOT TARGET dawn::dawncpp_headers AND NOT TARGET dawn::webgpu_dawn)
+        include("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../extern/aurora/cmake/AuroraDependencyVersions.cmake")
+        set(AURORA_DAWN_PROVIDER "package" CACHE STRING "How to provide Dawn for the mod SDK")
+        include("${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../extern/aurora/cmake/AuroraDawnProvider.cmake")
+    endif ()
+
+    if (TARGET dawn::dawncpp_headers)
+        target_link_libraries(${target_name} PRIVATE dawn::dawncpp_headers)
+    elseif (TARGET dawn::webgpu_dawn)
+        target_link_libraries(${target_name} PRIVATE dawn::webgpu_dawn)
+    else ()
+        message(FATAL_ERROR "add_mod: FEATURES webgpu could not provide WebGPU headers")
+    endif ()
+endfunction()
+
+function(_mod_add_fmt target_name)
+    if (NOT TARGET fmt::fmt-header-only)
+        find_package(fmt 11 CONFIG QUIET GLOBAL)
+    endif ()
+
+    if (NOT TARGET fmt::fmt-header-only)
+        include(FetchContent)
+        message(STATUS "Mod SDK: fetching fmt")
+        # Keep the fallback version in sync with extern/aurora/extern/CMakeLists.txt.
+        FetchContent_Declare(fmt
+                URL https://github.com/fmtlib/fmt/archive/refs/tags/12.1.0.tar.gz
+                URL_HASH SHA256=ea7de4299689e12b6dddd392f9896f08fb0777ac7168897a244a6d6085043fea
+                DOWNLOAD_EXTRACT_TIMESTAMP FALSE
+                EXCLUDE_FROM_ALL)
+        FetchContent_MakeAvailable(fmt)
+    endif ()
+
+    if (NOT TARGET fmt::fmt-header-only)
+        message(FATAL_ERROR "add_mod: FEATURES fmt could not provide fmt::fmt-header-only")
+    endif ()
+    target_link_libraries(${target_name} PRIVATE fmt::fmt-header-only)
 endfunction()
 
 function(add_mod target_name)
-    cmake_parse_arguments(ARG "BUNDLE" "MOD_JSON;RES_DIR;OVERLAY_DIR;TEXTURES_DIR;OUTPUT_DIR" "SOURCES" ${ARGN})
+    cmake_parse_arguments(ARG "BUNDLE" "MOD_JSON;RES_DIR;OVERLAY_DIR;TEXTURES_DIR;OUTPUT_DIR"
+            "SOURCES;RUNTIME_LIBRARIES;FEATURES" ${ARGN})
+    if (ARG_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "add_mod: unknown arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif ()
     if (NOT ARG_MOD_JSON)
         message(FATAL_ERROR "add_mod: MOD_JSON is required")
     endif ()
@@ -54,80 +150,156 @@ function(add_mod target_name)
         message(FATAL_ERROR "add_mod: MOD_JSON does not exist: ${_mod_json}")
     endif ()
 
-    add_library(${target_name} SHARED ${ARG_SOURCES})
-    _mod_lib_name(_lib_name)
-    set_target_properties(${target_name} PROPERTIES
-            PREFIX ""
-            C_VISIBILITY_PRESET hidden
-            CXX_VISIBILITY_PRESET hidden
-            VISIBILITY_INLINES_HIDDEN ON
-            WINDOWS_EXPORT_ALL_SYMBOLS OFF)
-    target_compile_features(${target_name} PRIVATE cxx_std_20)
-    target_link_libraries(${target_name} PRIVATE dusklight_game_headers)
-
-    if (NOT TARGET dusklight)
-        # Apply global compile options for out-of-tree mod builds
-        if (CMAKE_SYSTEM_NAME STREQUAL Linux)
-            target_compile_options(${target_name} PRIVATE
-                    -Wno-multichar -Wno-trigraphs -Wno-deprecated-declarations)
-        elseif (APPLE)
-            target_compile_options(${target_name} PRIVATE
-                    -Wno-declaration-after-statement -Wno-non-pod-varargs)
-        elseif (MSVC)
-            target_compile_options(${target_name} PRIVATE
-                    "$<$<COMPILE_LANGUAGE:C,CXX>:/bigobj>"
-                    "$<$<COMPILE_LANGUAGE:C,CXX>:/utf-8>")
+    set(_supported_features fmt game webgpu)
+    set(_features "")
+    foreach (_feature IN LISTS ARG_FEATURES)
+        list(FIND _supported_features "${_feature}" _feature_index)
+        if (_feature_index EQUAL -1)
+            list(JOIN _supported_features ", " _supported_features_text)
+            message(FATAL_ERROR
+                    "add_mod: unknown feature '${_feature}' (supported: ${_supported_features_text})")
         endif ()
-        # Use signed char on ARM to match the original game (and x86)
-        string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _mod_arch)
-        if (_mod_arch MATCHES "^(arm|aarch64)" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
-            target_compile_options(${target_name} PRIVATE -fsigned-char)
+        list(FIND _features "${_feature}" _duplicate_index)
+        if (NOT _duplicate_index EQUAL -1)
+            message(FATAL_ERROR "add_mod: duplicate feature '${_feature}'")
         endif ()
+        list(APPEND _features "${_feature}")
+    endforeach ()
+    if (_features AND NOT ARG_SOURCES)
+        message(FATAL_ERROR "add_mod: FEATURES requires SOURCES")
     endif ()
 
-    if (APPLE)
-        # Game symbols resolve against the host executable at dlopen time.
-        target_link_options(${target_name} PRIVATE -undefined dynamic_lookup)
-    elseif (ANDROID)
-        if (TARGET dusklight)
-            target_link_libraries(${target_name} PRIVATE dusklight)
-        elseif (DUSK_GAME_SOLIB)
-            target_link_libraries(${target_name} PRIVATE "${DUSK_GAME_SOLIB}")
-        else ()
-            message(FATAL_ERROR "add_mod: DUSK_GAME_SOLIB is not set (libmain.so)")
+    set(_has_lib FALSE)
+    set(_needs_host_link FALSE)
+    set(_lib_platform "")
+    set(_lib_name "")
+    if (ARG_SOURCES)
+        set(_has_lib TRUE)
+        add_library(${target_name} MODULE ${ARG_SOURCES})
+        _mod_lib_info(_lib_platform _lib_name)
+        set_target_properties(${target_name} PROPERTIES
+                PREFIX ""
+                C_VISIBILITY_PRESET hidden
+                CXX_VISIBILITY_PRESET hidden
+                VISIBILITY_INLINES_HIDDEN ON
+                WINDOWS_EXPORT_ALL_SYMBOLS OFF)
+        target_compile_features(${target_name} PRIVATE cxx_std_20)
+        target_link_libraries(${target_name} PRIVATE dusklight_mod_api)
+
+        if (APPLE)
+            set(_mod_exports "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/ModExports.exp")
+            target_link_options(${target_name} PRIVATE
+                    -Xlinker -exported_symbols_list -Xlinker "${_mod_exports}")
+            set_property(TARGET ${target_name} APPEND PROPERTY LINK_DEPENDS "${_mod_exports}")
+        elseif (UNIX)
+            set(_mod_exports "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/ModExports.ver")
+            target_link_options(${target_name} PRIVATE
+                    "-Wl,--version-script=${_mod_exports}"
+                    -Wl,--no-undefined-version)
+            set_property(TARGET ${target_name} APPEND PROPERTY LINK_DEPENDS "${_mod_exports}")
         endif ()
-    elseif (UNIX)
-        target_link_options(${target_name} PRIVATE -Wl,--allow-shlib-undefined)
-    elseif (WIN32)
-        # Link against the generated import library (game ABI surface). Function calls
-        # resolve through import thunks. Data is toolchain dependent:
-        # - clang-cl: lld's mingw mode auto-imports data references, fixed up at load by
-        #   the mod SDK's pseudo-relocation runtime (pseudo_reloc.cpp).
-        # - cl (MSVC): only DUSK_GAME_DATA-annotated data is reachable. Un-annotated
-        #   references fail to link.
-        if (NOT DUSK_GAME_IMPLIB)
-            message(FATAL_ERROR "add_mod: DUSK_GAME_IMPLIB is not set.")
-        endif ()
-        target_link_libraries(${target_name} PRIVATE "${DUSK_GAME_IMPLIB}")
-        set_target_properties(${target_name} PROPERTIES MSVC_RUNTIME_LIBRARY "MultiThreadedDLL")
-        target_compile_definitions(${target_name} PRIVATE _ITERATOR_DEBUG_LEVEL=0)
-        if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-            target_compile_options(${target_name} PRIVATE "$<$<COMPILE_LANGUAGE:C,CXX>:/clang:-mcmodel=large>")
-            target_sources(${target_name} PRIVATE "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/../sdk/pseudo_reloc.cpp")
-            # lld mingw mode rewrites /DEFAULTLIB directives to -l style and skips %LIB%, so
-            # the CRT libraries and search paths are spelled out explicitly.
-            target_link_options(${target_name} PRIVATE -lldmingw /nodefaultlib /INCREMENTAL:NO)
-            target_link_libraries(${target_name} PRIVATE
-                    msvcrt.lib msvcprt.lib vcruntime.lib ucrt.lib
-                    oldnames.lib uuid.lib kernel32.lib user32.lib)
-            set(_lib_dirs "$ENV{LIB}")
-            if ("${_lib_dirs}" STREQUAL "")
-                message(FATAL_ERROR "add_mod: %LIB% is empty; configure from a VS dev shell")
+
+        foreach (_feature IN LISTS _features)
+            target_link_libraries(${target_name} PRIVATE dusklight_mod_feature_${_feature})
+            if (_feature STREQUAL "webgpu")
+                _mod_add_webgpu_headers(${target_name})
+            endif ()
+            if (_feature STREQUAL "fmt")
+                _mod_add_fmt(${target_name})
+            endif ()
+            if (_feature STREQUAL "game" OR _feature STREQUAL "webgpu")
+                set(_needs_host_link TRUE)
+            endif ()
+        endforeach ()
+
+        if (NOT TARGET dusklight)
+            # Apply global compile options for out-of-tree mod builds
+            if (CMAKE_SYSTEM_NAME STREQUAL Linux)
+                target_compile_options(${target_name} PRIVATE
+                        -Wno-multichar -Wno-trigraphs -Wno-deprecated-declarations)
+            elseif (APPLE)
+                target_compile_options(${target_name} PRIVATE
+                        -Wno-declaration-after-statement -Wno-non-pod-varargs)
+            elseif (MSVC)
+                target_compile_options(${target_name} PRIVATE
+                        "$<$<COMPILE_LANGUAGE:C,CXX>:/bigobj>"
+                        "$<$<COMPILE_LANGUAGE:C,CXX>:/utf-8>")
+            endif ()
+            # Use signed char on ARM to match the original game (and x86)
+            string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _mod_arch)
+            if (_mod_arch MATCHES "^(arm|aarch64)" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
+                target_compile_options(${target_name} PRIVATE -fsigned-char)
             endif ()
-            foreach (_libdir IN LISTS _lib_dirs)
-                target_link_options(${target_name} PRIVATE "/libpath:${_libdir}")
-            endforeach ()
         endif ()
+
+        if (APPLE)
+            if (_needs_host_link)
+                if (TARGET dusklight)
+                    set(_game_exe "$<TARGET_FILE:dusklight>")
+                    add_dependencies(${target_name} dusklight)
+                elseif (DUSK_GAME_EXE)
+                    _mod_resolve_source_path(_game_exe "${DUSK_GAME_EXE}")
+                else ()
+                    _mod_download_link_stub(_game_exe)
+                endif ()
+                target_link_options(${target_name} PRIVATE
+                        -Xlinker -bundle_loader -Xlinker "${_game_exe}")
+                set_property(TARGET ${target_name} APPEND PROPERTY LINK_DEPENDS "${_game_exe}")
+            endif ()
+            set_target_properties(${target_name} PROPERTIES
+                    BUILD_RPATH "@loader_path"
+                    INSTALL_RPATH "@loader_path")
+        elseif (ANDROID)
+            if (_needs_host_link)
+                if (TARGET dusklight)
+                    target_link_libraries(${target_name} PRIVATE dusklight)
+                else ()
+                    if (DUSK_GAME_EXE)
+                        _mod_resolve_source_path(_game_lib "${DUSK_GAME_EXE}")
+                    else ()
+                        _mod_download_link_stub(_game_lib)
+                    endif ()
+                    target_link_libraries(${target_name} PRIVATE "${_game_lib}")
+                endif ()
+            endif ()
+            set_target_properties(${target_name} PROPERTIES
+                    BUILD_RPATH "$ORIGIN"
+                    INSTALL_RPATH "$ORIGIN")
+        elseif (UNIX)
+            if (_needs_host_link)
+                target_link_options(${target_name} PRIVATE -Wl,--allow-shlib-undefined)
+            endif ()
+            set_target_properties(${target_name} PROPERTIES
+                    BUILD_RPATH "$ORIGIN"
+                    INSTALL_RPATH "$ORIGIN")
+        elseif (WIN32)
+            # Mods link against the game's import library (sdk/windows-<arch>.lib, generated by
+            # setup_windows_exports); cl and clang-cl both consume it in MSVC mode. Function
+            # calls resolve through import thunks; game data is reachable only through
+            # __declspec(dllimport), i.e. DUSK_GAME_DATA-annotated declarations.
+            if (_needs_host_link)
+                if (TARGET dusklight)
+                    if (NOT DUSK_GAME_IMPLIB)
+                        message(FATAL_ERROR
+                                "add_mod: DUSK_GAME_IMPLIB is not set (see setup_windows_exports)")
+                    endif ()
+                    set(_game_lib "${DUSK_GAME_IMPLIB}")
+                elseif (DUSK_GAME_EXE)
+                    _mod_resolve_source_path(_game_lib "${DUSK_GAME_EXE}")
+                    if (NOT _game_lib MATCHES "\\.lib$")
+                        message(FATAL_ERROR
+                                "add_mod: DUSK_GAME_EXE must be an import library on Windows "
+                                "(sdk/windows-<arch>.lib)")
+                    endif ()
+                else ()
+                    _mod_download_link_stub(_game_lib)
+                endif ()
+                target_link_libraries(${target_name} PRIVATE "${_game_lib}")
+            endif ()
+        endif ()
+    endif ()
+    if (ARG_RUNTIME_LIBRARIES AND NOT _has_lib)
+        message(FATAL_ERROR "add_mod: RUNTIME_LIBRARIES requires SOURCES")
     endif ()
 
     set(_output_dir "${DUSK_MODS_OUTPUT_DIR}")
@@ -137,18 +309,52 @@ function(add_mod target_name)
     set(_stage "${CMAKE_CURRENT_BINARY_DIR}/${target_name}_stage")
     set(_out "${_output_dir}/${target_name}.dusk")
 
-    set(_zip_args "${_lib_name}" mod.json)
+    set(_zip_args mod.json)
     set(_package_deps "${_mod_json}")
     set(_package_inputs "${_mod_json}")
     set(_extra_cmds "")
+    set(_lib_copy_cmd "")
+    set(_lib_strip_cmd "")
+    set(_target_depend "")
+    if (_has_lib)
+        list(APPEND _zip_args lib)
+        set(_lib_copy_cmd
+                COMMAND ${CMAKE_COMMAND} -E make_directory "${_stage}/lib/${_lib_platform}"
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "$<TARGET_FILE:${target_name}>" "${_stage}/lib/${_lib_platform}/${_lib_name}")
+        if (UNIX AND NOT APPLE)
+            set(_lib_strip_cmd COMMAND "${CMAKE_STRIP}" --strip-unneeded
+                    "${_stage}/lib/${_lib_platform}/${_lib_name}")
+        endif ()
+        set(_target_depend ${target_name})
+    endif ()
+    string(TOLOWER "${_lib_name}" _lib_name_key)
+    set(_runtime_lib_name_keys "${_lib_name_key}")
+    foreach (_runtime_lib IN LISTS ARG_RUNTIME_LIBRARIES)
+        _mod_resolve_source_path(_runtime_lib_path "${_runtime_lib}")
+        if (NOT EXISTS "${_runtime_lib_path}" OR IS_DIRECTORY "${_runtime_lib_path}")
+            message(FATAL_ERROR "add_mod: runtime library does not exist or is not a file: ${_runtime_lib_path}")
+        endif ()
+        get_filename_component(_runtime_lib_name "${_runtime_lib_path}" NAME)
+        string(TOLOWER "${_runtime_lib_name}" _runtime_lib_name_key)
+        list(FIND _runtime_lib_name_keys "${_runtime_lib_name_key}" _runtime_lib_name_index)
+        if (NOT _runtime_lib_name_index EQUAL -1)
+            message(FATAL_ERROR "add_mod: duplicate runtime library filename: ${_runtime_lib_name}")
+        endif ()
+        list(APPEND _runtime_lib_name_keys "${_runtime_lib_name_key}")
+        list(APPEND _package_deps "${_runtime_lib_path}")
+        list(APPEND _package_inputs "${_runtime_lib_path}")
+        list(APPEND _lib_copy_cmd COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "${_runtime_lib_path}" "${_stage}/lib/${_lib_platform}/${_runtime_lib_name}")
+    endforeach ()
     if (ARG_RES_DIR)
         _mod_resolve_source_path(_res_dir "${ARG_RES_DIR}")
         _mod_collect_assets(_res_deps "${_res_dir}")
         list(APPEND _package_deps ${_res_deps})
         list(APPEND _package_inputs "${_res_dir}" ${_res_deps})
         list(APPEND _zip_args res)
-        list(APPEND _extra_cmds COMMAND ${CMAKE_COMMAND} -E copy_directory
-                "${_res_dir}" "${_stage}/res")
+        list(APPEND _extra_cmds COMMAND ${CMAKE_COMMAND} "-DSRC=${_res_dir}"
+                "-DDST=${_stage}/res" -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/CopyModAssets.cmake")
     endif ()
     if (ARG_OVERLAY_DIR)
         _mod_resolve_source_path(_overlay_dir "${ARG_OVERLAY_DIR}")
@@ -156,8 +362,8 @@ function(add_mod target_name)
         list(APPEND _package_deps ${_overlay_deps})
         list(APPEND _package_inputs "${_overlay_dir}" ${_overlay_deps})
         list(APPEND _zip_args overlay)
-        list(APPEND _extra_cmds COMMAND ${CMAKE_COMMAND} -E copy_directory
-                "${_overlay_dir}" "${_stage}/overlay")
+        list(APPEND _extra_cmds COMMAND ${CMAKE_COMMAND} "-DSRC=${_overlay_dir}"
+                "-DDST=${_stage}/overlay" -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/CopyModAssets.cmake")
     endif ()
     if (ARG_TEXTURES_DIR)
         _mod_resolve_source_path(_textures_dir "${ARG_TEXTURES_DIR}")
@@ -165,8 +371,8 @@ function(add_mod target_name)
         list(APPEND _package_deps ${_textures_deps})
         list(APPEND _package_inputs "${_textures_dir}" ${_textures_deps})
         list(APPEND _zip_args textures)
-        list(APPEND _extra_cmds COMMAND ${CMAKE_COMMAND} -E copy_directory
-                "${_textures_dir}" "${_stage}/textures")
+        list(APPEND _extra_cmds COMMAND ${CMAKE_COMMAND} "-DSRC=${_textures_dir}"
+                "-DDST=${_stage}/textures" -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/CopyModAssets.cmake")
     endif ()
 
     set(_bundle_cmds "")
@@ -177,6 +383,7 @@ function(add_mod target_name)
         set_property(GLOBAL APPEND PROPERTY DUSK_BUNDLED_MOD_IDS "${_mod_id}")
         set_property(GLOBAL APPEND PROPERTY DUSK_BUNDLED_MOD_STAGES "${_stage}")
         set_property(GLOBAL APPEND PROPERTY DUSK_BUNDLED_MOD_PACKAGES "${_out}")
+        set_property(GLOBAL APPEND PROPERTY DUSK_BUNDLED_MOD_LIB_PLATFORMS "${_lib_platform}")
         set_property(GLOBAL APPEND PROPERTY DUSK_BUNDLED_MOD_LIB_NAMES "${_lib_name}")
         set(_bundle_cmds
                 COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bundled_mods"
@@ -194,12 +401,13 @@ function(add_mod target_name)
     add_custom_command(OUTPUT "${_out}"
             COMMAND ${CMAKE_COMMAND} -E rm -rf "${_stage}"
             COMMAND ${CMAKE_COMMAND} -E make_directory "${_stage}" "${_output_dir}"
-            COMMAND ${CMAKE_COMMAND} -E copy_if_different "$<TARGET_FILE:${target_name}>" "${_stage}/${_lib_name}"
+            ${_lib_copy_cmd}
+            ${_lib_strip_cmd}
             COMMAND ${CMAKE_COMMAND} -E copy_if_different "${_mod_json}" "${_stage}/mod.json"
             ${_extra_cmds}
             COMMAND ${CMAKE_COMMAND} -E chdir "${_stage}" ${CMAKE_COMMAND} -E tar cvf "${_out}" --format=zip ${_zip_args}
             ${_bundle_cmds}
-            DEPENDS ${target_name} ${_package_deps} "${_package_inputs_file}"
+            DEPENDS ${_target_depend} ${_package_deps} "${_package_inputs_file}"
             COMMENT "Packaging ${target_name} -> ${_out}"
             COMMAND_EXPAND_LISTS
             VERBATIM
@@ -215,9 +423,10 @@ endfunction()
 #   user cache).
 # - Linux: pre-extracted stage dirs into <install>/mods so native libs dlopen in place from
 #   read-only installs.
-# - macOS: pre-extracted stage dirs into the installed app's Contents/Resources/mods, dylibs
-#   ad-hoc signed in place, then the whole bundle re-signed.
-# - iOS/tvOS: assets into <app>/mods/<id> and the dylib into Frameworks/<id>.dylib.
+# - macOS: pre-extracted stage dirs into the installed app's Contents/Resources/mods, native
+#   libs ad-hoc signed in place, then the whole bundle re-signed.
+# - iOS/tvOS: assets into <app>/mods/<id>, the mod library into Frameworks/<id>.so,
+#   and runtime libraries alongside it.
 # - Android: nothing here; gradle packs ${CMAKE_BINARY_DIR}/bundled_mods into APK assets.
 function(install_bundled_mods)
     get_property(_targets GLOBAL PROPERTY DUSK_BUNDLED_MOD_TARGETS)
@@ -226,6 +435,7 @@ function(install_bundled_mods)
     endif ()
     get_property(_ids GLOBAL PROPERTY DUSK_BUNDLED_MOD_IDS)
     get_property(_stages GLOBAL PROPERTY DUSK_BUNDLED_MOD_STAGES)
+    get_property(_lib_platforms GLOBAL PROPERTY DUSK_BUNDLED_MOD_LIB_PLATFORMS)
     get_property(_lib_names GLOBAL PROPERTY DUSK_BUNDLED_MOD_LIB_NAMES)
     list(LENGTH _targets _count)
     math(EXPR _last "${_count} - 1")
@@ -241,20 +451,67 @@ function(install_bundled_mods)
                 list(GET _targets ${_i} _target)
                 list(GET _ids ${_i} _id)
                 list(GET _stages ${_i} _stage)
+                list(GET _lib_platforms ${_i} _lib_platform)
                 list(GET _lib_names ${_i} _lib_name)
                 install(DIRECTORY "${_stage}/" DESTINATION "${_bundle_dir}/mods/${_id}"
-                        PATTERN "${_lib_name}" EXCLUDE)
+                        PATTERN "lib" EXCLUDE)
                 install(PROGRAMS "$<TARGET_FILE:${_target}>"
-                        DESTINATION "${_bundle_dir}/Frameworks" RENAME "${_id}.dylib")
+                        DESTINATION "${_bundle_dir}/Frameworks" RENAME "${_id}.so")
+                install(DIRECTORY "${_stage}/lib/${_lib_platform}/"
+                        DESTINATION "${_bundle_dir}/Frameworks"
+                        PATTERN "${_lib_name}" EXCLUDE)
             endforeach ()
+            if (DUSK_HAS_PREPATCH)
+                set(_prepatch_executable "${_bundle_dir}/Dusklight")
+                set(_prepatch_mod_args "")
+                foreach (_id IN LISTS _ids)
+                    string(APPEND _prepatch_mod_args
+                            " \"${_bundle_dir}/Frameworks/${_id}.so\"")
+                endforeach ()
+                install(CODE "
+                    execute_process(
+                        COMMAND \"${SYMGEN_EXE}\" prepatch
+                            --binary \"${_prepatch_executable}\"
+                            --report \"${CMAKE_BINARY_DIR}/prepatch-report-$<CONFIG>.json\"
+                            ${_prepatch_mod_args}
+                        COMMAND_ERROR_IS_FATAL ANY)")
+            endif ()
         else ()
             foreach (_i RANGE ${_last})
                 list(GET _ids ${_i} _id)
                 list(GET _stages ${_i} _stage)
+                list(GET _lib_platforms ${_i} _lib_platform)
                 list(GET _lib_names ${_i} _lib_name)
                 install(DIRECTORY "${_stage}/" DESTINATION "${_bundle_dir}/Contents/Resources/mods/${_id}")
-                install(CODE "execute_process(COMMAND /usr/bin/codesign --force --sign - \"${_bundle_dir}/Contents/Resources/mods/${_id}/${_lib_name}\" COMMAND_ERROR_IS_FATAL ANY)")
+                install(CODE "
+                    file(GLOB _mod_libs \"${_bundle_dir}/Contents/Resources/mods/${_id}/lib/${_lib_platform}/*\")
+                    foreach (_mod_lib IN LISTS _mod_libs)
+                        if (NOT IS_DIRECTORY \"\${_mod_lib}\")
+                            execute_process(COMMAND /usr/bin/codesign --force --sign - \"\${_mod_lib}\" COMMAND_ERROR_IS_FATAL ANY)
+                        endif ()
+                    endforeach ()")
             endforeach ()
+            if (DUSK_HAS_PREPATCH)
+                set(_prepatch_executable "${_bundle_dir}/Contents/MacOS/Dusklight")
+                set(_prepatch_mod_args "")
+                foreach (_i RANGE ${_last})
+                    list(GET _ids ${_i} _id)
+                    list(GET _lib_platforms ${_i} _lib_platform)
+                    list(GET _lib_names ${_i} _lib_name)
+                    string(APPEND _prepatch_mod_args
+                            " \"${_bundle_dir}/Contents/Resources/mods/${_id}/lib/${_lib_platform}/${_lib_name}\"")
+                endforeach ()
+                install(CODE "
+                    execute_process(
+                        COMMAND \"${SYMGEN_EXE}\" prepatch
+                            --binary \"${_prepatch_executable}\"
+                            --report \"${CMAKE_BINARY_DIR}/prepatch-report-$<CONFIG>.json\"
+                            ${_prepatch_mod_args}
+                        COMMAND_ERROR_IS_FATAL ANY)")
+            endif ()
+            if (TARGET crashpad_handler)
+                install(CODE "execute_process(COMMAND /usr/bin/codesign --force --sign - \"${_bundle_dir}/Contents/MacOS/$<TARGET_FILE_NAME:crashpad_handler>\" COMMAND_ERROR_IS_FATAL ANY)")
+            endif ()
             install(CODE "execute_process(COMMAND /usr/bin/codesign --force --sign - --entitlements \"${DUSK_ENTITLEMENTS}\" \"${_bundle_dir}\" COMMAND_ERROR_IS_FATAL ANY)")
         endif ()
         return ()
diff --git a/cmake/PatchFunchook.cmake b/cmake/PatchFunchook.cmake
index 6d5a6e36b4..cbd91fc38e 100644
--- a/cmake/PatchFunchook.cmake
+++ b/cmake/PatchFunchook.cmake
@@ -2,59 +2,55 @@ file(READ "${SOURCE_DIR}/cmake/capstone.cmake.in" _content)
 
 # Insert PATCH_COMMAND before CONFIGURE_COMMAND in the ExternalProject_Add.
 # Bracket args prevent cmake from substituting ${...} while writing this file.
-string(REPLACE
-    "    CONFIGURE_COMMAND \"\""
-    [=[    PATCH_COMMAND "${CMAKE_COMMAND}" -DDIR=${CMAKE_CURRENT_BINARY_DIR}/capstone-src -P "${CAPSTONE_FIX_SCRIPT}"
+if (NOT _content MATCHES "CAPSTONE_FIX_SCRIPT")
+    string(REPLACE
+        "    CONFIGURE_COMMAND \"\""
+        [=[    PATCH_COMMAND "${CMAKE_COMMAND}" -DDIR=${CMAKE_CURRENT_BINARY_DIR}/capstone-src -P "${CAPSTONE_FIX_SCRIPT}"
     CONFIGURE_COMMAND ""]=]
-    _content "${_content}")
-
-file(WRITE "${SOURCE_DIR}/cmake/capstone.cmake.in" "${_content}")
-
-file(READ "${SOURCE_DIR}/src/funchook_unix.c" _unix_content)
-
-# macOS rejects the POSIX mprotect RWX/RW transition for executable image pages on arm64.
-# Use Mach VM_PROT_COPY for the short patch window, then restore RX permissions.
-if (NOT _unix_content MATCHES "VM_PROT_READ \\| VM_PROT_WRITE \\| VM_PROT_COPY")
-    string(REPLACE
-        [=[    rv = mprotect(mstate->addr, mstate->size, prot);]=]
-        [=[#ifdef __APPLE__
-    kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)mstate->addr,
-                                  (vm_size_t)mstate->size, FALSE,
-                                  VM_PROT_READ | VM_PROT_WRITE | VM_PROT_COPY);
-    if (kr == KERN_SUCCESS) {
-        funchook_log(funchook, "  unprotect memory %p (size=%"PRIuPTR", prot=read,write,copy) <- %p (size=%"PRIuPTR")\n",
-                     mstate->addr, mstate->size, start, len);
-        return 0;
-    }
-    funchook_set_error_message(funchook, "Failed to unprotect memory %p (size=%"PRIuPTR", prot=read,write,copy) <- %p (size=%"PRIuPTR", error=%s)",
-                               mstate->addr, mstate->size, start, len,
-                               mach_error_string(kr));
-    return FUNCHOOK_ERROR_MEMORY_FUNCTION;
-#endif
-    rv = mprotect(mstate->addr, mstate->size, prot);]=]
-        _unix_content "${_unix_content}")
-
-    string(REPLACE
-        [=[    char errbuf[128];
-    int rv = mprotect(mstate->addr, mstate->size, PROT_READ | PROT_EXEC);]=]
-        [=[    char errbuf[128];
-#ifdef __APPLE__
-    kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)mstate->addr,
-                                  (vm_size_t)mstate->size, FALSE,
-                                  VM_PROT_READ | VM_PROT_EXECUTE);
-
-    if (kr == KERN_SUCCESS) {
-        funchook_log(funchook, "  protect memory %p (size=%"PRIuPTR", prot=read,exec)\n",
-                     mstate->addr, mstate->size);
-        return 0;
-    }
-    funchook_set_error_message(funchook, "Failed to protect memory %p (size=%"PRIuPTR", prot=read,exec, error=%s)",
-                               mstate->addr, mstate->size,
-                               mach_error_string(kr));
-    return FUNCHOOK_ERROR_MEMORY_FUNCTION;
-#endif
-    int rv = mprotect(mstate->addr, mstate->size, PROT_READ | PROT_EXEC);]=]
-        _unix_content "${_unix_content}")
+        _content "${_content}")
+    file(WRITE "${SOURCE_DIR}/cmake/capstone.cmake.in" "${_content}")
 endif ()
 
-file(WRITE "${SOURCE_DIR}/src/funchook_unix.c" "${_unix_content}")
+file(READ "${SOURCE_DIR}/src/funchook.c" _content)
+if (NOT _content MATCHES "commit_code_patch")
+    string(REPLACE "#include \"funchook_internal.h\""
+        "#include \"funchook_internal.h\"\n#ifdef __APPLE__\n#include \"code_patch_macos.hpp\"\n#endif"
+        _content "${_content}")
+
+    foreach(_operation install uninstall)
+        if (_operation STREQUAL "install")
+            set(_expected old_code)
+            set(_replacement new_code)
+        else ()
+            set(_expected new_code)
+            set(_replacement old_code)
+        endif ()
+        set(_original "            mem_state_t mstate;
+            int rv = funchook_unprotect_begin(funchook, &mstate, entry->target_func, JUMP32_BYTE_SIZE);
+
+            if (rv != 0) {
+                return rv;
+            }
+            memcpy(entry->target_func, entry->${_replacement}, JUMP32_BYTE_SIZE);
+            rv = funchook_unprotect_end(funchook, &mstate);
+            if (rv != 0) {
+                return rv;
+            }
+            flush_instruction_cache(entry->target_func, JUMP32_BYTE_SIZE);")
+        string(FIND "${_content}" "${_original}" _position)
+        if (_position EQUAL -1)
+            message(FATAL_ERROR "Funchook ${_operation} patch site changed")
+        endif ()
+        string(REPLACE "${_original}" "#ifdef __APPLE__
+            int rv = commit_code_patch(entry->target_func, entry->${_expected},
+                                            entry->${_replacement}, JUMP32_BYTE_SIZE);
+            if (rv != 0) {
+                funchook_set_error_message(funchook, \"Code patch commit failed (Mach error %d)\", rv);
+                return FUNCHOOK_ERROR_MEMORY_FUNCTION;
+            }
+#else
+${_original}
+#endif" _content "${_content}")
+    endforeach ()
+    file(WRITE "${SOURCE_DIR}/src/funchook.c" "${_content}")
+endif ()
diff --git a/cmake/SymbolManifest.cmake b/cmake/SymbolManifest.cmake
index ffaae9177e..7c7e09eaa1 100644
--- a/cmake/SymbolManifest.cmake
+++ b/cmake/SymbolManifest.cmake
@@ -2,40 +2,50 @@ include_guard(GLOBAL)
 
 get_filename_component(_SYMBOL_MANIFEST_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
 
-set(_SYMGEN_VERSION "1.1.0")
+set(_SYMGEN_VERSION "1.3.4")
 set(_SYMGEN_RELEASE_BASE_URL "https://github.com/encounter/symgen/releases/download/v${_SYMGEN_VERSION}")
 set(SYMGEN_PATH "" CACHE FILEPATH "Path to a symgen executable; empty downloads the pinned release")
 mark_as_advanced(SYMGEN_PATH)
 
-function(symgen_host_asset out_name)
+function(symgen_host_asset out_name out_hash)
     string(TOLOWER "${CMAKE_HOST_SYSTEM_PROCESSOR}" _host_processor)
     set(_asset "")
+    set(_asset_hash "")
 
     if (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
         if (_host_processor MATCHES "^(arm64|aarch64)$")
             set(_asset "symgen-macos-arm64")
+            set(_asset_hash "SHA256=983ef6278d30bee38f240f451ca736fd294da0e5705ee15029accac5c7a33829")
         elseif (_host_processor MATCHES "^(x86_64|amd64)$")
             set(_asset "symgen-macos-x86_64")
+            set(_asset_hash "SHA256=b6ab1720a4f04fadcf291f42d133e2ee68ef2e9a75d143e51584929e808af8a2")
         endif ()
     elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
         if (_host_processor MATCHES "^(aarch64|arm64)$")
             set(_asset "symgen-linux-aarch64")
+            set(_asset_hash "SHA256=ba84486ff1ceb753973e6213c9bc5f195b5ff6f220f5d3322fd861966cdc791c")
         elseif (_host_processor MATCHES "^(x86_64|amd64)$")
             set(_asset "symgen-linux-x86_64")
+            set(_asset_hash "SHA256=8b81a00a2ef8f5dd4b59adba1badfaca57e472bf272516bc12c4625cefb37718")
         elseif (_host_processor MATCHES "^(i[3-6]86|x86)$")
             set(_asset "symgen-linux-i686")
+            set(_asset_hash "SHA256=01aa85d84148a6806fdf69839dea7e962e6ac46956aed63b9ecb7d596f179f93")
         endif ()
     elseif (CMAKE_HOST_WIN32)
         if (_host_processor MATCHES "^(arm64|aarch64)$")
             set(_asset "symgen-windows-arm64.exe")
+            set(_asset_hash "SHA256=e116099f859177d7e29fc3444d67083596330e5c4fb3a0461b21402c89249d96")
         elseif (_host_processor MATCHES "^(x86_64|amd64)$")
             set(_asset "symgen-windows-x86_64.exe")
+            set(_asset_hash "SHA256=57ef1c2f563e33fa4915c40194c4ced540f985c48d9cf081047c6bbcb585fa37")
         elseif (_host_processor MATCHES "^(i[3-6]86|x86)$")
             set(_asset "symgen-windows-x86.exe")
+            set(_asset_hash "SHA256=cc0ba337c798d3f63d8acbb2d16d531d0c2da878fbdd2b6307702334ec880528")
         endif ()
     endif ()
 
     set(${out_name} "${_asset}" PARENT_SCOPE)
+    set(${out_hash} "${_asset_hash}" PARENT_SCOPE)
 endfunction()
 
 function(ensure_symgen required)
@@ -54,7 +64,7 @@ function(ensure_symgen required)
             return()
         endif ()
     else ()
-        symgen_host_asset(_asset)
+        symgen_host_asset(_asset _asset_hash)
         if (_asset STREQUAL "")
             if (required)
                 message(FATAL_ERROR "symgen: no prebuilt binary for host "
@@ -75,7 +85,8 @@ function(ensure_symgen required)
         file(DOWNLOAD "${_url}" "${_symgen}"
                 TLS_VERIFY ON
                 STATUS _download_status
-                SHOW_PROGRESS)
+                SHOW_PROGRESS
+                EXPECTED_HASH "${_asset_hash}")
         list(GET _download_status 0 _download_code)
         if (NOT _download_code EQUAL 0)
             list(GET _download_status 1 _download_message)
@@ -106,20 +117,37 @@ function(setup_symbol_manifest target)
     endif ()
     add_dependencies(${target} symgen)
 
-    if (WIN32)
-        set(_input --pdb "$<TARGET_PDB_FILE:${target}>")
-        set(_out "$<TARGET_FILE_DIR:${target}>/dusklight.symdb")
-    else ()
-        set(_input --binary "$<TARGET_FILE:${target}>")
-        if (APPLE)
-            set(_out "$<TARGET_BUNDLE_CONTENT_DIR:${target}>/Resources/dusklight.symdb")
-        else ()
-            set(_out "$<TARGET_FILE_DIR:${target}>/dusklight.symdb")
+    # Reserve an ELF program-header entry when the linker supports it (mold).
+    # symgen can replace the PT_NULL entry without relocating the table, keeping later post-link tools safe.
+    if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        include(CheckLinkerFlag)
+        check_linker_flag(CXX "LINKER:--spare-program-headers=1" _linker_supports_spare_program_headers)
+        if (_linker_supports_spare_program_headers)
+            target_link_options(${target} PRIVATE "LINKER:--spare-program-headers=1")
         endif ()
     endif ()
 
+    if (WIN32)
+        set(_input --pdb "$<TARGET_PDB_FILE:${target}>")
+    else ()
+        set(_input --binary "$<TARGET_FILE:${target}>")
+    endif ()
+
+    if (APPLE)
+        # Room for the symbol manifest and several prepatch arenas.
+        target_link_options(${target} PRIVATE "LINKER:-headerpad,0x1000")
+        # ld64 may update an existing output, which breaks our symdb insertion. Remove it first.
+        add_custom_command(TARGET ${target} PRE_LINK
+                COMMAND "${CMAKE_COMMAND}" -E rm -f "$<TARGET_FILE:${target}>"
+                VERBATIM)
+    endif ()
+
+    # The manifest is embedded into the image as a new section, located at runtime through
+    # the descriptor manifest.cpp reserves. On Apple platforms this command must stay
+    # attached before the ad-hoc codesign POST_BUILD command: the patch removes any existing
+    # signature.
     add_custom_command(TARGET ${target} POST_BUILD
-            COMMAND "${SYMGEN_EXE}" manifest ${_input} --out "${_out}"
-            COMMENT "Generating symbol manifest"
+            COMMAND "${SYMGEN_EXE}" manifest ${_input} --embed "$<TARGET_FILE:${target}>"
+            COMMENT "Embedding symbol manifest"
             VERBATIM)
 endfunction()
diff --git a/cmake/WindowsExports.cmake b/cmake/WindowsExports.cmake
index 86dc9414f2..dae7f067c0 100644
--- a/cmake/WindowsExports.cmake
+++ b/cmake/WindowsExports.cmake
@@ -6,9 +6,16 @@ get_filename_component(_DUSK_WINDOWS_EXPORTS_CMAKE_DIR "${CMAKE_CURRENT_LIST_FIL
 # import library mods link against. symgen scans the built objects, filters by source, and
 # writes a .def used by the main link and import library generation.
 function(setup_windows_exports target)
-    if (NOT CMAKE_SIZEOF_VOID_P EQUAL 8)
-        message(WARNING "dusklight: Windows code-mod exports are x64-only for now; skipping")
-        return()
+    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _implib_arch)
+    if (_implib_arch STREQUAL "arm64")
+        set(_dlltool_machine "arm64")
+        set(_lib_machine "arm64")
+    elseif (_implib_arch MATCHES "^(amd64|x86_64)$")
+        set(_dlltool_machine "i386:x86-64")
+        set(_lib_machine "x64")
+    else ()
+        message(FATAL_ERROR
+                "dusklight: no Windows mod linking support for ${CMAKE_SYSTEM_PROCESSOR}")
     endif ()
 
     include("${_DUSK_WINDOWS_EXPORTS_CMAKE_DIR}/SymbolManifest.cmake")
@@ -37,19 +44,27 @@ function(setup_windows_exports target)
         endif ()
     endforeach ()
 
+    set(_forward_args)
+    if (TARGET dawn::webgpu_dawn)
+        get_target_property(_dawn_type dawn::webgpu_dawn TYPE)
+        if (_dawn_type STREQUAL "SHARED_LIBRARY")
+            list(APPEND _forward_args
+                    --forward-dll "$<TARGET_FILE:dawn::webgpu_dawn>"
+                    --forward-sym-prefix wgpu)
+        endif ()
+    endif ()
+
     # Generate curated exports list from the main binary
     set(_def "${CMAKE_BINARY_DIR}/${_config_subdir}dusklight_exports.def")
     add_custom_command(TARGET ${target} PRE_LINK
-            # TODO: src/dusk/ is NOT excluded: inline code in game headers
-            # currently call into it (e.g. dusk::frame_interp::lookup_replacement).
             COMMAND "${_symgen}" def
-            --rsp "${_rsp}"
+            "@${_rsp}"
             --out "${_def}"
             --exclude cmake_pch
             --exclude miniz
-            --exclude asan_options
             --max-exports 58000
             ${_sdk_args}
+            ${_forward_args}
             COMMENT "Generating dusklight exports"
             VERBATIM)
     target_link_options(${target} PRIVATE "/DEF:${_def}")
@@ -59,11 +74,11 @@ function(setup_windows_exports target)
     get_filename_component(_compiler_dir "${CMAKE_CXX_COMPILER}" DIRECTORY)
     find_program(DUSK_LLVM_DLLTOOL llvm-dlltool HINTS "${_compiler_dir}")
     if (DUSK_LLVM_DLLTOOL)
-        set(_implib_cmd "${DUSK_LLVM_DLLTOOL}" -d "${_def}" -D dusklight.exe -m i386:x86-64
-                -l "${_implib}")
+        set(_implib_cmd "${DUSK_LLVM_DLLTOOL}" -d "${_def}" -D dusklight.exe
+                -m "${_dlltool_machine}" -l "${_implib}")
     else ()
-        set(_implib_cmd "${CMAKE_AR}" /nologo "/def:${_def}" /machine:x64 /name:dusklight.exe
-                "/out:${_implib}")
+        set(_implib_cmd "${CMAKE_AR}" /nologo "/def:${_def}" "/machine:${_lib_machine}"
+                /name:dusklight.exe "/out:${_implib}")
     endif ()
     add_custom_command(TARGET ${target} POST_BUILD
             COMMAND ${_implib_cmd}
@@ -71,9 +86,6 @@ function(setup_windows_exports target)
             COMMENT "Generating dusklight import library"
             VERBATIM)
     set(DUSK_GAME_IMPLIB "${_implib}" CACHE INTERNAL "Import library for Windows mod linking")
-    set(DUSK_GAME_DEF "${_def}" CACHE INTERNAL "Curated export .def for the game executable")
 
-    # Ship the import library as sdk/dusklight.lib in the install tree: mods may use it to
-    # compile against Dusklight without having to build the whole game. (See DUSK_GAME_IMPLIB)
-    install(FILES "${_implib}" DESTINATION sdk RENAME dusklight.lib)
+    install(FILES "${_implib}" DESTINATION sdk RENAME "windows-${_implib_arch}.lib")
 endfunction()
diff --git a/docs/ios-install-altstore.md b/docs/ios-install-altstore.md
index 5c0f071878..0c2e9e36a6 100644
--- a/docs/ios-install-altstore.md
+++ b/docs/ios-install-altstore.md
@@ -5,7 +5,13 @@
 - A Windows, Linux, or macOS device 
 - iOS device connected to computer via USB 
 - Dusklight IPA file (download the latest `Dusklight-vX.X.X-ios-arm64.ipa` from the [releases page](https://github.com/TwilitRealm/dusklight/releases))
-- Legally acquired game disc - `GZ2E01` (Gamecube USA) or `GZ2PE01` (Gamecube PAL)
+- Legally acquired game disc:
+  - `GZ2E01` (GameCube USA)
+  - `GZ2P01` (GameCube PAL)
+  - `GZ2J01` (GameCube JPN)
+  - `RZDE01` (Wii USA Rev. 0 *or* Rev. 2)
+  - `RZDP01` (Wii PAL)
+  - `RZDJ01` (Wii JPN)
 
 ## 1. Install iloader
 
diff --git a/docs/modding.md b/docs/modding.md
index 7b616989e8..7d7fa142a0 100644
--- a/docs/modding.md
+++ b/docs/modding.md
@@ -1,79 +1,36 @@
 # Dusklight Mod API
 
-Mods are `.dusk` bundles: zip archives that can contain code (in the form of native libraries), resources, DVD overlay
+Mods are `.dusk` bundles: zip archives that can contain code (native libraries or scripts), resources, DVD overlay
 files, and texture replacements. Mods may be enabled, disabled and reloaded at runtime.
 
-When code mods are loaded, they get dynamically linked by the operating system to the running game process. The mod
-exports lifecycle functions that Dusklight calls into (`mod_initialize`, `mod_update`, `mod_shutdown`), and the mod
-communicates with the host via **services**: plain C APIs, individually versioned. Dusklight exports several built-in
-services, and mods may export services of their own, permitting framework mods and cross-mod integration.
+There are three types of mods:
 
-Beyond services, mods have full access to the original game's code: include game headers, call directly into any public
-function, read and write data fields, and hook the vast majority of game functions.
+- **Asset-only mods**: Mods that contain no code, and may replace files on the game disc ("overlays") and provide
+  replacement textures (texture packs).
+- **Native mods (C++)**: Fully-featured, with the ability to interop with game code and hook functions. Must be compiled
+  for every supported platform. (See [mod-template](https://github.com/TwilitRealm/mod-template))
+- **Script mods (Luau)**: Simple, widely-compatible, but can only access provided services.
 
 ## Table of Contents
 
-1. [Getting Started](#getting-started)
-2. [mod.json](#modjson)
-3. [Anatomy of a Code Mod](#anatomy-of-a-code-mod)
-4. [Services](#services)
-5. [Built-in Services](#built-in-services)
-6. [Hooking Game Functions](#hooking-game-functions)
-7. [Asset Overlays](#asset-overlays)
-8. [Runtime Lifecycle](#runtime-lifecycle)
-9. [Error Handling](#error-handling)
-10. [Advanced: Exporting Services](#advanced-exporting-services)
-
----
-
-## Getting Started
-
-Fork the [mod template](../tools/mod_template/), a self-contained CMake project that uses the Dusklight mod SDK.
-
-```
-my_mod/
-├── CMakeLists.txt
-├── mod.json
-├── src/mod.cpp
-├── res/       (optional bundled resources)
-├── overlay/   (optional game file overrides)
-└── textures/  (optional texture replacements)
-```
-
-**CMakeLists.txt:**
-
-```cmake
-cmake_minimum_required(VERSION 3.25)
-project(my_mod CXX)
-
-set(DUSKLIGHT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dusklight" CACHE PATH "Path to dusklight source root")
-add_subdirectory("${DUSKLIGHT_DIR}/sdk" dusklight-sdk EXCLUDE_FROM_ALL)
-
-add_mod(my_mod
-        SOURCES src/mod.cpp
-        MOD_JSON mod.json
-        RES_DIR res            # optional
-        OVERLAY_DIR overlay    # optional
-        TEXTURES_DIR textures  # optional
-)
-```
-
-Building produces `my_mod.dusk` in `build/<preset>/mods/` (configurable via the `DUSK_MODS_OUTPUT_DIR` cache variable).
-Dusklight searches a `mods/` directory next to the app in addition to the user directory, so a dev build launched from
-`build/<preset>/` picks these up automatically: rebuild, relaunch (or click Reload), done.
-
-For a regular game install, copy the `.dusk` into the user mods folder:
-
-- Windows: `%APPDATA%\TwilitRealm\Dusklight\mods`
-- Linux: `~/.local/share/TwilitRealm/Dusklight/mods`
-- macOS: `~/Library/Application Support/TwilitRealm/Dusklight/mods`
-
-Passing `--mods <dir>` on the command line replaces the user directory with one of your choosing.
+1. [mod.json](#modjson)
+2. [Asset-only Mods](#asset-only-mods)
+3. [Native Mods (C++)](#native-mods)
+4. [Script Mods (Luau)](#script-mods)
+5. [Services](#services)
+6. [Built-in Services](#built-in-services)
+7. [Hooking Game Functions](#hooking-game-functions)
+8. [Asset Overlays](#asset-overlays)
+9. [Runtime Lifecycle](#runtime-lifecycle)
+10. [Error Handling](#error-handling)
+11. [Advanced](#advanced)
 
 ---
 
 ## mod.json
 
+Every mod starts with a single file, a `mod.json`:
+
 ```json
 {
   "id": "com.example.my_mod",
@@ -81,20 +38,60 @@ Passing `--mods <dir>` on the command line replaces the user directory with one
   "version": "1.0.0",
   "author": "Your Name",
   "description": "A short description shown in the mod manager.",
-  "icon": "res/my_icon.png",
-  "banner": "res/my_banner.png"
+  "icon": "res/icon.png",
+  "banner": "res/banner.png"
 }
 ```
 
-`id` is required: a unique, stable identifier (reverse-DNS style; periods, underscores, and alphanumerics). Everything
-else is optional but recommended.
+`id` is required: a unique, stable identifier (reverse-DNS style; periods, underscores, and lowercase alphanumerics).
+Everything else is optional but recommended.
 
-`icon` and `banner` are bundle-relative paths to PNG images for the in-game mod manager: the square icon (e.g.
-512x512), the banner (~3.5:1). If omitted, `res/icon.png` and `res/banner.png` are used automatically when present.
+`icon` and `banner` are bundle paths to PNG images that display in the in-game mod manager and mod website. A square
+icon (1:1), and a banner (~3.5:1, minimum 800px width). If omitted, `res/icon.png` and `res/banner.png` are used
+automatically when present.
+
+Simply create a zip file with a `mod.json`, and rename it to `.dusk`. That's it!
 
 ---
 
-## Anatomy of a Code Mod
+## Asset-only Mods
+
+```
+my_mod.dusk
+├── mod.json
+├── res/       (optional bundled resources)
+├── overlay/   (optional game file overrides)
+└── textures/  (optional texture replacements)
+```
+
+Place files in `overlay/` to replace the disc version of that file. Examples:
+
+- `overlay/Movie/demo_movie98_00.thp`: Replaces `Movie/demo_movie98_00.thp` on disc.
+- `overlay/res/Object/Kmdl/archive/bmwr/al.bmd`: Replaces `archive/bmwr/al.bmd` _within_ `res/Object/Kmdl.arc` without
+  overwriting the entire `.arc`.
+
+Place textures in `textures/` to automatically register them as texture replacements when active. These follow the same
+[Dolphin-compatible naming scheme](#textureservice-modssvctextureh) as the user `<data>/texture_replacements/`
+directory. Directories are scanned recursively. Examples:
+
+- `textures/tex1_256x128_e6a4c7be9bf48305_14.dds`: Replaces the Hero's Clothes texture.
+
+Simply zip the `mod.json` and adjacent folders, then rename to `.dusk`. Then, copy the `.dusk` into the user mods
+folder:
+
+- Windows: `%APPDATA%\TwilitRealm\Dusklight\mods`
+- Linux: `~/.local/share/TwilitRealm/Dusklight/mods`
+- macOS: `~/Library/Application Support/TwilitRealm/Dusklight/mods`
+
+---
+
+## Native Mods
+
+Mods built with [mod-template](https://github.com/TwilitRealm/mod-template) are native C++ mods. Native mods are very
+powerful and can interact with and [hook](#hooking-game-functions) game code directly. All features are available to
+native mods.
+
+Example C++ mod:
 
 ```cpp
 #include "mods/service.hpp"
@@ -117,46 +114,200 @@ MOD_EXPORT ModResult mod_update(ModError* error) {   // called every frame
 MOD_EXPORT ModResult mod_shutdown(ModError* error) {
     return MOD_OK;
 }
+
 }
 ```
 
-All three lifecycle exports are required. `mod_ctx` is your mod's identity token, set by the loader before
-`mod_initialize` runs. Pass it as the first argument to every service call.
+When native mods are loaded, they get dynamically linked by the operating system to the running game process. The mod
+exports lifecycle functions that Dusklight calls into (`mod_initialize`, `mod_update`, `mod_shutdown`), and the mod
+communicates with the host via **services**: plain C APIs, individually versioned. Dusklight exports several built-in
+services, and mods may export services of their own, permitting framework mods and cross-mod integration.
+
+Beyond services, native mods have full access to the original game's code: include game headers, call directly into any
+public function, read and write data fields, and hook the vast majority of game functions.
+
+### Quick Start (Native Mods)
+
+Create a repository from
+the [mod-template](https://github.com/new?template_name=mod-template&template_owner=TwilitRealm),
+a self-contained CMake project that uses the Dusklight mod SDK. It includes a GitHub Actions CI workflow that builds the
+mod for every supported platform.
+
+```
+my_mod/
+├── CMakeLists.txt
+├── mod.json
+├── src/mod.cpp
+├── res/       (optional bundled resources)
+├── overlay/   (optional game file overrides)
+└── textures/  (optional texture replacements)
+```
+
+**CMakeLists.txt:**
+
+```cmake
+cmake_minimum_required(VERSION 3.26)
+project(my_mod CXX)
+
+if (NOT DUSKLIGHT_VERSION)
+    set(DUSKLIGHT_VERSION "76b56cd8b81809fce0a5c2a44e2f6d437591132f")
+endif ()
+include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/FetchDusklight.cmake")
+add_subdirectory("${DUSKLIGHT_DIR}/sdk" dusklight-sdk EXCLUDE_FROM_ALL)
+
+add_mod(my_mod
+        FEATURES game fmt      # remove game for service-only mods; add webgpu for GfxService
+        SOURCES src/mod.cpp
+        MOD_JSON mod.json
+        RES_DIR res            # mod resources, including icon.png and banner.png
+        OVERLAY_DIR overlay    # game file overlays; remove if unused
+        TEXTURES_DIR textures  # texture replacements; remove if unused
+)
+```
+
+Available features:
+
+- `fmt`: Provides the header-only `{fmt}` library and the formatted logging helpers in
+  [`mods/svc/log.hpp`](../sdk/include/mods/svc/log.hpp).
+- `game`: Allows calling into and hooking game code. Mods that **only** use services may omit it, providing a wider
+  range of compatibility with Dusklight versions and a slightly faster build process.
+- `webgpu`: Allows importing the WebGPU API
+  ([`webgpu/webgpu.h`](https://github.com/webgpu-native/webgpu-headers/blob/main/webgpu.h)). Must be enabled when using
+  [GfxService](#gfxservice-modssvcgfxh).
+
+Building produces `my_mod.dusk` in `build/mods/`. Copy the `.dusk` into the user mods folder:
+
+- Windows: `%APPDATA%\TwilitRealm\Dusklight\mods`
+- Linux: `~/.local/share/TwilitRealm/Dusklight/mods`
+- macOS: `~/Library/Application Support/TwilitRealm/Dusklight/mods`
+
+Passing `--mods <dir>` on the command line replaces the user directory with one of your choosing.
+
+---
+
+## Script Mods
+
+For simpler use cases where direct game code access and hooks aren't necessary, Luau mods are also supported.
+Luau mods do not need to be compiled, and are always supported on all platforms. However, they can only use services
+that are provided as Luau modules.
+
+Mods can utilize Luau to add UI elements to their mod panel, use configuration variables, and dynamically swap out
+models/textures at runtime (e.g. to switch model variants or disable certain replacements) while remaining widely
+compatible.
+
+Example mod structure:
+
+```
+my_luau_mod.dusk
+├── mod.json
+└── res/
+    ├── main.luau
+    └── lib/util.luau
+```
+
+Set the `runtime` to `dev.twilitrealm.luau@1.0` in `mod.json`:
+
+```json
+{
+  "id": "com.example.my_luau_mod",
+  "name": "My Script Mod",
+  "version": "1.0.0",
+  "runtime": "dev.twilitrealm.luau@1.0"
+}
+```
+
+`res/main.luau` runs once when the mod activates. Register optional update and shutdown callbacks through
+`dusklight.host`:
+
+```lua
+local host = require("dusklight.host")
+host.on_update(function()
+    -- Runs every frame
+end)
+host.on_shutdown(function()
+    -- Runs on mod deactivation
+end)
+```
+
+Require script modules with `./` or `../` paths relative to the requiring file. The runtime appends `.luau` and rejects
+paths that escape `res/`.
+
+The runtime provides these modules:
+
+- `dusklight.log`: `write`, `trace`, `debug`, `info`, `warn`, and `error`.
+- `dusklight.host`: host `version`, mod metadata and directories, lifecycle callbacks, and `fail`.
+- `dusklight.config`: bool, integer, float, and string variables with `get`, `set`, and subscriptions.
+- `dusklight.resource`: binary-safe reads from the mod's `res/` tree.
+- `dusklight.overlay`: file and copied-buffer overlays with removable handles.
+- `dusklight.texture`: encoded-file and raw-data replacements with unregisterable handles.
+- `dusklight.ui`: Mods panels, controls, lists, windows, dialogs, styles, menu tabs, toasts, and clipboard access.
+
+For completion and type checking, add `sdk/luau/dusklight.d.luau` to the `luau-lsp.types.definitionFiles` setting.
+
+Configurable overlay example:
+
+```lua
+local config = require("dusklight.config")
+local overlay = require("dusklight.overlay")
+
+local hood = config.register({ name = "hood", type = "bool", default = true })
+local current
+
+local function apply(enabled)
+    if current then current:remove() end
+    current = overlay.add_file("/res/Object/Alink.arc",
+        enabled and "res/alink_hood.arc" or "res/alink_nohood.arc")
+end
+
+hood:subscribe(apply)
+apply(hood:get())
+```
+
+To create a script mod, copy `sdk/luau/template`, edit its manifest and source, then zip the `mod.json` and adjacent
+folders and rename to `.dusk`. Copy the `.dusk` into the user mods folder:
+
+- Windows: `%APPDATA%\TwilitRealm\Dusklight\mods`
+- Linux: `~/.local/share/TwilitRealm/Dusklight/mods`
+- macOS: `~/Library/Application Support/TwilitRealm/Dusklight/mods`
+
+**Restrictions:** The Luau VM has no raw filesystem, network, or game-code access. Each script mod has a 64 MiB memory
+limit. Calls are interrupted after 250 ms for updates and UI callbacks or 5 seconds for lifecycle calls. An uncaught
+error, timeout, or memory exhaustion fails and disables the mod.
 
 ---
 
 ## Services
 
-A service is a struct of C function pointers with a version header. You declare what you use at file scope, and the
-loader resolves it before your mod initializes:
+A service is a struct of C function pointers with a version header. Import services at file scope, and the loader
+resolves them before initializing the mod:
 
 ```cpp
-IMPORT_SERVICE(LogService, svc_log);              // required, any minor version
-IMPORT_SERVICE_VERSION(LogService, svc_log, 2);   // required, minor version >= 2
+IMPORT_SERVICE(LogService, svc_log);              // required, latest minor version
+IMPORT_SERVICE_VERSION(LogService, svc_log, 0);   // required, minimum minor version 0 (for backwards compatibility)
 IMPORT_OPTIONAL_SERVICE(SomeService, svc_maybe);  // may be null
 ```
 
+A service should be imported in only **one** file (usually your `mod.cpp`). Other files may simply use `svc_log` or
+`mods::log::` after including the appropriate header.
+
 Each service is individually versioned, and there may be multiple major versions of a service provided at once,
 allowing backwards compatibility with older mods while still changing services fundamentally if necessary. A **major**
 bump is a breaking change, treated as a different service entirely. For **additive** changes, a service appends new
-functions to the end of the struct without breaking existing callers and simply bumps the minor version. Mods that
-want the newer functions may use `IMPORT_SERVICE_VERSION` to require that minor at **load time**, or `SERVICE_HAS` to
-check at **runtime** whether a specific function is available.
+functions to the end of the struct without breaking existing callers and simply bumps the minor version.
 
-The contract (see `include/mods/api.h` for the full version):
-
-- **A required import is guaranteed valid.** If the service is missing or too old, the mod fails to load with a clear
-  error. No need to null check at call sites.
-- **Anything at or below the minor version you imported can be called unconditionally.**
-- Optional imports may be null; check once in `mod_initialize`.
-- Fields newer than your imported minor must be gated behind `SERVICE_HAS(service, ServiceType, field)` plus a null
-  check.
+`IMPORT_SERVICE` and `IMPORT_OPTIONAL_SERVICE` require the latest minor version compiled against, guaranteeing that
+every function is present. If a mod doesn't use (or may operate without) functions added in later minor versions, and
+wants to remain compatible with older Dusklight versions, it may use `IMPORT_SERVICE_VERSION` or
+`IMPORT_OPTIONAL_SERVICE_VERSION` to require an older minor version. It can then check `SERVICE_HAS` at runtime to see
+if a newer function is present (i.e. running on a new enough Dusklight version).
 
 ---
 
 ## Built-in Services
 
-### LogService (`mods/svc/log.h`)
+### LogService ([`mods/svc/log.h`](../sdk/include/mods/svc/log.h))
+
+**C++**
 
 ```cpp
 IMPORT_SERVICE(LogService, svc_log);
@@ -167,14 +318,31 @@ svc_log->error(mod_ctx, "very bad");
 svc_log->write(mod_ctx, LOG_LEVEL_DEBUG, "verbose details");
 ```
 
-Messages appear in the console prefixed with your mod ID. Messages are plain UTF-8 strings and are copied before the
-call returns; use `snprintf` or `fmt::format` for formatting.
+**Luau**
 
-### ResourceService (`mods/svc/resource.h`)
+```lua
+local log = require("dusklight.log")
+log.info("spawned the thing")
+```
+
+Messages appear in the console prefixed with your mod ID. Messages are plain UTF-8 strings and are copied before the
+call returns. C++ mods can enable `add_mod(... FEATURES fmt)` and use the formatted logging helpers in
+[`mods/svc/log.hpp`](../sdk/include/mods/svc/log.hpp):
+
+```cpp
+#include <mods/svc/log.hpp>
+
+mods::log::info("spawned actor {} at ({}, {})", actorName, x, y);
+mods::log::warn("health is down to {:.1f}%", healthPercent);
+```
+
+### ResourceService ([`mods/svc/resource.h`](../sdk/include/mods/svc/resource.h))
 
 Loads files from the `res/` tree of your `.dusk` archive. Paths are relative to `res/` (pass `"config.txt"`, not
 `"res/config.txt"`); absolute paths and `..` are rejected.
 
+**C++**
+
 ```cpp
 IMPORT_SERVICE(ResourceService, svc_resource);
 
@@ -185,28 +353,223 @@ if (svc_resource->load(mod_ctx, "config.txt", &buf) == MOD_OK) {
 }
 ```
 
-Missing files return `MOD_UNAVAILABLE`. Always `free` what you `load`. Note that the bundle is read-only; for writable
-storage, use the directory from `svc_host->mod_dir(mod_ctx)`.
+**Luau**
 
-### HostService (`mods/svc/host.h`)
+```lua
+local resource = require("dusklight.resource")
+local contents = resource.load("config.txt")
+```
 
-Mod metadata and runtime interaction with the loader:
+Missing files return `MOD_UNAVAILABLE`. Always `free` what you `load`. The bundle is read-only; use
+`HostService::data_dir` for persistent storage.
+
+### FileService ([`mods/svc/file.h`](../sdk/include/mods/svc/file.h))
+
+Provides file and folder pickers, file I/O, exports and folder enumeration.
+
+A location is an opaque UTF-8 string returned by `pick_*`, `export_file`, `join`, or `create_child`.
+Save it and pass it back to the service. Never parse it or manually append path segments.
+
+```cpp
+#include "mods/svc/file.hpp"
+
+IMPORT_SERVICE(FileService, svc_file);
+
+mods::file::PickOptions options;
+options.filters.push_back({"Audio", "wav;ogg"});
+mods::file::pick_file(options, [](mods::file::PickResult result) {
+    if (result.status == MOD_OK && !result.locations.empty()) {
+        save_location(result.locations.front());
+    }
+});
+```
+
+Use `check` before reopening a saved location because removable storage or an access grant may no longer be available.
+`open` provides seekable streaming I/O. `read_all` allocates the entire file and should only be used when the file is
+small. Folder locations support `list` and child resolution through `join`. Only one picker can be open at a time.
+
+`create_child` never replaces an existing file and returns `MOD_CONFLICT` if one exists. Use the returned location;
+document providers may adjust the requested name. `write_all` is a convenience function over
+`open`/`write`/`flush`/`close`.
+
+```cpp
+std::string location;
+if (mods::file::create_child(folder, "report.txt", location) == MOD_OK) {
+    mods::file::write_all(location, report);
+}
+
+mods::file::export_file(location, "report.txt", [](mods::file::PickResult result) {
+    if (result.status == MOD_OK) {
+        remember_export_destination(result.locations.front());
+    }
+});
+```
+
+`export_file` copies an existing file to a user-selected destination and returns the destination location in its
+callback. Mod-owned persistent files belong in `HostService::data_dir`.
+
+### HttpService ([`mods/svc/http.h`](../sdk/include/mods/svc/http.h))
+
+Asynchronous HTTPS requests supporting HTTP/2 and TLS 1.2+. C++ mods should use the helpers in
+[`mods/svc/http.hpp`](../sdk/include/mods/svc/http.hpp):
+
+```cpp
+#include "mods/svc/http.hpp"
+
+IMPORT_SERVICE(HttpService, svc_http);
+
+mods::http::Pending pendingRequest;
+
+void fetch_manifest() {
+    mods::http::Request request{
+        .url = "https://example.com/manifest.json",
+        .maxBodyBytes = 256 * 1024,
+    };
+    pendingRequest = mods::http::request(request, [](mods::http::Response response) {
+        if (!response.ok()) {
+            handle_fetch_error(response.error, response.statusCode);
+            return;
+        }
+
+        std::string manifest{response.body.begin(), response.body.end()};
+        use_manifest(manifest);
+    });
+    if (!pendingRequest) {
+        handle_start_error(pendingRequest.result());
+    }
+}
+```
+
+Keep the returned `Pending` alive until completion. Dropping it or calling `cancel` requests cancellation. Callbacks run
+on the game thread.
+
+`Response::ok()` requires a 2xx status. Other HTTP statuses are valid responses, not transport errors, so always check
+`statusCode`. In-memory responses default to a 1 MiB limit; set `maxBodyBytes` to increase it if needed.
+
+For large responses, set `downloadPath` to an absolute path in the calling mod's `HostService::data_dir` or
+`HostService::mod_dir`. The response is streamed to disk instead of loaded in memory. On success, the callback receives
+an empty `body` and the final path in `downloadPath`. Check `Response::ok()` before using the file.
+`Pending::progress()` reports download progress when the server provides a total size.
+
+### WebSocketService ([`mods/svc/websocket.h`](../sdk/include/mods/svc/websocket.h))
+
+WebSocket client connections with text or binary messages. Secure `wss://` URLs are supported everywhere. Insecure
+`ws://` is limited to `localhost`, `127.0.0.1`, and `[::1]`.
+
+```cpp
+#include "mods/svc/websocket.hpp"
+
+IMPORT_SERVICE(WebSocketService, svc_websocket);
+
+mods::ws::Connection connection;
+
+MOD_EXPORT ModResult mod_initialize(ModError*) {
+    connection = mods::ws::connect({.url = "wss://example.com/events"});
+    return connection ? MOD_OK : connection.result();
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    mods::ws::Event event;
+    while (mods::ws::poll(event)) {
+        if (event.type == WEBSOCKET_EVENT_MESSAGE) {
+            consume(event.data);
+        } else if (event.type == WEBSOCKET_EVENT_CLOSED) {
+            schedule_reconnect(event.error);
+        }
+    }
+    return MOD_OK;
+}
+```
+
+Keep the `Connection` alive and drain `mods::ws::poll()` regularly, usually on every `mod_update` tick. A connection
+emits an (optional) `OPEN` event, zero to many `MESSAGE` events, and exactly one `CLOSED` event.
+
+**Restrictions:** A mod may only open four connections at once. Messages have a 1 MiB limit by default, and may request
+up to 16 MiB. Unread data is limited to 16 MiB and the outbound queue to 4 MiB. `send` returns `MOD_CONFLICT` when the
+outbound queue is full. Dropping the `Connection` or deactivating the mod attempts to gracefully close with code 1001,
+until the close deadline expires.
+
+### NetService ([`mods/svc/net.h`](../sdk/include/mods/svc/net.h))
+
+Asynchronous raw TCP and UDP networking. Endpoints can be `tcp://host:port` or `udp://host:port`. TCP connections and
+`resolve` accept hostnames. Listeners and UDP endpoints require IP literals.
+
+```cpp
+#include "mods/svc/net.hpp"
+
+IMPORT_SERVICE(NetService, svc_net);
+
+mods::net::BindOutcome bound;
+mods::net::Socket listener;
+mods::net::Socket client;
+
+MOD_EXPORT ModResult mod_initialize(ModError*) {
+    listener = mods::net::listen("tcp://127.0.0.1:0", &bound);
+    client = mods::net::connect(bound.local);
+    return listener && client ? MOD_OK : MOD_ERROR;
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    mods::net::Event event;
+    while (mods::net::poll(event)) {
+        if (event.type == NET_EVENT_ACCEPTED) {
+            remember_client(mods::net::adopt(event.accepted));
+        } else if (event.type == NET_EVENT_STREAM_DATA) {
+            consume(event.data);
+        }
+    }
+    return MOD_OK;
+}
+```
+
+`send` and `send_to` copy the payload and return `MOD_CONFLICT` when the socket's outbound queue is full. `stats`
+reports queued bytes, traffic, dropped inbound datagrams, and asynchronous UDP send failures.
+
+**Restrictions:** A mod may only have 32 streams, 4 listeners, 4 UDP sockets, and 8 DNS resolutions active at once.
+
+### HostService ([`mods/svc/host.h`](../sdk/include/mods/svc/host.h))
+
+Mod metadata and runtime interaction with the loader.
+
+**C++**
 
 ```cpp
 IMPORT_SERVICE(HostService, svc_host);
 
-const char* id  = svc_host->mod_id(mod_ctx);
-const char* dir = svc_host->mod_dir(mod_ctx);  // writable per-mod directory
-svc_host->fail(mod_ctx, MOD_ERROR, "something unrecoverable happened");  // disables the mod
+// Temporary mod data directory, wiped on startup
+const char* cacheDir = svc_host->mod_dir(mod_ctx);
+
+// Persistent mod data directory
+const char* dataDir = nullptr;
+if (svc_host->data_dir(mod_ctx, &dataDir) == MOD_OK) {
+    // ...
+}
+
+// Report an error and disable the mod
+svc_host->fail(mod_ctx, MOD_ERROR, "something unrecoverable happened");
 ```
 
-`get_service`/`publish_service` provide dynamic service lookup; see [Advanced](#advanced-exporting-services).
+**Luau**
+
+```lua
+local host = require("dusklight.host")
+local dataDir = host.data_dir()
+host.on_update(function()
+    -- Runs every frame
+end)
+host.on_shutdown(function()
+    -- Runs on mod deactivation
+end)
+host.fail("something unrecoverable happened")
+```
+
+`get_service`/`publish_service` provide dynamic service lookup; see [Exporting Services](#exporting-services).
 
 **Lifecycle watches.** If your mod provides a service that hands out per-caller state (registrations, callbacks,
 handles), watch other mods' lifecycle and drop what you hold for a mod when it detaches.
 
 ```cpp
-IMPORT_SERVICE_VERSION(HostService, svc_host, 1);
+IMPORT_SERVICE(HostService, svc_host);
 
 void on_mod_lifecycle(ModContext* ctx, ModContext* subject, const char* subject_id,
     ModLifecycleEvent event, void* user_data) {
@@ -222,37 +585,54 @@ svc_host->watch_mod_lifecycle(mod_ctx, on_mod_lifecycle, nullptr, &watch);
 `MOD_LIFECYCLE_DETACHED` fires on the game thread at a lifecycle safe point, after the subject's `mod_shutdown` ran and
 every service dropped its state. For your own mod's teardown, use `mod_shutdown` instead.
 
-### HookService (`mods/svc/hook.h`)
+### HookService ([`mods/svc/hook.h`](../sdk/include/mods/svc/hook.h))
 
 Installs hooks on game functions and resolves symbols by name. You'll rarely call it directly; use the typed helpers in
-`mods/hook.hpp` described in [Hooking Game Functions](#hooking-game-functions).
+[`mods/svc/hook.hpp`](../sdk/include/mods/svc/hook.hpp) described in
+[Hooking Game Functions](#hooking-game-functions).
 
-### OverlayService (`mods/svc/overlay.h`)
+### OverlayService ([`mods/svc/overlay.h`](../sdk/include/mods/svc/overlay.h))
 
 Registers DVD file overlays at runtime: the dynamic counterpart to the static `overlay/` directory (see
-[Asset Overlays](#asset-overlays)). Overlay a disc path with a file from your bundle, or with a caller-owned buffer
-(copied on registration):
+[Asset Overlays](#asset-overlays)). Overlay a disc path with a file from your bundle, a file within an archive,
+or with a caller-owned buffer (copied on registration).
+
+**C++**
 
 ```cpp
 IMPORT_SERVICE(OverlayService, svc_overlay);
 
 OverlayHandle handle = 0;
-svc_overlay->add_file(mod_ctx, "/res/Msgus.arc", "res/replacement.arc", &handle);
+svc_overlay->add_file(mod_ctx, "/Movie/demo_movie98_00.thp", "res/replacement.thp", &handle); // Replaces the demo movie
+svc_overlay->add_file(mod_ctx, "/res/Object/Kmdl/archive/bmwr/al.bmd", "res/link_model.bmd", &handle); // Replaces link's model
 svc_overlay->add_buffer(mod_ctx, "/generated.txt", data, size, nullptr);
 svc_overlay->remove(mod_ctx, handle);
 ```
 
+**Luau**
+
+```lua
+local overlay = require("dusklight.overlay")
+local replacement = overlay.add_file("/Movie/demo_movie98_00.thp", "res/replacement.thp")
+replacement:remove()
+```
+
 `disc_path` must be absolute (leading `/`) and is matched against the disc case-insensitively. Paths that don't exist
 on the disc are added as new files. Changes are applied at the next frame boundary, and data the game already read
 stays in memory until the file is re-read: sometimes a scene reload, and in the worst case, a full restart.
 
+Dusklight reloads core archive files during scene transitions so modifications to Link, Midna or other globally-loaded
+data get refreshed without a full restart.
+
 See [Asset Overlays](#asset-overlays) for priority and conflict handling.
 
-### TextureService (`mods/svc/texture.h`)
+### TextureService ([`mods/svc/texture.h`](../sdk/include/mods/svc/texture.h))
 
 Registers texture replacements at runtime: the dynamic counterpart to the static `textures/` directory (see
 [Asset Overlays](#asset-overlays)). Two forms: raw texel data with an explicit key, or an encoded `.dds`/`.png` from
-your bundle whose filename encodes the key:
+your bundle whose filename encodes the key.
+
+**C++**
 
 ```cpp
 IMPORT_SERVICE(TextureService, svc_texture);
@@ -273,6 +653,14 @@ svc_texture->register_data(mod_ctx, &key, &data, nullptr);
 svc_texture->unregister(mod_ctx, handle);
 ```
 
+**Luau**
+
+```lua
+local texture = require("dusklight.texture")
+local replacement = texture.register_file("res/tex1_32x32_$_6.png")
+replacement:unregister()
+```
+
 Filenames use the same Dolphin-style convention as the user's `texture_replacements` directory:
 `tex1_{w}x{h}_{texhash}[_{tluthash}]_{fmt}.dds|.png`, where hashes may be `$` (wildcard). `_mipN` sidecar files next to
 a registered file are picked up automatically. Files are decoded lazily on first use by the renderer; raw data is copied
@@ -280,11 +668,13 @@ at registration. Registrations follow your mod's lifecycle.
 
 See [Asset Overlays](#asset-overlays) for priority and conflict handling.
 
-### ConfigService (`mods/svc/config.h`)
+### ConfigService ([`mods/svc/config.h`](../sdk/include/mods/svc/config.h))
 
 Persistent, mod-scoped configuration variables. Each var is stored in the user's `config.json` under
 `mod.<escaped mod id>.<name>` (escaping: `.` → `_`, `_` → `__`, so `com.example.my_mod` becomes `com_example_my__mod`),
-next to the host's own settings:
+next to the host's own settings.
+
+**C++**
 
 ```cpp
 IMPORT_SERVICE(ConfigService, svc_config);
@@ -308,6 +698,17 @@ void on_speed_changed(ModContext* ctx, ConfigVarHandle var, const ConfigVarValue
 svc_config->subscribe(mod_ctx, var, on_speed_changed, nullptr, nullptr);
 ```
 
+**Luau**
+
+```lua
+local config = require("dusklight.config")
+local speed = config.register({ name = "speedMultiplier", type = "float", default = 1.0 })
+speed:subscribe(function(value, previous)
+    -- React to the new value.
+end)
+speed:set(2.0)
+```
+
 Types: `CONFIG_VAR_BOOL` (`bool`), `CONFIG_VAR_INT` (`int64_t`), `CONFIG_VAR_FLOAT` (`double`), `CONFIG_VAR_STRING`
 (UTF-8; `get_string` copies into a caller buffer, pass a `NULL` buffer with size 0 to query the length). Accessors are
 typed and must match the registration.
@@ -316,7 +717,89 @@ Change callbacks fire on the game thread whenever the value changes at runtime (
 Writes that store the same value are silent. Values applied from `config.json` or `--cvar` at registration do
 **not** fire callbacks; read the value after `register_var` for the starting state.
 
-### UiService (`mods/svc/ui.h`)
+### SaveService ([`mods/svc/save.h`](../sdk/include/mods/svc/save.h))
+
+Stores named binary blobs for each save slot. Blob names are scoped to the calling mod, and each mod may store up to
+`SAVE_BLOB_BUDGET_BYTES` per slot. The service copies data passed to `set_blob`.
+
+```cpp
+IMPORT_SERVICE(SaveService, svc_save);
+
+struct MySaveData {
+    uint32_t version;
+    uint32_t counter;
+};
+
+MySaveData state{1, 42};
+svc_save->set_blob(mod_ctx, "state", &state, sizeof(state));
+
+MySaveData loaded{};
+size_t loadedSize = sizeof(loaded);
+if (svc_save->get_blob(mod_ctx, "state", &loaded, &loadedSize) == MOD_OK &&
+    loadedSize == sizeof(loaded)) {
+    apply_state(loaded);
+}
+```
+
+`set_blob`, `get_blob`, and `delete_blob` operate on the current slot, which is available after creating or loading a
+save and unavailable at file select. Blob changes are written with the next game save. File-select copy and erase
+operations update the blob data as well. Use `peek_blob` to read the calling mod's data from any slot; it uses the same
+buffer contract as `get_blob`. Pass a `NULL` buffer to either read function to query the blob size.
+
+`observe_saves` registers callbacks for new, loaded, and written saves. New-save callbacks run after the slot's blobs
+are cleared. Observers are removed automatically when the mod is detached, so the output handle is only needed for
+manual unregistration. Save callbacks run on the game thread.
+
+### StageService ([`mods/svc/stage.h`](../sdk/include/mods/svc/stage.h))
+
+Allows making changes to a stage's "stage info" (contents of .dzs/.dzr files).
+(Currently only supports editing actor nodes.)
+
+```cpp
+IMPORT_SERVICE(StageService, svc_stage);
+
+stage_actor_data_class record = {
+    "carry00",
+    0xFF000000,
+    cXyz(0.0f, 0.0f, 0.0f),
+    csXyz(0, 0, 0),
+    0,
+};
+
+StageActorHandle handle{};
+svc_stage->patch_actor(mod_ctx, "F_SP102", 0, -1, record_crc, &record, sizeof(record), &handle);
+```
+
+```
+StageActorHandle handle{};
+svc_stage->delete_actor(mod_ctx, "F_SP102", 0, -1, record_crc, &handle);
+```
+
+Patch or remove actors from the original actor list as the room loads.
+Given records must be of either `stage_actor_data_class` or `stage_tgsc_data_class` types.
+`record_crc` is the CRC-32 of the unmodified original record used to identify the record to replace or remove.
+
+```
+stage_actor_data_class record = {
+    "carry00",
+    0xFF000000,
+    cXyz(0.0f, 0.0f, 0.0f),
+    csXyz(0, 0, 0),
+    0,
+};
+
+StageActorHandle handle{};
+svc_stage->add_actor(mod_ctx, "F_SP102", 0, -1, &record, sizeof(record), &handle);
+```
+
+Add a new actor to the actor list as the room loads.
+Given records must be of either `stage_actor_data_class` or `stage_tgsc_data_class` types.
+
+Stage names may contain up to 8 characters. For patches and deletions, room `0xff` and layer `-1` match any room or
+layer; additions require a specific room. Edits are removed when the mod is detached. If multiple mods edit the same
+record, the later-loaded mod wins.
+
+### UiService ([`mods/svc/ui.h`](../sdk/include/mods/svc/ui.h))
 
 Integrate seamlessly with Dusklight's UI system: add controls and buttons to your mod's detail pane in the Mods window,
 create custom windows and modal dialogs, apply custom RCSS stylesheets (anywhere!), and add menu bar tabs.
@@ -326,6 +809,8 @@ content is rebuilt, and `update` runs every frame while that mod is selected. Wh
 pane carries your mod's id as a `mod-id` attribute (like custom window roots), so scoped RCSS can target it (e.g.
 `[mod-id="com.example.mod"]`).
 
+**C++**
+
 ```cpp
 IMPORT_SERVICE(UiService, svc_ui);
 
@@ -349,14 +834,26 @@ panel.update = update;
 svc_ui->register_mods_panel(mod_ctx, &panel);
 ```
 
+**Luau**
+
+```lua
+local ui = require("dusklight.ui")
+ui.register_mods_panel({
+    build = function(panel)
+        panel:add_section("Status")
+        panel:add_text("running")
+    end,
+})
+```
+
 Element setters must match the element kind: `elem_set_text`/`elem_set_rml` on text rows, and `elem_set_progress` on
 progress bars. `elem_set_class` sets or clears an RCSS class on any element handle, for styling via scoped or
 per-window RCSS. A non-`MOD_OK` result from `build`/`update` fails your mod, as do exceptions thrown from any UI
 callback.
 
 **Controls:** `pane_add_control` adds an input row described by a `UiControlDesc`: `UI_CONTROL_BUTTON`,
-`UI_CONTROL_TOGGLE`, `UI_CONTROL_NUMBER`, `UI_CONTROL_STRING`, or `UI_CONTROL_SELECT`. Values bind with callbacks or
-directly to a config var.
+`UI_CONTROL_GROUP`, `UI_CONTROL_TOGGLE`, `UI_CONTROL_NUMBER`, `UI_CONTROL_STRING`, `UI_CONTROL_SELECT`, or
+`UI_CONTROL_COLOR`. Values bind with callbacks or directly to a config var.
 
 ```cpp
 UiControlDesc control = UI_CONTROL_DESC_INIT;
@@ -369,9 +866,56 @@ svc_ui->pane_add_control(mod_ctx, leftPane, &control, nullptr);
 ```
 
 `UI_BINDING_CONFIG_VAR` wires persistence, change notifications, and the modified indicator automatically. The var
-type must match the control: `TOGGLE` = bool, `NUMBER` and `SELECT` = int, `STRING` = string. Float vars are not
-bindable; use callbacks and convert. `help_rml` and `SELECT` option lists render in a help pane, so `SELECT` controls
-are only available inside window tabs.
+type must match the control: `TOGGLE` = bool, `NUMBER` and `SELECT` = int, `STRING` and `COLOR` = string. Float vars
+are not bindable; use callbacks and convert. `help_rml` and `SELECT` option lists render in a help pane, so `SELECT`
+controls are only available inside window tabs.
+
+`pane_add_group` adds a category button to a window tab's left pane. Focusing the button clears the paired right pane
+and calls the group's build callback with that pane, which is useful for organizing related controls without adding
+more tabs.
+
+**Lists:** `pane_add_list` adds a scrollable virtualized list of items that can be efficiently updated and filtered.
+Keys must be unique and remain stable across replacements.
+
+```cpp
+UiListHandle locationList = 0;
+
+void replace_locations(std::string_view query) {
+    std::vector<UiListItem> items;
+    for (uint64_t i = 0; i < locations.size(); ++i) {
+        if (matches(locations[i], query)) {
+            UiListItem item = UI_LIST_ITEM_INIT;
+            item.key = i;
+            item.label = locations[i].c_str();
+            items.push_back(item);
+        }
+    }
+    svc_ui->list_set_items(mod_ctx, locationList, items.data(), items.size());
+}
+
+void set_filter(ModContext*, void*, const UiControlValue* value) {
+    replace_locations(value->string_value);
+}
+
+bool location_selected(ModContext*, UiListHandle, uint64_t key, void*) {
+    return selected_locations.contains(key);
+}
+
+UiControlDesc filter = UI_CONTROL_DESC_INIT;
+filter.kind = UI_CONTROL_STRING;
+filter.label = "Filter";
+filter.get = get_filter;
+filter.set = set_filter;
+filter.string_set_mode = UI_STRING_SET_ON_CHANGE; /* invoke `set` while typing */
+svc_ui->pane_add_control(mod_ctx, pane, &filter, nullptr);
+
+UiListDesc list = UI_LIST_DESC_INIT;
+/* items may be passed as a part of list creation, or set afterwards */
+list.on_pressed = location_pressed;
+list.is_selected = location_selected;
+svc_ui->pane_add_list(mod_ctx, pane, &list, &locationList);
+replace_locations(""); /* calls `list_set_items` */
+```
 
 **Windows:** `window_push` pushes a tabbed two-pane window onto the document stack and shows it. Each tab's `build`
 receives the window handle plus fresh left and right pane handles on every activation. The optional per-tab `update`
@@ -393,10 +937,52 @@ svc_ui->window_push(mod_ctx, &desc, &window);
 ```
 
 **Dialogs:** `dialog_push` shows a modal dialog. `variant` picks the style, `icon` optionally overrides the variant's
-default icon, and actions become buttons. After an action's `on_pressed` returns, the dialog closes unless the action
-sets `keep_open`. A `keep_open` action can close it later (or immediately) with `dialog_close`. Cancel fires
-`on_dismiss` if present and always closes. `dialog_set_body`, `dialog_set_icon`, and `dialog_add_action` mutate a live
-dialog.
+default icon, and actions become buttons. The optional `build` callback allows you to add controls to a pane between
+the body and actions. It uses the same text, progress, and control builders as panels.
+
+```cpp
+ModResult build_dialog(ModContext*, UiElementHandle pane, void*, ModError*) {
+    UiControlDesc input = UI_CONTROL_DESC_INIT;
+    input.kind = UI_CONTROL_STRING;
+    input.label = "Name";
+    input.get = get_name;
+    input.set = set_name;
+    return svc_ui->pane_add_control(mod_ctx, pane, &input, nullptr);
+}
+
+UiDialogAction action = UI_DIALOG_ACTION_INIT;
+action.label = "Save";
+action.on_pressed = save;
+action.is_disabled = is_save_disabled;
+
+UiDialogDesc dialog = UI_DIALOG_DESC_INIT;
+dialog.title = "New Preset";
+dialog.body_rml = "Choose a name for the preset.";
+dialog.actions = &action;
+dialog.action_count = 1;
+dialog.build = build_dialog;
+svc_ui->dialog_push(mod_ctx, &dialog, nullptr);
+```
+
+After an action's `on_pressed`, the dialog closes unless the action sets `keep_open`. It can then be closed later
+(or immediately) with `dialog_close`. Cancel fires `on_dismiss` and always closes. `dialog_set_body` and
+`dialog_set_icon` mutate a live dialog.
+
+**Toasts:** `push_toast` enqueues a notification. Titles and bodies accept RML. The optional `type` is applied as an
+RCSS class; `warning` uses the built-in warning appearance, and mods can define their own types. A duration of 0 uses
+the default of 5 seconds.
+
+Toasts have a `mod-id` attribute, so `UI_SCOPE_OVERLAY` styles can use selectors such as
+`toast[mod-id="com.example.randomizer"].success`.
+
+```cpp
+UiToastDesc toast = UI_TOAST_DESC_INIT;
+toast.type = "success";
+toast.title_rml = "Randomizer";
+toast.body_rml = "<span>Seed loaded successfully.</span>";
+toast.duration_ms = 3000;
+svc_ui->push_toast(mod_ctx, &toast);
+```
 
 **Menu bar tabs:** `register_menu_tab` adds a tab to the in-game menu bar. `on_selected` fires when the user activates
 the tab: typically you'd push a window from it. The tab is removed by `unregister_menu_tab`, or automatically when the
@@ -409,34 +995,334 @@ existing documents restyle immediately, and future ones pick it up when created.
 host styles and may override them. Scope selectors tightly (use `[mod-id="..."]`!), especially for `UI_SCOPE_WINDOW`,
 unless changing host UI is intentional.
 
+### WindowService ([`mods/svc/window.h`](../sdk/include/mods/svc/window.h))
+
+Allows creating new windows that can be rendered to via `GfxService`.
+
+```cpp
+IMPORT_SERVICE(WindowService, svc_window);
+
+WindowDesc desc = WINDOW_DESC_INIT;
+desc.title = "My auxiliary view";
+desc.on_event = on_window_event;
+WindowHandle window = 0;
+svc_window->create_window(mod_ctx, &desc, &window);
+```
+
+Window callbacks run on the game thread. A close event is only a request; call `destroy_window` when the mod is ready to
+close it. A window attached to a GfxService present target cannot be destroyed until that target is unregistered. Only
+one present target may be attached to a WindowService window at a time.
+
+New windows are hidden by default so a mod can finish attaching graphics before calling `show_window`.
+
+### GfxService ([`mods/svc/gfx.h`](../sdk/include/mods/svc/gfx.h))
+
+**Requires `add_mod(... FEATURES webgpu)`**
+
+Direct WebGPU access at various stages of the rendering pipeline. Mods use the `wgpu*` C API (via
+[`webgpu/webgpu.h`](https://github.com/webgpu-native/webgpu-headers/blob/main/webgpu.h)) for custom draws and compute
+dispatches. Mods must manage their own WebGPU state, including pipelines and bind groups.
+
+```cpp
+IMPORT_SERVICE(GfxService, svc_gfx);
+
+GfxDeviceInfo info = GFX_DEVICE_INFO_INIT;
+svc_gfx->get_device_info(mod_ctx, &info);
+```
+
+`register_stage_hook` runs a game-thread callback during frame recording. The public stages are:
+
+- `GFX_STAGE_SCENE_BEGIN`: world camera window after camera/projection/light setup
+- `GFX_STAGE_SCENE_AFTER_TERRAIN`: after terrain/shadow lists, before object and translucent lists
+- `GFX_STAGE_SCENE_AFTER_OPAQUE`: after sky/terrain/object opaque lists, before translucent lists
+- `GFX_STAGE_FRAME_BEFORE_HUD`: 3D scene and wipe are complete, before 2D/HUD lists
+- `GFX_STAGE_FRAME_AFTER_HUD`: full game scene, including HUD
+
+Inside a stage callback, record work with `push_draw`, stream per-frame data with `push_verts`, `push_indices`,
+`push_uniform`, or `push_storage`, snapshot the current frame with `resolve_pass`, and use `create_pass`/`resolve_pass`
+for temporary offscreen passes. Draw callbacks run later on the render worker thread with the live
+`WGPURenderPassEncoder`; they may use only their `GfxDrawContext` handles and raw `wgpu*` calls. Compute callbacks
+registered with `register_compute_type` follow the same worker-thread rule and run on the frame command encoder.
+
+All WGPU handles from the service are borrowed. Resolved target views are valid for the current frame only. GPU objects
+created by a mod are owned by that mod and should be released in `mod_shutdown`.
+
+#### External presentation
+
+GfxService supports external presentation ("present targets") backed by either a WindowService window (via
+`register_window_present_target`) or a plain `WGPUSurface` (via `register_present_target`).
+
+```cpp
+GfxPresentTargetDesc target_desc = GFX_PRESENT_TARGET_DESC_INIT;
+target_desc.render = render_auxiliary_view;
+GfxPresentTargetHandle target = 0;
+svc_gfx->register_window_present_target(mod_ctx, window, &target_desc, &target);
+
+// From a stage callback:
+svc_gfx->push_present(mod_ctx, target, &payload, sizeof(payload));
+```
+
+For WindowService windows, the surface is automatically reconfigured on window size changes.
+For plain `WBPUSurface`s, `resize_present_target` must be used to resize.
+
+To create a `WGPUSurface` manually, `GfxDeviceInfo` holds the `WGPUInstance` and `WGPUAdapter` which can be used with
+`wgpuInstanceCreateSurface` and a chained `WGPUSurfaceSource*` struct.
+
+`push_present` must be called every frame from a GfxService stage callback. If surface was lost, `push_present` returns
+`MOD_ERROR`. Unregister and re-register the target before trying again.
+
+### CameraService ([`mods/svc/camera.h`](../sdk/include/mods/svc/camera.h))
+
+Converts a game view provided by a render callback into WebGPU-convention camera data. Matrix fields are column-major
+`float[16]` values using the matrix * column-vector convention (transpose of the game's row-major `Mtx`/`Mtx44` layout),
+ready to copy into WGSL `mat4x4f` uniforms.
+
+```cpp
+IMPORT_SERVICE(CameraService, svc_camera);
+
+CameraInfo camera = CAMERA_INFO_INIT;
+if (svc_camera->get_camera(mod_ctx, game_view, &camera) == MOD_OK) {
+    // camera.view_from_world, camera.proj_from_view, camera.eye, ...
+}
+```
+
+`get_camera` returns `MOD_UNAVAILABLE` while the view is not a valid perspective camera, such as before the
+first in-game frame. Projection matrices match the renderer's WebGPU clip convention and renderer depth convention
+(reversed-Z by default).
+
+Camera operators allow overriding the main camera. When an operator callback returns true, its values replace the camera
+state for the current frame. Register and unregister using `register_camera_operator` / `unregister_camera_operator`.
+
+### GameModeService ([`mods/svc/game_mode.h`](../sdk/include/mods/svc/game_mode.h))
+
+Allows a mod to register a game mode with callbacks for key gameplay and save lifecycle events. Registered game modes
+appear in the prelaunch menu. Game modes may use a unique set of saves by configuring `save_name`; leave it empty to use
+the vanilla `gczelda2` save.
+
+```cpp
+IMPORT_SERVICE(LogService, svc_log);
+IMPORT_SERVICE(HookService, svc_hook);
+IMPORT_SERVICE(GameModeService, svc_game_mode);
+
+DEFINE_HOOK(fopAcM_createItem, CreateItem);
+
+#define MY_GAME_MODE_ID "game-mode-id"
+
+static HookAction my_function_hook(ModContext* ctx, void* args, void*, void*) {
+    // If we wish to have this hook only run while the gamemode is registered, we need to hook the function from the
+    // gamemode's onActivatedFunction, and uninstall the hook during the onDeactivatedFunction. Example below.
+    // Alternatively, check with `svc_game_mode->is_active(mod_ctx, MY_GAME_MODE_ID, &active) == MOD_OK && active`.
+    return HOOK_CONTINUE;
+}
+
+ModResult on_game_mode_activated(void*, ModError* outError) {
+    // Setup the gamemode, Add any hooks that are gamemode specific
+    // Overlay any files that are gamemode specific
+    ModResult result = mods::hook_add_pre<CreateItem>(svc_hook, my_function_hook);
+    if (result != MOD_OK) {
+        return mods::set_error(outError, result, "failed to install fopAcM_createItem hook");
+    }
+    return MOD_OK;
+}
+
+ModResult on_game_mode_deactivated(void*, ModError* outError) {
+    // Uninstall any hooks that are gamemode specific
+    // Remove any file overlays that are gamemode specific
+    ModResult result = mods::hook_uninstall<CreateItem>();
+    if (result != MOD_OK) {
+        return mods::set_error(outError, result, "failed to uninstall fopAcM_createItem hook");
+    }
+    return MOD_OK;
+}
+
+ModResult on_save_loaded(void*, ModError*) {
+    // This function will be invoked by the game as a save is loaded
+    return MOD_OK;
+}
+
+const GameModeDesc gameModeDesc = {
+    .struct_size = sizeof(GameModeDesc),
+    .game_mode_id = MY_GAME_MODE_ID,
+    .full_name = "My Game Mode",
+    .save_name = "my-unique-save",
+    .user_data = nullptr,
+    .on_activated = on_game_mode_activated,
+    .on_deactivated = on_game_mode_deactivated,
+    .on_save_loaded = on_save_loaded,
+};
+svc_game_mode->register_game_mode(mod_ctx, &gameModeDesc);
+```
+
+A game mode can also open UI for per-save settings when creating a new file. The state begins as
+`GAME_MODE_STATE_PENDING` and remains valid until the mod selects `PROCEED` or `RETURN`.
+
+```cpp
+IMPORT_SERVICE(GameModeService, svc_game_mode);
+IMPORT_SERVICE(UiService, svc_ui);
+
+ModResult on_new_save_select(void*, GameModeNewSaveState* state, ModError* outError) {
+    static GameModeNewSaveState* newSaveState;
+    static UiWindowHandle windowHandle;
+
+    newSaveState = state;
+
+    UiTabDesc tabs[1]{};
+
+    tabs[0].struct_size = sizeof(UiTabDesc);
+    tabs[0].title = "Play";
+    tabs[0].build = [](ModContext* ctx, UiWindowHandle, UiElementHandle leftPane, UiElementHandle rightPane, void*, ModError*) {
+        UiControlDesc desc = UI_CONTROL_DESC_INIT;
+        desc.kind = UI_CONTROL_BUTTON;
+        desc.label = "Play";
+        desc.help_rml = "Play Button";
+        desc.on_pressed = [](ModContext* ctx, void* userdata) {
+            *newSaveState = GAME_MODE_STATE_PROCEED;
+            svc_ui->window_close(ctx, *static_cast<UiWindowHandle*>(userdata));
+        };
+        desc.user_data = &windowHandle;
+        svc_ui->pane_add_control(mod_ctx, leftPane, &desc, nullptr);
+        return MOD_OK;
+    };
+
+    UiWindowDesc desc = UI_WINDOW_DESC_INIT;
+    desc.tabs = tabs;
+    desc.tab_count = 1;
+    desc.on_closed = [](ModContext *, UiWindowHandle, void *userdata) {
+        // If closing the window through backing out, return to file select
+        if (*newSaveState == GAME_MODE_STATE_PENDING) {
+            *newSaveState = GAME_MODE_STATE_RETURN;
+        }
+    };
+
+    ModResult result = svc_ui->window_push(mod_ctx, &desc, &windowHandle);
+    if (result != MOD_OK) {
+        return mods::set_error(outError, result, "failed to open new-save settings");
+    }
+    return MOD_OK;
+}
+
+const GameModeDesc gameModeDesc = {
+    .struct_size = sizeof(GameModeDesc),
+    .game_mode_id = "my-game-mode-id",
+    .full_name = "My Game Mode",
+    .save_name = "my-unique-save",
+    .on_new_save_select = on_new_save_select,
+};
+svc_game_mode->register_game_mode(mod_ctx, &gameModeDesc);
+
+```
+
+### ActorService (`mods/svc/actor.h`)
+
+A service that manages registering and creating custom actors. These actors will be run by the game as if they are part of the engine. These actors can be created by the game either by its 16-bit actor name, or a 7-character long name that can
+be loaded by a stage.
+
+```cpp
+#include "mods/svc/actor.h"
+IMPORT_SERVICE(ActorService, svc_actor);
+
+class myActor_c : public fopAc_ac_c {};
+
+int myActor_Create(void* i_this) {
+    // Ran several times, until it returns cPhs_COMPLEATE_e to allow for async loading
+    return cPhs_COMPLEATE_e;
+}
+
+int myActor_Delete(void* i_this) {
+    // Free resources here
+    return 1;
+}
+
+int myActor_Execute(void* i_this) {
+    // Ran once per game tick
+    return 1;
+}
+
+int myActor_IsDelete(void* i_this) {
+    // Returns 1 when the actor can be deleted
+    return 1;
+}
+
+int myActor_Draw(void* i_this) {
+    // Code to draw the actor
+    return 1;
+}
+
+s16 actor_name; // The process name that can be used by the game to load the actor
+ActorHandle actor_handle;
+ActorProfileDesc profDesc = {
+    .name = "AUnique", // The name used by the stage loader to load the actor with.
+                       // It has a character limit of 7 and must be unique among active
+                       // mod actors. Matching a game actor name overrides stage lookup.
+    .priority_group = 7, // When, relative to other actors _Execute should run
+                         // See: mods/svc/actor.h
+    .process_size = sizeof(myActor_c),
+    .draw_priority = fpcDwPi_OBJ_LBOX_e, // Defines when the actor should be drawn relative
+                                         // to other actors (see f_pc_draw_priority.h)
+    .status = fopAcStts_CULL_e  | fopAcStts_UNK_0x4000_e | fopAcStts_UNK_0x40000_e,
+    .group = fopAc_ACTOR_e, // Can be fopAc_ACTOR_e, fopAc_PLAYER_e, fopAc_ENEMY_e, or fopAc_NPC_e
+    .cull_type = fopAc_CULLBOX_CUSTOM_e,
+    .create_function = myActor_Create,
+    .delete_function = myActor_Delete,
+    .execute_function = myActor_Execute,
+    .is_delete_function = myActor_IsDelete,
+    .draw_function = myActor_Draw,
+};
+svc_actor->register_actor(mod_ctx, &profDesc, &actor_name, &actor_handle);
+
+// Spawn the actor at the player's position
+fopAc_ac_c* plr = dComIfGp_getPlayer(0);
+if (plr) {
+    ActorSpawnParams spawnParams = {
+        .parameters = 0,
+        .argument = 0,
+        .room_num = fopAcM_GetRoomNo(plr),
+        .position = {plr->current.pos.x, plr->current.pos.y, plr->current.pos.z},
+        .angle = {plr->current.angle.x, plr->current.angle.y, plr->current.angle.z},
+        .scale = {1.0f, 1.0f, 1.0f}
+    };
+    ActorId created_actor_id;
+    svc_actor->create_actor(mod_ctx, actor_name, &spawnParams, &created_actor_id);
+}
+```
+
+See `mods/custom_actor_demo` for a more complete example.
+
 ---
 
 ## Hooking Game Functions
 
+**Requires `add_mod(... FEATURES game)`**
+
 Mods may hook the vast majority of game functions, including file-local static, private and virtual functions.
-`mods/hook.hpp` provides typed helpers over the hook service:
+[`mods/svc/hook.hpp`](../sdk/include/mods/svc/hook.hpp) provides typed helpers over the hook service:
 
 ```cpp
-#include "mods/hook.hpp"
-#include "mods/svc/hook.h"
+#include "mods/svc/hook.hpp"
 
 IMPORT_SERVICE(HookService, svc_hook);
+
+DEFINE_HOOK(&daAlink_c::posMove, LinkPosMove);
+DEFINE_HOOK(&daAlink_c::execute, LinkExecute);
 ```
 
+Every hook target must be **declared** at namespace scope with `DEFINE_HOOK` (a target you can name in C++) or
+`DEFINE_HOOK_SYMBOL` (a symbol name).
+
 ### Pre-hooks
 
 Run before the original. Return `HOOK_SKIP_ORIGINAL` to cancel it (post-hooks still run).
 
 ```cpp
 HookAction on_pos_move_pre(ModContext*, void* args, void* retval, void* userdata) {
-    daAlink_c* link = dusk::mods::arg<daAlink_c*>(args, 0);  // arg 0 is `this`
+    daAlink_c* link = mods::arg<daAlink_c*>(args, 0);  // arg 0 is `this`
     if (link->shape_angle.y > 10000) {
         return HOOK_SKIP_ORIGINAL;
     }
     return HOOK_CONTINUE;
 }
 
-dusk::mods::hook_add_pre<&daAlink_c::posMove>(svc_hook, on_pos_move_pre);
+mods::hook::add_pre<LinkPosMove>(on_pos_move_pre);
 ```
 
 ### Post-hooks
@@ -447,24 +1333,22 @@ if any.
 ```cpp
 void on_pos_move_post(ModContext*, void* args, void* retval, void* userdata) { ... }
 
-dusk::mods::hook_add_post<&daAlink_c::posMove>(svc_hook, on_pos_move_post);
+mods::hook::add_post<LinkPosMove>(on_pos_move_post);
 ```
 
 ### Replace-hooks
 
-Substitute the original entirely. Call through to it via `Hook<...>::g_orig` if needed:
+Substitute the original entirely. Call through to it via the declaration's `g_orig` if needed:
 
 ```cpp
-using ExecuteEntry = dusk::mods::Hook<&daAlink_c::execute>;
-
 void on_execute_replace(ModContext*, void* args, void* retval, void*) {
-    int result = ExecuteEntry::g_orig(dusk::mods::arg<daAlink_c*>(args, 0));
+    int result = LinkExecute::g_orig(mods::arg<daAlink_c*>(args, 0));
     if (retval != nullptr) {
         *static_cast<int*>(retval) = result;
     }
 }
 
-dusk::mods::hook_replace<&daAlink_c::execute>(svc_hook, on_execute_replace);
+mods::hook::replace<LinkExecute>(on_execute_replace);
 ```
 
 By default a second replace-hook on the same function is a conflict; `HookOptions` (`replace_policy`, `priority`,
@@ -477,63 +1361,16 @@ Functions you can't name in C++ (file-local statics, private class members, anyt
 symbol name instead. You must supply the signature along with the name.
 
 ```cpp
-// static callback used by Link's hookshot collider in d_a_alink_hook.inc
-using HookshotHit = dusk::mods::NamedHook<
-    "daAlink_hookshotAtHitCallBack",
-    void(fopAc_ac_c*, dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*)>;
+DEFINE_HOOK_SYMBOL("daAlink_hookshotAtHitCallBack",
+    void(fopAc_ac_c*, dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*), HookshotHit);
 
-dusk::mods::hook_add_pre<HookshotHit>(svc_hook, on_hookshot_hit_pre);
+mods::hook::add_pre<HookshotHit>(on_hookshot_hit_pre);
 ...
 HookshotHit::g_orig(link, atObjInf, target, tgObjInf);  // call through to the original
 ```
 
 Class member functions must include `Class*` as the first argument.
 
-The install fails with the resolve error when the name is missing (`MOD_UNAVAILABLE`), ambiguous (`MOD_CONFLICT`),
-or the manifest is absent (`MOD_UNSUPPORTED`). Unlike `Hook<&Class::method>`, the signature is **not**
-compiler-checked: a mismatched signature will corrupt the call.
-
-### Reading and writing arguments
-
-`args` is an array of pointers to the arguments. For member functions, index 0 is `this`; parameters follow in
-declaration order.
-
-```cpp
-T  value = dusk::mods::arg<T>(args, n);      // copy
-T& ref   = dusk::mods::arg_ref<T>(args, n);  // read/write reference
-```
-
-```cpp
-// fpc_ProcID fopAcM_createItem(..., int itemNo, ...): turn heart drops into green rupees
-HookAction on_create_item_pre(ModContext*, void* args, void*, void*) {
-    int& itemNo = dusk::mods::arg_ref<int>(args, 1);
-    if (itemNo == dItemNo_HEART_e) {
-        itemNo = dItemNo_GREEN_RUPEE_e;
-    }
-    return HOOK_CONTINUE;
-}
-
-dusk::mods::hook_add_pre<&fopAcM_createItem>(svc_hook, on_create_item_pre);
-```
-
-For reference parameters (e.g. `const cXyz& pos`), `arg_ref<cXyz>` yields a direct reference.
-
-### Resolving symbols by name
-
-`resolve` looks a symbol up in the **symbol manifest**: a name→address map generated alongside every game build and
-keyed to that exact binary. It covers the whole image, including functions that aren't exported (file-local statics),
-which makes them hookable:
-
-```cpp
-IMPORT_SERVICE(HookService, svc_hook);
-
-void* addr = nullptr;
-uint32_t flags = 0;
-if (svc_hook->resolve(mod_ctx, "GXSetProjection", &addr, &flags) == MOD_OK) {
-    // addr is the function's real address in the running game; hook or call it.
-}
-```
-
 Two spellings work on every platform:
 
 - **Display names** (`daAlink_c::posMove`, `fapGm_Before`): the qualified name with no parameter list. They carry no
@@ -541,25 +1378,36 @@ Two spellings work on every platform:
 - **Decorated names** (`_ZN9daAlink_c7posMoveEv` / `?posMove@daAlink_c@@...`): the platform's mangled spelling in
   dlsym convention (no Mach-O leading underscore). The escape hatch for overloads.
 
-`MOD_UNSUPPORTED` means the manifest is missing or was built for a different game binary.
+Installing fails with `MOD_UNAVAILABLE` when it didn't resolve (missing, ambiguous, or no symbol manifest). Unlike
+`DEFINE_HOOK`, the signature is **not** compiler-checked: a mismatched signature will corrupt the
+call.
 
-### Game code ABI contract
+### Reading and writing arguments
 
-A primary consideration when letting mods link against the game is maintaining ABI stability across Dusklight
-versions. If your mod calls or hooks game code directly (anything beyond the service APIs), import `GameService`
-(`mods/svc/game.h`):
+`args` is an array of pointers to the arguments. For member functions, index 0 is `this`; parameters follow in
+declaration order.
 
 ```cpp
-IMPORT_SERVICE(GameService, svc_game);
+T  value = mods::arg<T>(args, n);      // copy
+T& ref   = mods::arg_ref<T>(args, n);  // read/write reference
 ```
 
-Its major version is the game code ABI epoch: it's bumped when game struct or vtable layouts change incompatibly, and
-the ordinary service version check then rejects your mod with a clear error instead of letting it corrupt memory in a
-version it wasn't built for. Service-only and asset-only mods should *not* import it and will continue to work across
-game ABI changes.
+```cpp
+DEFINE_HOOK(fopAcM_createItem, CreateItem);
 
-The more you can do through services, the better: a mod that avoids touching game code directly sidesteps future ABI
-breaks entirely and plays nicer with other enabled mods.
+// fpc_ProcID fopAcM_createItem(..., int itemNo, ...): turn heart drops into green rupees
+HookAction on_create_item_pre(ModContext*, void* args, void*, void*) {
+    int& itemNo = mods::arg_ref<int>(args, 1);
+    if (itemNo == dItemNo_HEART_e) {
+        itemNo = dItemNo_GREEN_RUPEE_e;
+    }
+    return HOOK_CONTINUE;
+}
+
+mods::hook::add_pre<CreateItem>(on_create_item_pre);
+```
+
+For reference parameters (e.g. `const cXyz& pos`), `arg_ref<cXyz>` yields a direct reference.
 
 ---
 
@@ -567,6 +1415,11 @@ breaks entirely and plays nicer with other enabled mods.
 
 Files placed under `overlay/` in the `.dusk` archive override game files at the corresponding path, equivalent to
 replacing files in the .iso. This requires no code: an archive with just `mod.json` and `overlay/` is a complete mod.
+To replace a file within an `.arc` archive, replace the archive suffix with a directory and place the replacement at
+its path within the archive.
+
+- `overlay/Audiores/Stream/menu_select.ast` replaces the main title's audio stream.
+- `overlay/res/Layout/main2D/main2d/timg/midona64.bti` replaces Midna's UI icon inside `main2D.arc`.
 
 Files placed under `textures/` register as texture replacements, and act just like the user's general
 `texture_replacements/` directory: Dolphin-style naming, matched by texture hash
@@ -615,13 +1468,13 @@ the stack for the whole session (e.g. the outermost main loop); a mod that does
 
 Service calls report failure through `ModResult` return values (`MOD_OK`, `MOD_UNAVAILABLE`,
 `MOD_INVALID_ARGUMENT`, ...). Lifecycle exports additionally receive a `ModError*`: fill it (e.g. with
-`dusk::mods::set_error(error, code, "message")`) and return the code, and the loader disables the mod and shows the
+`mods::set_error(error, code, "message")`) and return the code, and the loader disables the mod and shows the
 message to the user.
 
 ```cpp
 MOD_EXPORT ModResult mod_initialize(ModError* error) {
     if (!load_my_data()) {
-        return dusk::mods::set_error(error, MOD_ERROR, "failed to load data");
+        return mods::set_error(error, MOD_ERROR, "failed to load data");
     }
     return MOD_OK;
 }
@@ -632,7 +1485,9 @@ explicit results.
 
 ---
 
-## Advanced: Exporting Services
+## Advanced
+
+### Exporting Services
 
 Mods may export services of their own, permitting framework mods and cross-mod integration. Define the interface in a
 header both mods share:
@@ -653,9 +1508,10 @@ typedef struct MyModService {
 #ifdef __cplusplus
 #include "mods/service.hpp"
 template <>
-struct dusk::mods::ServiceTraits<MyModService> {
+struct mods::ServiceTraits<MyModService> {
     static constexpr const char* id = MY_MOD_SERVICE_ID;
     static constexpr uint16_t major_version = MY_MOD_SERVICE_MAJOR;
+    static constexpr uint16_t minor_version = MY_MOD_SERVICE_MINOR;
 };
 #endif
 ```
@@ -684,7 +1540,7 @@ svc_my_mod->do_thing(mod_ctx, 42);
 The loader registers all exports before resolving any imports, so declaration order between mods doesn't matter. Note
 that the `ctx` a provider receives identifies the *calling* mod.
 
-### Dependencies between mods
+#### Dependencies between mods
 
 Service imports are also dependency declarations: the loader initializes mods in dependency order, so by the time your
 `mod_initialize` runs, every mod you import services from (required *or* optional) has already finished its own
@@ -714,3 +1570,31 @@ For services whose construction can't happen at static-init time, declare the ex
 and publish the pointer later via `svc_host->publish_service(...)`. Consumers can fetch services dynamically with
 `svc_host->get_service(...)`; prefer manifest imports whenever possible, since they give the loader dependency
 information and fail fast with good errors.
+
+### Native Runtime Libraries
+
+`RUNTIME_LIBRARIES` passed to `add_mod` are packaged beside the mod's native module in `lib/<platform>/`. Dusklight
+extracts the whole directory before loading the mod, so libraries linked by the mod resolve normally. The SDK links the
+mod itself with `$ORIGIN` on Linux and `@loader_path` on Apple platforms; runtime libraries with their own non-system
+dependencies must also be built with origin-relative lookup paths. On Windows, Dusklight uses an isolated DLL search
+rooted at this directory.
+
+```cmake
+add_mod(my_mod
+        SOURCES src/mod.cpp
+        MOD_JSON mod.json
+        RUNTIME_LIBRARIES "${VENDOR_RUNTIME_LIBRARY}")
+```
+
+SDKs that load plugins by directory can pass them the absolute runtime path from the current HostService:
+
+```cpp
+IMPORT_SERVICE(HostService, svc_host);
+
+const char* nativeDir = svc_host->native_dir(mod_ctx);  // read-only
+```
+
+Libraries loaded explicitly by the mod remain its responsibility: stop their threads and unload them during
+`mod_shutdown`. Do not write into `native_dir`; use `data_dir` for persistent storage or `mod_dir` for temporary
+(session) storage. Native library namespaces are process-wide on some platforms, so two mods cannot safely assume that
+incompatible libraries with the same filename will remain isolated.
diff --git a/extern/aurora b/extern/aurora
index 0a5a5d90ef..d0c931da2e 160000
--- a/extern/aurora
+++ b/extern/aurora
@@ -1 +1 @@
-Subproject commit 0a5a5d90efd2dbc7b402ab61f1021922dbf7496f
+Subproject commit d0c931da2ed3f41d0e42736c2ab52a78c7cf1a9d
diff --git a/extern/borealis b/extern/borealis
new file mode 160000
index 0000000000..0bdba6c50a
--- /dev/null
+++ b/extern/borealis
@@ -0,0 +1 @@
+Subproject commit 0bdba6c50a46409c4862474c72b4a3a631fbe0ec
diff --git a/files.cmake b/files.cmake
index 15b64c3a3f..42a12c353c 100644
--- a/files.cmake
+++ b/files.cmake
@@ -244,7 +244,7 @@ set(DOLZEL_FILES
         src/CaptureScreen.cpp
 )
 if(DEBUG)
-    list(APPEND DOLZEL_FILES src/d/d_event_debug.cpp)
+        list(APPEND DOLZEL_FILES src/d/d_event_debug.cpp)
 endif(DEBUG)
 
 set(Z2AUDIOLIB_FILES
@@ -1404,117 +1404,223 @@ set(REL_FILES
 )
 
 set(DOLPHIN_FILES
-    libs/dolphin/src/gf/GFGeometry.cpp
-    libs/dolphin/src/gf/GFLight.cpp
-    libs/dolphin/src/gf/GFPixel.cpp
-    libs/dolphin/src/gf/GFTev.cpp
+        libs/dolphin/src/gf/GFGeometry.cpp
+        libs/dolphin/src/gf/GFLight.cpp
+        libs/dolphin/src/gf/GFPixel.cpp
+        libs/dolphin/src/gf/GFTev.cpp
 )
 
 set(DUSK_FILES
-        include/dusk/action_bindings.h
-        include/dusk/endian_gx.hpp
-        include/dusk/config.hpp
-        include/dusk/dvd_asset.hpp
-        include/dusk/scope_guard.hpp
-        src/dusk/dvd_asset.cpp
+        include/helpers/batch.hpp
+        include/helpers/bits.hpp
+        include/helpers/endian_gx.hpp
         src/d/actor/d_a_alink_dusk.cpp
-        src/dusk/android_frame_rate.hpp
-        src/dusk/android_frame_rate.cpp
+        src/dusk/OSContext.cpp
+        src/dusk/OSMutex.cpp
+        src/dusk/OSReport.cpp
+        src/dusk/OSThread.cpp
+        src/dusk/achievements.cpp
+        src/dusk/action_bindings.cpp
+        src/dusk/action_bindings.h
+        src/dusk/archive.cpp
+        src/dusk/archive.hpp
         src/dusk/asserts.cpp
-        src/dusk/batch.cpp
-        src/dusk/batch.hpp
+        src/dusk/autosave.cpp
         src/dusk/config.cpp
-        src/dusk/crash_handler.cpp
-        src/dusk/crash_reporting.cpp
+        src/dusk/config.hpp
         src/dusk/data.cpp
         src/dusk/data.hpp
-        src/dusk/endian.cpp
+        src/dusk/discord_presence.cpp
+        src/dusk/dvd_asset.cpp
+        src/dusk/dvd_asset.hpp
         src/dusk/extras.c
-        src/dusk/file_select.cpp
-        src/dusk/file_select.hpp
-        src/dusk/frame_interpolation.cpp
+        src/dusk/commands.cpp
+        src/dusk/commands.hpp
         src/dusk/game_clock.cpp
+        src/dusk/hash.hpp
+        src/dusk/game_mode.cpp
+        src/dusk/gamepad_color.cpp
         src/dusk/globals.cpp
         src/dusk/gyro.cpp
-        include/dusk/menu_pointer.h
-        src/dusk/menu_pointer.cpp
-        src/dusk/mouse.cpp
-		src/dusk/gamepad_color.cpp
-		src/dusk/autosave.cpp
-        src/dusk/http/http.hpp
-        src/dusk/io.cpp
-        src/dusk/layout.cpp
-        src/dusk/logging.cpp
-        src/dusk/settings.cpp
-        src/dusk/speedrun.cpp
-        src/dusk/string.cpp
-        src/dusk/stubs.cpp
-        include/dusk/texture_replacements.hpp
-        src/dusk/texture_replacements.cpp
-        src/dusk/touch_camera.cpp
-        src/dusk/update_check.cpp
-        src/dusk/update_check.hpp
+        src/dusk/game_combos.cpp
+        src/dusk/trigger_viewer.cpp
         #src/dusk/m_Do_ext_dusk.cpp
-        src/dusk/imgui/ImGuiConfig.hpp
-        src/dusk/imgui/ImGuiConsole.hpp
-        src/dusk/imgui/ImGuiConsole.cpp
-        src/dusk/imgui/ImGuiEngine.cpp
-        src/dusk/imgui/ImGuiEngine.hpp
+        src/dusk/hq_minimap.cpp
+        src/dusk/imgui/ImGuiActorSpawner.cpp
         src/dusk/imgui/ImGuiBloomWindow.cpp
         src/dusk/imgui/ImGuiBloomWindow.hpp
+        src/dusk/imgui/ImGuiCameraOverlay.cpp
+        src/dusk/imgui/ImGuiConfig.hpp
+        src/dusk/imgui/ImGuiConsole.cpp
+        src/dusk/imgui/ImGuiConsole.hpp
+        src/dusk/imgui/ImGuiControllerOverlay.cpp
+        src/dusk/imgui/ImGuiEngine.cpp
+        src/dusk/imgui/ImGuiEngine.hpp
+        src/dusk/imgui/ImGuiHeapOverlay.cpp
         src/dusk/imgui/ImGuiMenuTools.cpp
         src/dusk/imgui/ImGuiMenuTools.hpp
-        src/dusk/imgui/ImGuiActorSpawner.cpp
         src/dusk/imgui/ImGuiProcessOverlay.cpp
-        src/dusk/imgui/ImGuiCameraOverlay.cpp
-        src/dusk/imgui/ImGuiHeapOverlay.cpp
-        src/dusk/imgui/ImGuiControllerOverlay.cpp
-        src/dusk/imgui/ImGuiStubLog.cpp
         src/dusk/imgui/ImGuiSaveEditor.cpp
-        src/dusk/imgui/ImGuiStateShare.hpp
         src/dusk/imgui/ImGuiStateShare.cpp
+        src/dusk/imgui/ImGuiStateShare.hpp
+        src/dusk/imgui/ImGuiStubLog.cpp
+        src/dusk/interp/camera.cpp
+        src/dusk/interp/dual_buffer.cpp
+        src/dusk/interp/frame_interpolation.cpp
+        src/dusk/interp/line.cpp
+        src/dusk/io.cpp
+        src/dusk/iso_validate.cpp
+        src/dusk/language.cpp
+        src/dusk/language.hpp
+        src/dusk/layout.cpp
+        src/dusk/livesplit.cpp
+        src/dusk/logging.cpp
+        src/dusk/menu_pointer.cpp
+        src/dusk/menu_pointer.h
+        src/dusk/mods/loader/bundle_disk.cpp
+        src/dusk/mods/loader/bundle_zip.cpp
+        src/dusk/mods/loader/context.cpp
+        src/dusk/mods/loader/depgraph.cpp
+        src/dusk/mods/loader/depgraph.hpp
+        src/dusk/mods/loader/loader.cpp
+        src/dusk/mods/loader/loader.hpp
+        src/dusk/mods/loader/manifest.cpp
+        src/dusk/mods/loader/manifest.hpp
+        src/dusk/mods/loader/natives.cpp
+        src/dusk/mods/loader/natives.hpp
+        src/dusk/mods/loader/packages.cpp
+        src/dusk/mods/loader/packages.hpp
+        src/dusk/mods/loader/native_module.cpp
+        src/dusk/mods/loader/native_module.hpp
+        src/dusk/mods/loader/prepatch.cpp
+        src/dusk/mods/loader/prepatch.hpp
+        src/dusk/mods/catalog.cpp
+        src/dusk/mods/catalog.hpp
+        src/dusk/mods/queue.cpp
+        src/dusk/mods/queue.hpp
+        src/dusk/mods/item.hpp
+        src/dusk/mods/item_actor.cpp
+        src/dusk/mods/item_checks.cpp
+        src/dusk/mods/item_gives.cpp
+        src/dusk/mods/log_buffer.cpp
+        src/dusk/mods/log_buffer.hpp
+        src/dusk/mods/manifest.cpp
+        src/dusk/mods/manifest.hpp
+        src/dusk/mods/svc/actor.cpp
+        src/dusk/mods/svc/camera.cpp
+        src/dusk/mods/svc/config.cpp
+        src/dusk/mods/svc/config.hpp
+        src/dusk/mods/svc/file.cpp
+        src/dusk/mods/svc/game.cpp
+        src/dusk/mods/svc/gfx.cpp
+        src/dusk/mods/svc/flow.cpp
+        src/dusk/mods/svc/hook.cpp
+        src/dusk/mods/svc/host.cpp
+        src/dusk/mods/svc/http.cpp
+        src/dusk/mods/svc/net.cpp
+        src/dusk/mods/svc/net.hpp
+        src/dusk/mods/svc/websocket.cpp
+        src/dusk/mods/svc/item.cpp
+        src/dusk/mods/svc/item.hpp
+        src/dusk/mods/svc/log.cpp
+        src/dusk/mods/svc/overlay.cpp
+        src/dusk/mods/svc/registry.cpp
+        src/dusk/mods/svc/registry.hpp
+        src/dusk/mods/svc/resource.cpp
+        src/dusk/mods/svc/texture.cpp
+        src/dusk/mods/svc/ui.cpp
+        src/dusk/mods/svc/ui.hpp
+        src/dusk/mods/svc/game_mode.cpp
+        src/dusk/mods/svc/window.cpp
+        src/dusk/mods/svc/window.hpp
+        src/dusk/mods/svc/save.cpp
+        src/dusk/mods/svc/save.hpp
+        src/dusk/mods/svc/stage.cpp
+        src/dusk/mods/svc/stage.hpp
+        src/dusk/mouse.cpp
+        src/dusk/presentation.cpp
+        src/dusk/presentation.hpp
+        src/dusk/scope_guard.hpp
+        src/dusk/settings.cpp
+        src/dusk/speedrun.cpp
+        src/dusk/stubs.cpp
+        src/dusk/texture_replacements.cpp
+        src/dusk/texture_replacements.hpp
+        src/dusk/touch_camera.cpp
         src/dusk/ui/achievements.cpp
         src/dusk/ui/achievements.hpp
+        src/dusk/ui/command_console.cpp
+        src/dusk/ui/command_console.hpp
         src/dusk/ui/bool_button.cpp
         src/dusk/ui/bool_button.hpp
         src/dusk/ui/button.cpp
         src/dusk/ui/button.hpp
+        src/dusk/ui/color_input.cpp
+        src/dusk/ui/color_input.hpp
         src/dusk/ui/component.cpp
         src/dusk/ui/component.hpp
-        src/dusk/ui/controls.hpp
         src/dusk/ui/controller_config.cpp
         src/dusk/ui/controller_config.hpp
+        src/dusk/ui/controls.hpp
         src/dusk/ui/document.cpp
         src/dusk/ui/document.hpp
+        src/dusk/ui/drop_install_modal.cpp
+        src/dusk/ui/drop_install_modal.hpp
         src/dusk/ui/editor.cpp
         src/dusk/ui/editor.hpp
         src/dusk/ui/event.cpp
         src/dusk/ui/event.hpp
         src/dusk/ui/graphics_tuner.cpp
         src/dusk/ui/graphics_tuner.hpp
-        src/dusk/ui/input.cpp
-        src/dusk/ui/input.hpp
+        src/dusk/ui/group_button.cpp
+        src/dusk/ui/group_button.hpp
+        src/dusk/ui/file_button.cpp
+        src/dusk/ui/file_button.hpp
         src/dusk/ui/icon_provider.cpp
         src/dusk/ui/icon_provider.hpp
+        src/dusk/ui/input.cpp
+        src/dusk/ui/input.hpp
         src/dusk/ui/logs_window.cpp
         src/dusk/ui/logs_window.hpp
+        src/dusk/ui/list.cpp
+        src/dusk/ui/list.hpp
+        src/dusk/ui/menu_bar.cpp
+        src/dusk/ui/menu_bar.hpp
+        src/dusk/ui/mod_browser.cpp
+        src/dusk/ui/mod_browser.hpp
+        src/dusk/ui/queue_window.cpp
+        src/dusk/ui/queue_window.hpp
+        src/dusk/ui/package_row.cpp
+        src/dusk/ui/package_row.hpp
         src/dusk/ui/mod_texture_provider.cpp
         src/dusk/ui/mod_texture_provider.hpp
+        src/dusk/ui/remote_texture_provider.cpp
+        src/dusk/ui/remote_texture_provider.hpp
+        src/dusk/ui/runtime_image.cpp
+        src/dusk/ui/runtime_image.hpp
         src/dusk/ui/mod_window.cpp
         src/dusk/ui/mod_window.hpp
         src/dusk/ui/modal.cpp
         src/dusk/ui/modal.hpp
+        src/dusk/ui/mods_window.cpp
+        src/dusk/ui/mods_window.hpp
         src/dusk/ui/nav_types.hpp
+        src/dusk/ui/nav_group.cpp
+        src/dusk/ui/nav_group.hpp
+        src/dusk/ui/context_menu.cpp
+        src/dusk/ui/context_menu.hpp
+        src/dusk/ui/icon_button.cpp
+        src/dusk/ui/icon_button.hpp
+        src/dusk/ui/tooltip.cpp
+        src/dusk/ui/tooltip.hpp
         src/dusk/ui/number_button.cpp
         src/dusk/ui/number_button.hpp
         src/dusk/ui/overlay.cpp
         src/dusk/ui/overlay.hpp
         src/dusk/ui/pane.cpp
         src/dusk/ui/pane.hpp
-        src/dusk/ui/menu_bar.cpp
-        src/dusk/ui/menu_bar.hpp
-        src/dusk/ui/mods_window.cpp
-        src/dusk/ui/mods_window.hpp
+        src/dusk/ui/popover.cpp
+        src/dusk/ui/popover.hpp
         src/dusk/ui/prelaunch.cpp
         src/dusk/ui/prelaunch.hpp
         src/dusk/ui/preset.cpp
@@ -1529,10 +1635,10 @@ set(DUSK_FILES
         src/dusk/ui/string_button.hpp
         src/dusk/ui/tab_bar.cpp
         src/dusk/ui/tab_bar.hpp
-        src/dusk/ui/touch_controls_common.cpp
-        src/dusk/ui/touch_controls_common.hpp
         src/dusk/ui/touch_controls.cpp
         src/dusk/ui/touch_controls.hpp
+        src/dusk/ui/touch_controls_common.cpp
+        src/dusk/ui/touch_controls_common.hpp
         src/dusk/ui/touch_controls_editor.cpp
         src/dusk/ui/touch_controls_editor.hpp
         src/dusk/ui/ui.cpp
@@ -1541,50 +1647,10 @@ set(DUSK_FILES
         src/dusk/ui/warp.hpp
         src/dusk/ui/window.cpp
         src/dusk/ui/window.hpp
-        src/dusk/achievements.cpp
-        src/dusk/iso_validate.cpp
-        src/dusk/livesplit.cpp
-        src/dusk/offset_ptr.cpp
-        src/dusk/OSContext.cpp
-        src/dusk/OSReport.cpp
-        src/dusk/OSThread.cpp
-        src/dusk/OSMutex.cpp
-        src/dusk/mods/log_buffer.cpp
-        src/dusk/mods/log_buffer.hpp
-        src/dusk/mods/manifest.cpp
-        src/dusk/mods/manifest.hpp
-        src/dusk/mods/loader/bundle_disk.cpp
-        src/dusk/mods/loader/bundle_zip.cpp
-        src/dusk/mods/loader/context.cpp
-        src/dusk/mods/loader/depgraph.cpp
-        src/dusk/mods/loader/depgraph.hpp
-        src/dusk/mods/loader/loader.cpp
-        src/dusk/mods/loader/loader.hpp
-        src/dusk/mods/loader/native_module.cpp
-        src/dusk/mods/loader/native_module.hpp
-        src/dusk/mods/svc/config.cpp
-        src/dusk/mods/svc/config.hpp
-        src/dusk/mods/svc/game.cpp
-        src/dusk/mods/svc/hook.cpp
-        src/dusk/mods/svc/host.cpp
-        src/dusk/mods/svc/log.cpp
-        src/dusk/mods/svc/overlay.cpp
-        src/dusk/mods/svc/resource.cpp
-        src/dusk/mods/svc/texture.cpp
-        src/dusk/mods/svc/ui.cpp
-        src/dusk/mods/svc/ui.hpp
-        src/dusk/mods/svc/registry.cpp
-        src/dusk/mods/svc/registry.hpp
-        src/dusk/discord.cpp
-        src/dusk/discord.hpp
-        src/dusk/discord_presence.cpp
         src/dusk/version.cpp
-        src/dusk/action_bindings.cpp
-)
-
-set(DUSK_HTTP_BACKEND_FILES
-        src/dusk/http/no_backend.cpp
-        src/dusk/http/curl.cpp
-        src/dusk/http/winhttp.cpp
-        src/dusk/http/url_session.mm
+        src/dusk/utilities.cpp
+        src/helpers/batch.cpp
+        src/helpers/endian.cpp
+        src/helpers/offset_ptr.cpp
+        src/helpers/string.cpp
 )
diff --git a/flake.nix b/flake.nix
index 6be8c03aef..01a20fad2d 100644
--- a/flake.nix
+++ b/flake.nix
@@ -2,6 +2,7 @@
   description = "Dusklight — native PC port of the Twilight Princess decompilation";
 
   inputs.nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
+  inputs.self.submodules = true;
 
   outputs =
     { self, nixpkgs }:
@@ -58,21 +59,6 @@
           hasNodPrebuilt = nodPrebuiltInfo ? ${system};
 
           aurora = builtins.pathExists "${self}/extern/aurora/CMakeLists.txt";
-          needSubmodules = ''
-            dusklight: The aurora submodule is not vendored. Add submodules=1 to build.
-
-            As a flake input:
-
-            dusklight.url = "git+https://github.com/TwilitRealm/dusklight?ref=main&submodules=1";
-
-            nix command:
-
-            nix run 'git+https://github.com/TwilitRealm/dusklight?submodules=1'
-
-            Local checkout:
-
-            nix run '.?submodules=1#dusklight'
-          '';
 
           dawn = pkgs.fetchzip {
             url = "https://github.com/encounter/dawn/releases/download/${dawnVersion}/dawn-${dawnInfo.${system}.triple}.tar.gz";
@@ -140,6 +126,14 @@
             JSON = pkgs.nlohmann_json.src;
             XXHASH = pkgs.xxhash.src;
             ZSTD = pkgs.zstd.src;
+
+
+            MINIZ = pkgs.fetchzip {
+              url = "https://github.com/richgel999/miniz/releases/download/3.0.2/miniz-3.0.2.zip";
+              hash = "sha256-DXysXkQEmoDAMMg1F8KexkwpXNyiHNzLJqXR9SMEkxk=";
+              stripRoot = false;
+            };
+
             FMT = pkgs.fetchzip {
               url = "https://github.com/fmtlib/fmt/archive/refs/tags/12.1.0.tar.gz";
               hash = "sha256-ZmI1Dv0ZabPlxa02OpERI47jp7zFfjpeWCy1WyuPYZ0=";
@@ -165,19 +159,16 @@
           };
 
           dusklight =
-            if !aurora then
-              throw needSubmodules
-            else
-              pkgs.stdenv.mkDerivation {
-                pname = "dusklight";
-                version = versionSuffix;
-                src = ./.;
+            pkgs.stdenv.mkDerivation {
+              pname = "dusklight";
+              version = versionSuffix;
+              src = ./.;
 
-                postUnpack = ''
-                  chmod -R u+w "$sourceRoot"
-                  substituteInPlace "$sourceRoot/extern/aurora/CMakeLists.txt" \
-                    --replace-warn "add_subdirectory(tests)" ""
-                '';
+              postUnpack = ''
+                chmod -R u+w "$sourceRoot"
+                substituteInPlace "$sourceRoot/extern/aurora/CMakeLists.txt" \
+                  --replace-warn "add_subdirectory(tests)" ""
+              '';
 
                 nativeBuildInputs = [
                   pkgs.cmake
@@ -237,7 +228,7 @@
                 ninjaFlags = [ "dusklight" ];
 
                 cmakeFlags = [
-                  "-DDUSK_VERSION_OVERRIDE=${versionSuffix}"
+                  "-DBOREALIS_APP_VERSION_OVERRIDE=${versionSuffix}"
                   "-DFETCHCONTENT_FULLY_DISCONNECTED=ON"
                   "-DAURORA_DAWN_PROVIDER=package"
                   "-DAURORA_DAWN_LINKAGE=static"
diff --git a/include/DynamicLink.h b/include/DynamicLink.h
index 7f6d8568eb..1f9a1c8eeb 100644
--- a/include/DynamicLink.h
+++ b/include/DynamicLink.h
@@ -88,9 +88,9 @@ struct DynamicModuleControl : DynamicModuleControlBase {
     /* 0x24 */ s32 mSize;
     /* 0x28 */ mDoDvdThd_callback_c* mAsyncLoadCallback;
 
-    static u32 sAllocBytes;
-    static JKRArchive* sArchive;
-    static JKRFileCache* sFileCache;
+    static DUSK_GAME_DATA u32 sAllocBytes;
+    static DUSK_GAME_DATA JKRArchive* sArchive;
+    static DUSK_GAME_DATA JKRFileCache* sFileCache;
 };
 
 #endif /* DYNAMICLINK_H */
diff --git a/include/SSystem/SComponent/c_API.h b/include/SSystem/SComponent/c_API.h
index 8fcd246b2d..2bb68e5cdd 100644
--- a/include/SSystem/SComponent/c_API.h
+++ b/include/SSystem/SComponent/c_API.h
@@ -12,6 +12,6 @@ struct cAPI_Interface {
     /* 0x14 */ cAPIGph_Mthd blankingOffMtd;
 };
 
-extern cAPI_Interface g_cAPI_Interface;
+DUSK_GAME_EXTERN cAPI_Interface g_cAPI_Interface;
 
 #endif /* C_API_H */
diff --git a/include/SSystem/SComponent/c_angle.h b/include/SSystem/SComponent/c_angle.h
index f851033eab..f5788f75d2 100644
--- a/include/SSystem/SComponent/c_angle.h
+++ b/include/SSystem/SComponent/c_angle.h
@@ -24,11 +24,11 @@ private:
     s16 mAngle;
 
 public:
-    const static cSAngle _0;
-    const static cSAngle _1;
-    const static cSAngle _90;
-    const static cSAngle _180;
-    const static cSAngle _270;
+    const static DUSK_GAME_DATA cSAngle _0;
+    const static DUSK_GAME_DATA cSAngle _1;
+    const static DUSK_GAME_DATA cSAngle _90;
+    const static DUSK_GAME_DATA cSAngle _180;
+    const static DUSK_GAME_DATA cSAngle _270;
 #ifdef __MWERKS__
     cSAngle() {}
     ~cSAngle() {}
diff --git a/include/SSystem/SComponent/c_bg_s_chk.h b/include/SSystem/SComponent/c_bg_s_chk.h
index adbc0c1807..badc04679a 100644
--- a/include/SSystem/SComponent/c_bg_s_chk.h
+++ b/include/SSystem/SComponent/c_bg_s_chk.h
@@ -5,7 +5,6 @@
 #include "f_pc/f_pc_base.h"
 #include "SSystem/SComponent/c_bg_s_grp_pass_chk.h"
 #include "SSystem/SComponent/c_bg_s_poly_pass_chk.h"
-#include "dusk/endian.h"
 
 struct cBgD_Vtx_t : public Vec {};
 
diff --git a/include/SSystem/SComponent/c_cc_d.h b/include/SSystem/SComponent/c_cc_d.h
index 66c71a4ead..7a8400a55a 100644
--- a/include/SSystem/SComponent/c_cc_d.h
+++ b/include/SSystem/SComponent/c_cc_d.h
@@ -435,7 +435,7 @@ public:
 
     cM3dGAab& GetWorkAab() { return mAab; }
 
-    static cXyz m_virtual_center;
+    static DUSK_GAME_DATA cXyz m_virtual_center;
 };
 
 STATIC_ASSERT(0x20 == sizeof(cCcD_ShapeAttr));
diff --git a/include/SSystem/SComponent/c_counter.h b/include/SSystem/SComponent/c_counter.h
index 864554b1a7..c67524fb73 100644
--- a/include/SSystem/SComponent/c_counter.h
+++ b/include/SSystem/SComponent/c_counter.h
@@ -9,7 +9,7 @@ struct counter_class {
     u32 mTimer;
 };
 
-extern counter_class g_Counter;
+DUSK_GAME_EXTERN counter_class g_Counter;
 
 void cCt_Counter(int resetCounter1);
 
diff --git a/include/SSystem/SComponent/c_lib.h b/include/SSystem/SComponent/c_lib.h
index 75d4544341..4be9645bc4 100644
--- a/include/SSystem/SComponent/c_lib.h
+++ b/include/SSystem/SComponent/c_lib.h
@@ -102,6 +102,6 @@ void MtxPosition(cXyz DUSK_CONST*, cXyz*);
 void MtxPush(void);
 void MtxPull(void);
 
-extern Mtx* calc_mtx;
+DUSK_GAME_EXTERN Mtx* calc_mtx;
 
 #endif
diff --git a/include/SSystem/SComponent/c_m3d.h b/include/SSystem/SComponent/c_m3d.h
index 94762d5a29..50c92a2934 100644
--- a/include/SSystem/SComponent/c_m3d.h
+++ b/include/SSystem/SComponent/c_m3d.h
@@ -20,7 +20,7 @@ struct cM3d_Range {
 };
 
 #define G_CM3D_F_INF (1000000000.0f)
-extern const f32 G_CM3D_F_ABS_MIN;
+DUSK_GAME_EXTERN const f32 G_CM3D_F_ABS_MIN;
 
 static void cM3d_InDivPos1(const Vec*, const Vec*, f32, Vec*);
 void cM3d_InDivPos2(const Vec*, const Vec*, f32, Vec*);
diff --git a/include/SSystem/SComponent/c_m3d_g_tri.h b/include/SSystem/SComponent/c_m3d_g_tri.h
index cac178e064..cd535d66c3 100644
--- a/include/SSystem/SComponent/c_m3d_g_tri.h
+++ b/include/SSystem/SComponent/c_m3d_g_tri.h
@@ -2,7 +2,6 @@
 #define C_M3D_G_TRI_H_
 
 #include "SSystem/SComponent/c_m3d_g_pla.h"
-#include "dusk/endian.h"
 
 class cM3dGCyl;
 
diff --git a/include/SSystem/SComponent/c_malloc.h b/include/SSystem/SComponent/c_malloc.h
index 95b2d8f298..5eb775e033 100644
--- a/include/SSystem/SComponent/c_malloc.h
+++ b/include/SSystem/SComponent/c_malloc.h
@@ -6,7 +6,7 @@
 class JKRHeap;
 
 struct cMl {
-    static JKRHeap* Heap;
+    static DUSK_GAME_DATA JKRHeap* Heap;
     static void init(JKRHeap*);
     static void* memalignB(int, u32);
     static void free(void*);
diff --git a/include/SSystem/SComponent/c_sxyz.h b/include/SSystem/SComponent/c_sxyz.h
index bfaa035de9..4b2ea4dd45 100644
--- a/include/SSystem/SComponent/c_sxyz.h
+++ b/include/SSystem/SComponent/c_sxyz.h
@@ -9,7 +9,7 @@ struct SVec {
 
 class csXyz : public SVec {
 public:
-    static const csXyz Zero;
+    static DUSK_GAME_DATA const csXyz Zero;
     ~csXyz() {}
     csXyz() {}
     csXyz(s16, s16, s16);
diff --git a/include/SSystem/SComponent/c_xyz.h b/include/SSystem/SComponent/c_xyz.h
index 66dff18fd2..87cd6648d1 100644
--- a/include/SSystem/SComponent/c_xyz.h
+++ b/include/SSystem/SComponent/c_xyz.h
@@ -14,14 +14,14 @@ struct cXy {
 };
 
 struct cXyz : Vec {
-    static const cXyz Zero;
-    static const cXyz BaseX;
-    static const cXyz BaseY;
-    static const cXyz BaseZ;
-    static const cXyz BaseXY;
-    static const cXyz BaseXZ;
-    static const cXyz BaseYZ;
-    static const cXyz BaseXYZ;
+    static DUSK_GAME_DATA const cXyz Zero;
+    static DUSK_GAME_DATA const cXyz BaseX;
+    static DUSK_GAME_DATA const cXyz BaseY;
+    static DUSK_GAME_DATA const cXyz BaseZ;
+    static DUSK_GAME_DATA const cXyz BaseXY;
+    static DUSK_GAME_DATA const cXyz BaseXZ;
+    static DUSK_GAME_DATA const cXyz BaseYZ;
+    static DUSK_GAME_DATA const cXyz BaseXYZ;
 #ifdef __MWERKS__
     cXyz() {}
     ~cXyz() {}
diff --git a/include/Z2AudioCS/SpkMixingBuffer.h b/include/Z2AudioCS/SpkMixingBuffer.h
index ccdb8902b0..5cdfcd74bb 100644
--- a/include/Z2AudioCS/SpkMixingBuffer.h
+++ b/include/Z2AudioCS/SpkMixingBuffer.h
@@ -13,7 +13,6 @@ public:
     bool update(s32 chan);
     void bzeroBuffer(s32 chan);
 
-private:
     /* 0x00 */ s16* mBuffer[4];
 };
 
diff --git a/include/Z2AudioCS/SpkSpeakerCtrl.h b/include/Z2AudioCS/SpkSpeakerCtrl.h
index 7216eed07d..372d5b1835 100644
--- a/include/Z2AudioCS/SpkSpeakerCtrl.h
+++ b/include/Z2AudioCS/SpkSpeakerCtrl.h
@@ -41,7 +41,6 @@ public:
     static bool checkRadioSensitivity(s32 chan);
     static bool isSubmitPlayByRadioSensitivity(s32 chan);
 
-private:
 };
 
 #endif /* Z2AUDIOCS_SPKSPEAKERCTRL_H */
diff --git a/include/Z2AudioCS/SpkSystem.h b/include/Z2AudioCS/SpkSystem.h
index 05541c72e5..03b30cda6e 100644
--- a/include/Z2AudioCS/SpkSystem.h
+++ b/include/Z2AudioCS/SpkSystem.h
@@ -28,7 +28,6 @@ public:
     inline SpkData* getData(void) const { return mData; }
     inline SpkMixingBuffer* getMixingBuffer(void) const { return mMixingBuffer; }
 
-private:
     /* 0x00 */ JKRHeap* mHeap;
     /* 0x04 */ SpkData* mData;
     /* 0x08 */ SpkMixingBuffer* mMixingBuffer;
diff --git a/include/Z2AudioCS/SpkTable.h b/include/Z2AudioCS/SpkTable.h
index 862fdba3c1..f2234f5a06 100644
--- a/include/Z2AudioCS/SpkTable.h
+++ b/include/Z2AudioCS/SpkTable.h
@@ -31,7 +31,6 @@ public:
         return (SpkTableParams*)mEntryOffset + num;
     }
 
-    // private:
     /* 0x00 */ bool mIsInitialized;
     /* 0x04 */ s32 mNumOfSound;
     /* 0x08 */ u32 mEntryOffset;
diff --git a/include/Z2AudioCS/SpkWave.h b/include/Z2AudioCS/SpkWave.h
index 6a604d8a50..72cde1c0a0 100644
--- a/include/Z2AudioCS/SpkWave.h
+++ b/include/Z2AudioCS/SpkWave.h
@@ -25,7 +25,6 @@ public:
     inline const void* getResource(void) const { return mWaveData; }
     inline void* getResource(void) { return mWaveData; }
 
-private:
     /* 0x00 */ void* mWaveData;
 };
 
diff --git a/include/Z2AudioLib/Z2Audience.h b/include/Z2AudioLib/Z2Audience.h
index 75998e878b..e6d2f7da3a 100644
--- a/include/Z2AudioLib/Z2Audience.h
+++ b/include/Z2AudioLib/Z2Audience.h
@@ -256,7 +256,7 @@ inline Z2Audience* Z2GetAudience() {
     return JASGlobalInstance<Z2Audience>::getInstance();
 }
 
-extern s8 data_80451358;
-extern s8 data_80451359;
+DUSK_GAME_EXTERN s8 data_80451358;
+DUSK_GAME_EXTERN s8 data_80451359;
 
 #endif /* Z2AUDIENCE_H */
diff --git a/include/Z2AudioLib/Z2AudioMgr.h b/include/Z2AudioLib/Z2AudioMgr.h
index 0f8e5a17ea..82fbdee7e4 100644
--- a/include/Z2AudioLib/Z2AudioMgr.h
+++ b/include/Z2AudioLib/Z2AudioMgr.h
@@ -34,7 +34,7 @@ public:
     bool isResetting() { return mResettingFlag; }
 
     static Z2AudioMgr* getInterface() { return mAudioMgrPtr; }
-    static Z2AudioMgr* mAudioMgrPtr;
+    static DUSK_GAME_DATA Z2AudioMgr* mAudioMgrPtr;
 
     /* 0x0514 */ virtual bool startSound(JAISoundID soundID, JAISoundHandle* handle, const JGeometry::TVec3<f32>* posPtr);
     /* 0x0518 */ bool mResettingFlag;
diff --git a/include/Z2AudioLib/Z2Calc.h b/include/Z2AudioLib/Z2Calc.h
index e8eee29571..ded419e9f4 100644
--- a/include/Z2AudioLib/Z2Calc.h
+++ b/include/Z2AudioLib/Z2Calc.h
@@ -42,8 +42,8 @@ f32 getParamByExp(f32 value, f32 inMin, f32 inMax, f32 exponent, f32 outMin, f32
 f32 getRandom(f32 magnitude, f32 exponent, f32 bias);
 f32 getRandom_0_1();
 
-extern const f32 cEqualCSlope;
-extern const f32 cEqualPSlope;
+DUSK_GAME_EXTERN const f32 cEqualCSlope;
+DUSK_GAME_EXTERN const f32 cEqualPSlope;
 }  // namespace Z2Calc
 
 #endif /* Z2CALC_H */
diff --git a/include/Z2AudioLib/Z2Creature.h b/include/Z2AudioLib/Z2Creature.h
index c4f96ca742..c17394b75f 100644
--- a/include/Z2AudioLib/Z2Creature.h
+++ b/include/Z2AudioLib/Z2Creature.h
@@ -67,7 +67,6 @@ public:
     void playVoice(int);
     virtual Z2SoundHandlePool* startCreatureVoice(JAISoundID soundID, s8 reverb);
 
-private:
     /* 0xA0 */ s8 mCitizenID;
     /* 0xA1 */ s8 field_0xa1;
     /* 0xA2 */ bool mLinkSearch;
diff --git a/include/Z2AudioLib/Z2EnvSeMgr.h b/include/Z2AudioLib/Z2EnvSeMgr.h
index 464da590de..f2f4dc175a 100644
--- a/include/Z2AudioLib/Z2EnvSeMgr.h
+++ b/include/Z2AudioLib/Z2EnvSeMgr.h
@@ -175,7 +175,7 @@ struct Z2EnvSeMgr : public JASGlobalInstance<Z2EnvSeMgr> {
 
 STATIC_ASSERT(sizeof(Z2EnvSeMgr) == 0x30C);
 
-extern Z2EnvSeMgr g_mEnvSeMgr;
+DUSK_GAME_EXTERN Z2EnvSeMgr g_mEnvSeMgr;
 
 inline Z2EnvSeMgr* Z2GetEnvSeMgr() {
     return JASGlobalInstance<Z2EnvSeMgr>::getInstance();
diff --git a/include/Z2AudioLib/Z2LinkMgr.h b/include/Z2AudioLib/Z2LinkMgr.h
index cf05ed14d9..e64c1729eb 100644
--- a/include/Z2AudioLib/Z2LinkMgr.h
+++ b/include/Z2AudioLib/Z2LinkMgr.h
@@ -57,13 +57,12 @@ public:
     void setUsingIronBall(bool isUsingIronBall) { mUsingIronBall = isUsingIronBall; }
     void setMarkState(u8 state) { mMarkState = state; }
 
-    static Z2CreatureLink* mLinkPtr;
+    static DUSK_GAME_DATA Z2CreatureLink* mLinkPtr;
     static Z2CreatureLink* getLink() { return mLinkPtr; }
 
     friend class Z2LinkSoundStarter;
     friend struct Z2RideSoundStarter;
 
-private:
     /* 0x90 Z2LinkSoundStarter */
     /* 0x94 */ Z2SoundObjSimple mKantera;
     /* 0xB4 */ Vec field_0xb4;
@@ -123,7 +122,6 @@ public:
 
     virtual void deleteObject();
 
-private:
     /* 0x90 */  // Z2RideSoundStarter mSoundStarter;
     /* 0x98 */ bool mLinkRiding;
 };  // Size: 0x9C
@@ -136,7 +134,6 @@ public:
     Z2SoundHandlePool* startFireSound(u16);
     Z2SoundHandlePool* startSound(JAISoundID soundID, u32 mapinfo, s8 reverb);
 
-private:
     /* 0x20 */ f32 field_0x20;
 };
 
diff --git a/include/Z2AudioLib/Z2Param.h b/include/Z2AudioLib/Z2Param.h
index e6c8aac993..73e8b01256 100644
--- a/include/Z2AudioLib/Z2Param.h
+++ b/include/Z2AudioLib/Z2Param.h
@@ -4,72 +4,72 @@
 #include <types.h>
 
 struct Z2Param {
-    static f32 DISTANCE_MAX;
-    static f32 MAX_VOLUME_DISTANCE;
-    static f32 DOLBY_CENTER_VALUE;
-    static f32 DOLBY_FLONT_DISTANCE_MAX;
-    static f32 DOLBY_BEHIND_DISTANCE_MAX;
-    static f32 DISTANCE_FX_PARAM;
-    static f32 SONIC_SPEED;
-    static f32 VOL_BGM_DEFAULT;
-    static f32 VOL_SE_SYSTEM_DEFAULT;
-    static f32 VOL_SE_LINK_VOICE_DEFAULT;
-    static f32 VOL_SE_LINK_MOTION_DEFAULT;
-    static f32 VOL_SE_LINK_FOOTNOTE_DEFAULT;
-    static f32 VOL_SE_CHAR_VOICE_DEFAULT;
-    static f32 VOL_SE_CHAR_MOVE_DEFAULT;
-    static f32 VOL_SE_OBJECT_DEFAULT;
-    static f32 VOL_SE_ATMOSPHERE_DEFAULT;
-    static f32 VOL_BGM_TALKING;
-    static f32 VOL_SE_SYSTEM_TALKING;
-    static f32 VOL_SE_LINK_VOICE_TALKING;
-    static f32 VOL_SE_LINK_MOTION_TALKING;
-    static f32 VOL_SE_LINK_FOOTNOTE_TALKING;
-    static f32 VOL_SE_CHAR_VOICE_TALKING;
-    static f32 VOL_SE_CHAR_MOVE_TALKING;
-    static f32 VOL_SE_OBJECT_TALKING;
-    static f32 VOL_SE_ATMOSPHERE_TALKING;
-    static f32 VOL_BGM_PAUSING;
-    static f32 VOL_SE_SYSTEM_PAUSING;
-    static f32 VOL_SE_LINK_VOICE_PAUSING;
-    static f32 VOL_SE_LINK_MOTION_PAUSING;
-    static f32 VOL_SE_LINK_FOOTNOTE_PAUSING;
-    static f32 VOL_SE_CHAR_VOICE_PAUSING;
-    static f32 VOL_SE_CHAR_MOVE_PAUSING;
-    static f32 VOL_SE_OBJECT_PAUSING;
-    static f32 VOL_SE_ATMOSPHERE_PAUSING;
-    static f32 MIN_DISTANCE_VOLUME;
-    static f32 ENEMY_LASTHIT_MUTE_VOLUME;
+    static DUSK_GAME_DATA f32 DISTANCE_MAX;
+    static DUSK_GAME_DATA f32 MAX_VOLUME_DISTANCE;
+    static DUSK_GAME_DATA f32 DOLBY_CENTER_VALUE;
+    static DUSK_GAME_DATA f32 DOLBY_FLONT_DISTANCE_MAX;
+    static DUSK_GAME_DATA f32 DOLBY_BEHIND_DISTANCE_MAX;
+    static DUSK_GAME_DATA f32 DISTANCE_FX_PARAM;
+    static DUSK_GAME_DATA f32 SONIC_SPEED;
+    static DUSK_GAME_DATA f32 VOL_BGM_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_SYSTEM_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_VOICE_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_MOTION_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_FOOTNOTE_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_CHAR_VOICE_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_CHAR_MOVE_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_OBJECT_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_SE_ATMOSPHERE_DEFAULT;
+    static DUSK_GAME_DATA f32 VOL_BGM_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_SYSTEM_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_VOICE_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_MOTION_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_FOOTNOTE_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_CHAR_VOICE_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_CHAR_MOVE_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_OBJECT_TALKING;
+    static DUSK_GAME_DATA f32 VOL_SE_ATMOSPHERE_TALKING;
+    static DUSK_GAME_DATA f32 VOL_BGM_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_SYSTEM_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_VOICE_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_MOTION_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_LINK_FOOTNOTE_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_CHAR_VOICE_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_CHAR_MOVE_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_OBJECT_PAUSING;
+    static DUSK_GAME_DATA f32 VOL_SE_ATMOSPHERE_PAUSING;
+    static DUSK_GAME_DATA f32 MIN_DISTANCE_VOLUME;
+    static DUSK_GAME_DATA f32 ENEMY_LASTHIT_MUTE_VOLUME;
 
     // made up names based on HIO labels
-    static u8 SCENE_CHANGE_BGM_FADEOUT_TIME;
-    static u8 BGM_CROSS_FADEIN_TIME;
-    static u8 BGM_CROSS_FADEOUT_TIME;
-    static u8 BATTLE_BGM_WAIT_TIME;
+    static DUSK_GAME_DATA u8 SCENE_CHANGE_BGM_FADEOUT_TIME;
+    static DUSK_GAME_DATA u8 BGM_CROSS_FADEIN_TIME;
+    static DUSK_GAME_DATA u8 BGM_CROSS_FADEOUT_TIME;
+    static DUSK_GAME_DATA u8 BATTLE_BGM_WAIT_TIME;
 
     static f32 ENEMY_NEARBY_DIST;
     static f32 BATTLE_FADEIN_DIST;
     static f32 BATTLE_FADEOUT_DIST;
 
-    static u8 FOUND_TRACK_FI_TIME;
-    static u8 FOUND_TRACK_FO_TIME;
-    static u8 CLOSE_BATTLE_TRACK_FI_TIME;
-    static u8 CLOSE_BATTLE_TRACK_FO_TIME;
+    static DUSK_GAME_DATA u8 FOUND_TRACK_FI_TIME;
+    static DUSK_GAME_DATA u8 FOUND_TRACK_FO_TIME;
+    static DUSK_GAME_DATA u8 CLOSE_BATTLE_TRACK_FI_TIME;
+    static DUSK_GAME_DATA u8 CLOSE_BATTLE_TRACK_FO_TIME;
 
-    static u8 ENDING_BLOW_VOL_DOWN_TIME;
-    static u8 ENDING_BLOW_VOL_LOWER_TIME;
-    static u8 ENDING_BLOW_VOL_LOWER_RECOVER_TIME;
-    static u8 ENDING_BLOW_MIN_FINISH_TIME;
+    static DUSK_GAME_DATA u8 ENDING_BLOW_VOL_DOWN_TIME;
+    static DUSK_GAME_DATA u8 ENDING_BLOW_VOL_LOWER_TIME;
+    static DUSK_GAME_DATA u8 ENDING_BLOW_VOL_LOWER_RECOVER_TIME;
+    static DUSK_GAME_DATA u8 ENDING_BLOW_MIN_FINISH_TIME;
 
-    static u8 DARK_SE_FILTER_ON;
-    static u8 DARK_SE_LOW_PASS_FILTER_SETTING;
-    static u8 SYSTEM_SE_USE_DARK_SE_SETTING;
+    static DUSK_GAME_DATA u8 DARK_SE_FILTER_ON;
+    static DUSK_GAME_DATA u8 DARK_SE_LOW_PASS_FILTER_SETTING;
+    static DUSK_GAME_DATA u8 SYSTEM_SE_USE_DARK_SE_SETTING;
 
     static f32 AUDIBLE_DELTA_RANGE_VOLUME;
     static f32 AUDIBLE_DELTA_RANGE_PAN;
     static f32 AUDIBLE_DELTA_RANGE_DOLBY;
 };
 
-extern u8 data_8045086C;
+DUSK_GAME_EXTERN u8 data_8045086C;
 
 #endif /* Z2PARAM_H */
diff --git a/include/Z2AudioLib/Z2SceneMgr.h b/include/Z2AudioLib/Z2SceneMgr.h
index 1b3ef2cc0b..739c53bb10 100644
--- a/include/Z2AudioLib/Z2SceneMgr.h
+++ b/include/Z2AudioLib/Z2SceneMgr.h
@@ -47,7 +47,6 @@ public:
     s32 getBgmLoadStatus(u32 wave) { return getWaveLoadStatus(wave, 1); }
     u8 getDemoSeWaveNum() { return loadedDemoWave; }
 
-private:
     /* 0x00 */ JAISoundID BGM_ID;
     /* 0x04 */ int sceneNum;
     /* 0x08 */ int timer;
diff --git a/include/Z2AudioLib/Z2SeMgr.h b/include/Z2AudioLib/Z2SeMgr.h
index 3f8ca03eb3..7075308ef7 100644
--- a/include/Z2AudioLib/Z2SeMgr.h
+++ b/include/Z2AudioLib/Z2SeMgr.h
@@ -84,7 +84,6 @@ public:
     void homeMenuSeCallback(s32);    
 #endif
 
-private:
     /* 0x000 */ JAISoundHandle mSoundHandle[24];
     /* 0x060 */ JAISoundHandles mSoundHandles;
     #if VERSION >= VERSION_WII_USA_R0
diff --git a/include/Z2AudioLib/Z2SoundHandles.h b/include/Z2AudioLib/Z2SoundHandles.h
index 5915e5967b..1ad344c796 100644
--- a/include/Z2AudioLib/Z2SoundHandles.h
+++ b/include/Z2AudioLib/Z2SoundHandles.h
@@ -44,7 +44,6 @@ public:
         return (Z2SoundHandlePool*)getNth(index);
     }
 
-private:
     /* 0xC */ u8 handleNum_;
 };
 
diff --git a/include/Z2AudioLib/Z2SoundMgr.h b/include/Z2AudioLib/Z2SoundMgr.h
index cd6341b2cb..eabf9d2614 100644
--- a/include/Z2AudioLib/Z2SoundMgr.h
+++ b/include/Z2AudioLib/Z2SoundMgr.h
@@ -38,7 +38,6 @@ public:
     const JAISeqMgr* getSeqMgr() const { return &seqMgr_; }
     JAIStreamMgr* getStreamMgr() { return &streamMgr_; }
 
-private:
     /* 0x004 */ JAISeMgr seMgr_;
     /* 0x728 */ JAISeqMgr seqMgr_;
     /* 0x79C */ JAIStreamMgr streamMgr_;
diff --git a/include/Z2AudioLib/Z2SoundObjMgr.h b/include/Z2AudioLib/Z2SoundObjMgr.h
index 687f9eaf0a..64bf058ba1 100644
--- a/include/Z2AudioLib/Z2SoundObjMgr.h
+++ b/include/Z2AudioLib/Z2SoundObjMgr.h
@@ -104,7 +104,6 @@ public:
     JSUList<Z2SoundObjBase>* getAllList() { return &allList_; }
     #endif
 
-private:
     /* 0x00 */ JSUList<Z2CreatureEnemy> field_0x0;
     #if PARTIAL_DEBUG || DEBUG
     /* 0x0C */ JSUList<Z2SoundObjBase> allList_;
diff --git a/include/Z2AudioLib/Z2WolfHowlMgr.h b/include/Z2AudioLib/Z2WolfHowlMgr.h
index 10b746a4c1..5376499715 100644
--- a/include/Z2AudioLib/Z2WolfHowlMgr.h
+++ b/include/Z2AudioLib/Z2WolfHowlMgr.h
@@ -70,7 +70,6 @@ public:
     u8 getReleaseTimer() { return mReleaseTimer; }
     u8 getCorrectCurveID() { return mCorrectCurveID; }
 
-private:
     /* 0x00 */ JAISoundHandle mWolfHowlHandle;
     /* 0x04 */ JAISoundHandle mWindStoneHandle;
     /* 0x08 */ JAISoundHandle mGuideHandle;
diff --git a/include/c/c_damagereaction.h b/include/c/c_damagereaction.h
index e2c8bfe051..56b54825b7 100644
--- a/include/c/c_damagereaction.h
+++ b/include/c/c_damagereaction.h
@@ -12,18 +12,18 @@ public:
 
 BOOL cDmrNowMidnaTalk();
 
-extern u8 cDmr_SkipInfo;
-extern u8 data_80450C99;
-extern u8 data_80450C9A;
-extern u8 data_80450C9B;
-extern u8 data_80450C9C;
-extern u8 data_80450C9D;
-extern u8 data_80450C9E;
-extern u8 cDmr_FishingWether;
-extern u8 data_80450CA0;
+DUSK_GAME_EXTERN u8 cDmr_SkipInfo;
+DUSK_GAME_EXTERN u8 data_80450C99;
+DUSK_GAME_EXTERN u8 data_80450C9A;
+DUSK_GAME_EXTERN u8 data_80450C9B;
+DUSK_GAME_EXTERN u8 data_80450C9C;
+DUSK_GAME_EXTERN u8 data_80450C9D;
+DUSK_GAME_EXTERN u8 data_80450C9E;
+DUSK_GAME_EXTERN u8 cDmr_FishingWether;
+DUSK_GAME_EXTERN u8 data_80450CA0;
 
 extern "C" {
-    extern JPTraceParticleCallBack4 JPTracePCB4;
+    DUSK_GAME_EXTERN JPTraceParticleCallBack4 JPTracePCB4;
 }
 
 void debug_actor_create();
diff --git a/include/d/actor/d_a_alink.h b/include/d/actor/d_a_alink.h
index a1d78c6116..a0b70747bc 100644
--- a/include/d/actor/d_a_alink.h
+++ b/include/d/actor/d_a_alink.h
@@ -57,8 +57,8 @@ public:
     void setNowOffsetX(f32 i_offset) { mNowOffsetX = i_offset; }
     void setNowOffsetY(f32 i_offset) { mNowOffsetY = i_offset; }
 
-    static bool m_eye_move_flg;
-    static u8 m_morf_frame;
+    static DUSK_GAME_DATA bool m_eye_move_flg;
+    static DUSK_GAME_DATA u8 m_morf_frame;
 
     /* 0x0F4 */ mutable f32 field_0xf4;
     /* 0x0F8 */ mutable f32 field_0xf8;
@@ -77,7 +77,6 @@ public:
     virtual void draw();
     virtual ~daAlink_blur_c() {}
 
-    // private:
     /* 0x010 */ ResTIMG* m_blurTex;
     /* 0x014 */ int field_0x14;
     /* 0x018 */ u8 field_0x18[4];
@@ -113,7 +112,6 @@ public:
 
     void onAppearFlg() { mAppearFlg = true; }
 
-private:
     /* 0x04 */ s16 mHitFlg;
     /* 0x06 */ s16 mAppearFlg;
     /* 0x08 */ f32 mKeepMinY;
@@ -3913,20 +3911,20 @@ public:
 
     static u32 getOtherHeapSize() { return 0xF0A60; }
 
-    static daAlink_BckData const m_mainBckShield[20];
-    static daAlink_BckData const m_mainBckSword[5];
-    static daAlink_BckData const m_mainBckFishing[28];
-    static daAlink_AnmData const m_anmDataTable[ANM_MAX];
-    static daAlink_WlAnmData const m_wlAnmDataTable[WANM_MAX];
-    static daAlink_FaceTexData const m_faceTexDataTable[];
-    static Vec const m_handLeftOutSidePos;
-    static Vec const m_handRightOutSidePos;
-    static Vec const m_handLeftInSidePos;
-    static Vec const m_handRightInSidePos;
+    static DUSK_GAME_DATA daAlink_BckData const m_mainBckShield[20];
+    static DUSK_GAME_DATA daAlink_BckData const m_mainBckSword[5];
+    static DUSK_GAME_DATA daAlink_BckData const m_mainBckFishing[28];
+    static DUSK_GAME_DATA daAlink_AnmData const m_anmDataTable[ANM_MAX];
+    static DUSK_GAME_DATA daAlink_WlAnmData const m_wlAnmDataTable[WANM_MAX];
+    static DUSK_GAME_DATA daAlink_FaceTexData const m_faceTexDataTable[];
+    static DUSK_GAME_DATA Vec const m_handLeftOutSidePos;
+    static DUSK_GAME_DATA Vec const m_handRightOutSidePos;
+    static DUSK_GAME_DATA Vec const m_handLeftInSidePos;
+    static DUSK_GAME_DATA Vec const m_handRightInSidePos;
 
-    static const daAlink_procInitTable m_procInitTable[];
-    static daAlink_procFunc m_demoInitTable[];
-    static const EffParamProc m_fEffParamProc[];
+    static DUSK_GAME_DATA const daAlink_procInitTable m_procInitTable[];
+    static DUSK_GAME_DATA daAlink_procFunc m_demoInitTable[];
+    static DUSK_GAME_DATA const EffParamProc m_fEffParamProc[];
 
     /* 0x0062C */ request_of_phase_process_class mPhaseReq;
     /* 0x00634 */ const char* mArcName;
@@ -4558,30 +4556,8 @@ public:
     bool checkAimContext();
     bool checkAimInputContext();
 
-    void onIronBallChainInterpCallback();
-
-    static const int IRON_BALL_CHAIN_COUNT = 102;
-    cXyz mIBChainInterpPrevPos[IRON_BALL_CHAIN_COUNT];
-    cXyz mIBChainInterpCurrPos[IRON_BALL_CHAIN_COUNT];
-    csXyz mIBChainInterpPrevAngle[IRON_BALL_CHAIN_COUNT];
-    csXyz mIBChainInterpCurrAngle[IRON_BALL_CHAIN_COUNT];
-    cXyz mIBChainInterpPrevHandRoot;
-    cXyz mIBChainInterpCurrHandRoot;
-    bool mIBChainInterpPrevValid;
-    bool mIBChainInterpCurrValid;
-
-    cXyz mHsChainInterpPrevTop;
-    cXyz mHsChainInterpCurrTop;
-    cXyz mHsChainInterpPrevRoot;
-    cXyz mHsChainInterpCurrRoot;
-    cXyz mHsChainInterpPrevSubRoot;
-    cXyz mHsChainInterpCurrSubRoot;
-    cXyz mHsChainInterpPrevSubTop;
-    cXyz mHsChainInterpCurrSubTop;
-    bool mHsChainInterpPrevValid;
-    bool mHsChainInterpCurrValid;
-
     bool mIsRollstab = false;
+    void* mAnmBuffers[3] = {};
 #endif
 };  // Size: 0x385C
 
@@ -4649,7 +4625,7 @@ struct daAlinkHIO_basic_c1 {
 
 class daAlinkHIO_basic_c0 {
 public:
-    static daAlinkHIO_basic_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_basic_c1 const m;
 };
 
 class daAlinkHIO_basic_c : public daAlinkHIO_data_c {
@@ -4700,7 +4676,7 @@ public:
 
 class daAlinkHIO_move_c0 {
 public:
-    static daAlinkHIO_move_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_move_c1 const m;
 };
 
 class daAlinkHIO_move_c : public daAlinkHIO_data_c {
@@ -4746,7 +4722,7 @@ public:
 
 class daAlinkHIO_atnMove_c0 {
 public:
-    static daAlinkHIO_atnMove_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_atnMove_c1 const m;
 };
 
 class daAlinkHIO_atnMove_c : public daAlinkHIO_data_c {
@@ -4792,7 +4768,7 @@ public:
 
 class daAlinkHIO_noActAtnMove_c0 {
 public:
-    static daAlinkHIO_noActAtnMove_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_noActAtnMove_c1 const m;
 };
 
 class daAlinkHIO_noActAtnMove_c : public daAlinkHIO_data_c {
@@ -4834,7 +4810,7 @@ public:
 
 class daAlinkHIO_frontRoll_c0 {
 public:
-    static daAlinkHIO_frontRoll_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_frontRoll_c1 const m;
 };
 
 class daAlinkHIO_frontRoll_c : public daAlinkHIO_data_c {
@@ -4864,7 +4840,7 @@ public:
 
 class daAlinkHIO_backJump_c0 {
 public:
-    static daAlinkHIO_backJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_backJump_c1 const m;
 };
 
 class daAlinkHIO_backJump_c : public daAlinkHIO_data_c {
@@ -4898,7 +4874,7 @@ public:
 
 class daAlinkHIO_sideStep_c0 {
 public:
-    static daAlinkHIO_sideStep_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_sideStep_c1 const m;
 };
 
 class daAlinkHIO_sideStep_c : public daAlinkHIO_data_c {
@@ -4936,7 +4912,7 @@ public:
 
 class daAlinkHIO_slide_c0 {
 public:
-    static daAlinkHIO_slide_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_slide_c1 const m;
 };
 
 class daAlinkHIO_slide_c : public daAlinkHIO_data_c {
@@ -4964,27 +4940,27 @@ public:
 
 class daAlinkHIO_cutNmV_c0 {
 public:
-    static daAlinkHIO_cutNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutNormal_c1 const m;
 };
 
 class daAlinkHIO_cutNmL_c0 {
 public:
-    static daAlinkHIO_cutNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutNormal_c1 const m;
 };
 
 class daAlinkHIO_cutNmR_c0 {
 public:
-    static daAlinkHIO_cutNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutNormal_c1 const m;
 };
 
 class daAlinkHIO_cutNmSL_c0 {
 public:
-    static daAlinkHIO_cutNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutNormal_c1 const m;
 };
 
 class daAlinkHIO_cutNmSR_c0 {
 public:
-    static daAlinkHIO_cutNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutNormal_c1 const m;
 };
 
 class daAlinkHIO_cutNormal_c : public daAlinkHIO_data_c {
@@ -5015,32 +4991,32 @@ public:
 
 class daAlinkHIO_cutFnL_c0 {
 public:
-    static daAlinkHIO_cutFinish_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFinish_c1 const m;
 };
 
 class daAlinkHIO_cutFnV_c0 {
 public:
-    static daAlinkHIO_cutFinish_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFinish_c1 const m;
 };
 
 class daAlinkHIO_cutFnS_c0 {
 public:
-    static daAlinkHIO_cutFinish_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFinish_c1 const m;
 };
 
 class daAlinkHIO_cutFnSl_c0 {
 public:
-    static daAlinkHIO_cutFinish_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFinish_c1 const m;
 };
 
 class daAlinkHIO_cutFnSm_c0 {
 public:
-    static daAlinkHIO_cutFinish_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFinish_c1 const m;
 };
 
 class daAlinkHIO_cutFnR_c0 {
 public:
-    static daAlinkHIO_cutFinish_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFinish_c1 const m;
 };
 
 class daAlinkHIO_cutFinish_c : public daAlinkHIO_data_c {
@@ -5077,7 +5053,7 @@ public:
 
 class daAlinkHIO_cutFnJU_c0 {
 public:
-    static daAlinkHIO_cutFnJU_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutFnJU_c1 const m;
 };
 
 class daAlinkHIO_cutFnJU_c : public daAlinkHIO_data_c {
@@ -5104,17 +5080,17 @@ public:
 
 class daAlinkHIO_cutDaL_c0 {
 public:
-    static daAlinkHIO_cutDash_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutDash_c1 const m;
 };
 
 class daAlinkHIO_cutDaR_c0 {
 public:
-    static daAlinkHIO_cutDash_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutDash_c1 const m;
 };
 
 class daAlinkHIO_cutDaCharge_c0 {
 public:
-    static daAlinkHIO_cutDash_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutDash_c1 const m;
 };
 
 class daAlinkHIO_cutDash_c : public daAlinkHIO_data_c {
@@ -5146,7 +5122,7 @@ public:
 
 class daAlinkHIO_cutJump_c0 {
 public:
-    static daAlinkHIO_cutJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutJump_c1 const m;
 };
 
 class daAlinkHIO_cutJump_c : public daAlinkHIO_data_c {
@@ -5197,7 +5173,7 @@ public:
 
 class daAlinkHIO_cutTurn_c0 {
 public:
-    static daAlinkHIO_cutTurn_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutTurn_c1 const m;
 };
 
 class daAlinkHIO_cutTurn_c : public daAlinkHIO_data_c {
@@ -5225,22 +5201,22 @@ public:
 
 class daAlinkHIO_hoCutLA_c0 {
 public:
-    static daAlinkHIO_hoCut_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_hoCut_c1 const m;
 };
 
 class daAlinkHIO_hoCutLB_c0 {
 public:
-    static daAlinkHIO_hoCut_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_hoCut_c1 const m;
 };
 
 class daAlinkHIO_hoCutRA_c0 {
 public:
-    static daAlinkHIO_hoCut_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_hoCut_c1 const m;
 };
 
 class daAlinkHIO_hoCutRB_c0 {
 public:
-    static daAlinkHIO_hoCut_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_hoCut_c1 const m;
 };
 
 class daAlinkHIO_hoCut_c : public daAlinkHIO_data_c {
@@ -5273,7 +5249,7 @@ public:
 
 class daAlinkHIO_hoCutCharge_c0 {
 public:
-    static daAlinkHIO_hoCutCharge_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_hoCutCharge_c1 const m;
 };
 
 class daAlinkHIO_hoCutCharge_c : public daAlinkHIO_data_c {
@@ -5307,7 +5283,7 @@ public:
 
 class daAlinkHIO_cutDown_c0 {
 public:
-    static daAlinkHIO_cutDown_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutDown_c1 const m;
 };
 
 class daAlinkHIO_cutDown_c : public daAlinkHIO_data_c {
@@ -5343,7 +5319,7 @@ public:
 
 class daAlinkHIO_cutHead_c0 {
 public:
-    static daAlinkHIO_cutHead_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutHead_c1 const m;
 };
 
 class daAlinkHIO_cutHead_c : public daAlinkHIO_data_c {
@@ -5380,7 +5356,7 @@ public:
 
 class daAlinkHIO_cutLargeJump_c0 {
 public:
-    static daAlinkHIO_cutLargeJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cutLargeJump_c1 const m;
 };
 
 class daAlinkHIO_cutLargeJump_c : public daAlinkHIO_data_c {
@@ -5457,7 +5433,7 @@ public:
     static daAlinkHIO_cutDown_c0 const mCutDown;
     static daAlinkHIO_cutHead_c0 const mCutHead;
     static daAlinkHIO_cutLargeJump_c0 const mCutLargeJump;
-    static daAlinkHIO_cut_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_cut_c1 const m;
 };
 
 class daAlinkHIO_cut_c : public daAlinkHIO_data_c {
@@ -5513,12 +5489,12 @@ public:
 
 class daAlinkHIO_gAtPush_c0 {
 public:
-    static daAlinkHIO_guardAttack_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_guardAttack_c1 const m;
 };
 
 class daAlinkHIO_gAtKick_c0 {
 public:
-    static daAlinkHIO_guardAttack_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_guardAttack_c1 const m;
 };
 
 class daAlinkHIO_guardAttack_c : public daAlinkHIO_data_c {
@@ -5550,7 +5526,7 @@ public:
 
 class daAlinkHIO_turnMove_c0 {
 public:
-    static daAlinkHIO_turnMove_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_turnMove_c1 const m;
 };
 
 class daAlinkHIO_turnMove_c : public daAlinkHIO_data_c {
@@ -5595,7 +5571,7 @@ public:
     static daAlinkHIO_gAtPush_c0 const mAtPush;
     static daAlinkHIO_gAtKick_c0 const mAtKick;
     static daAlinkHIO_turnMove_c0 const mTurnMove;
-    static daAlinkHIO_guard_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_guard_c1 const m;
 };
 
 class daAlinkHIO_guard_c : public daAlinkHIO_data_c {
@@ -5634,7 +5610,7 @@ public:
 
 class daAlinkHIO_crouch_c0 {
 public:
-    static daAlinkHIO_crouch_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_crouch_c1 const m;
 };
 
 class daAlinkHIO_crouch_c : public daAlinkHIO_data_c {
@@ -5689,7 +5665,7 @@ public:
 
 class daAlinkHIO_autoJump_c0 {
 public:
-    static daAlinkHIO_autoJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_autoJump_c1 const m;
 };
 
 class daAlinkHIO_autoJump_c : public daAlinkHIO_data_c {
@@ -5719,7 +5695,7 @@ public:
 
 class daAlinkHIO_smallJump_c0 {
 public:
-    static daAlinkHIO_smallJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_smallJump_c1 const m;
 };
 
 class daAlinkHIO_smallJump_c : public daAlinkHIO_data_c {
@@ -5748,7 +5724,7 @@ public:
 
 class daAlinkHIO_wallCatch_c0 {
 public:
-    static daAlinkHIO_wallCatch_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wallCatch_c1 const m;
 };
 
 class daAlinkHIO_wallCatch_c : public daAlinkHIO_data_c {
@@ -5774,7 +5750,7 @@ public:
 
 class daAlinkHIO_wallFall_c0 {
 public:
-    static daAlinkHIO_wallFall_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wallFall_c1 const m;
 };
 
 class daAlinkHIO_wallFall_c : public daAlinkHIO_data_c {
@@ -5803,7 +5779,7 @@ public:
 
 class daAlinkHIO_wallMove_c0 {
 public:
-    static daAlinkHIO_wallMove_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wallMove_c1 const m;
 };
 
 class daAlinkHIO_wallMove_c : public daAlinkHIO_data_c {
@@ -5839,7 +5815,7 @@ public:
     static daAlinkHIO_wallCatch_c0 const mWallCatch;
     static daAlinkHIO_wallFall_c0 const mWallFall;
     static daAlinkHIO_wallMove_c0 const mWallMove;
-    static daAlinkHIO_wallHang_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wallHang_c1 const m;
 };
 
 class daAlinkHIO_wallHang_c : public daAlinkHIO_data_c {
@@ -5886,7 +5862,7 @@ public:
 
 class daAlinkHIO_pushpull_c0 {
 public:
-    static daAlinkHIO_pushpull_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_pushpull_c1 const m;
 };
 
 class daAlinkHIO_pushpull_c : public daAlinkHIO_data_c {
@@ -5920,7 +5896,7 @@ public:
 
 class daAlinkHIO_damNormal_c0 {
 public:
-    static daAlinkHIO_damNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damNormal_c1 const m;
 };
 
 class daAlinkHIO_damNormal_c : public daAlinkHIO_data_c {
@@ -5959,12 +5935,12 @@ public:
 
 class daAlinkHIO_damLarge_c0 {
 public:
-    static daAlinkHIO_damLaHu_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damLaHu_c1 const m;
 };
 
 class daAlinkHIO_damHuge_c0 {
 public:
-    static daAlinkHIO_damLaHu_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damLaHu_c1 const m;
 };
 
 class daAlinkHIO_damLaHu_c : public daAlinkHIO_data_c {
@@ -5992,7 +5968,7 @@ public:
 
 class daAlinkHIO_damHorse_c0 {
 public:
-    static daAlinkHIO_damHorse_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damHorse_c1 const m;
 };
 
 class daAlinkHIO_damHorse_c : public daAlinkHIO_data_c {
@@ -6027,7 +6003,7 @@ public:
 
 class daAlinkHIO_damFall_c0 {
 public:
-    static daAlinkHIO_damFall_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damFall_c1 const m;
 };
 
 class daAlinkHIO_damFall_c : public daAlinkHIO_data_c {
@@ -6057,7 +6033,7 @@ public:
 
 class daAlinkHIO_damCaught_c0 {
 public:
-    static daAlinkHIO_damCaught_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damCaught_c1 const m;
 };
 
 class daAlinkHIO_damCaught_c : public daAlinkHIO_data_c {
@@ -6093,7 +6069,7 @@ public:
 
 class daAlinkHIO_damSwim_c0 {
 public:
-    static daAlinkHIO_damSwim_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damSwim_c1 const m;
 };
 
 class daAlinkHIO_damSwim_c : public daAlinkHIO_data_c {
@@ -6140,7 +6116,7 @@ public:
 
 class daAlinkHIO_damage_c0 {
 public:
-    static daAlinkHIO_damage_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_damage_c1 const m;
     static daAlinkHIO_damNormal_c0 const mDamNormal;
     static daAlinkHIO_damLarge_c0 const mDamLarge;
     static daAlinkHIO_damHuge_c0 const mDamHuge;
@@ -6192,7 +6168,7 @@ public:
 
 class daAlinkHIO_horse_c0 {
 public:
-    static daAlinkHIO_horse_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_horse_c1 const m;
 };
 
 class daAlinkHIO_horse_c : public daAlinkHIO_data_c {
@@ -6231,7 +6207,7 @@ public:
 
 class daAlinkHIO_canoe_c0 {
 public:
-    static daAlinkHIO_canoe_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_canoe_c1 const m;
 };
 
 class daAlinkHIO_canoe_c : public daAlinkHIO_data_c {
@@ -6276,7 +6252,7 @@ public:
 
 class daAlinkHIO_bow_c0 {
 public:
-    static daAlinkHIO_bow_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_bow_c1 const m;
 };
 
 class daAlinkHIO_bow_c : public daAlinkHIO_data_c {
@@ -6312,7 +6288,7 @@ public:
 
 class daAlinkHIO_boom_c0 {
 public:
-    static daAlinkHIO_boom_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_boom_c1 const m;
 };
 
 class daAlinkHIO_boom_c : public daAlinkHIO_data_c {
@@ -6356,7 +6332,7 @@ public:
 
 class daAlinkHIO_bomb_c0 {
 public:
-    static daAlinkHIO_bomb_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_bomb_c1 const m;
 };
 
 class daAlinkHIO_bomb_c : public daAlinkHIO_data_c {
@@ -6391,7 +6367,7 @@ public:
 
 class daAlinkHIO_huLight_c0 {
 public:
-    static daAlinkHIO_huLight_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_huLight_c1 const m;
 };
 
 class daAlinkHIO_wlLight_c1 {
@@ -6410,7 +6386,7 @@ public:
 
 class daAlinkHIO_wlLight_c0 {
 public:
-    static daAlinkHIO_wlLight_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlLight_c1 const m;
 };
 
 class daAlinkHIO_zwLight_c1 {  // may be wrong
@@ -6429,7 +6405,7 @@ public:
 
 class daAlinkHIO_zwLight_c0 {
 public:
-    static daAlinkHIO_zwLight_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_zwLight_c1 const m;
 };
 
 class daAlinkHIO_light_c : public daAlinkHIO_data_c {
@@ -6465,7 +6441,7 @@ public:
 
 class daAlinkHIO_kandelaar_c0 {
 public:
-    static daAlinkHIO_kandelaar_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_kandelaar_c1 const m;
 };
 
 class daAlinkHIO_kandelaar_c : public daAlinkHIO_data_c {
@@ -6504,7 +6480,7 @@ public:
 
 class daAlinkHIO_magneBoots_c0 {
 public:
-    static daAlinkHIO_magneBoots_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_magneBoots_c1 const m;
 };
 
 class daAlinkHIO_magneBoots_c : public daAlinkHIO_data_c {
@@ -6530,7 +6506,7 @@ public:
 
 class daAlinkHIO_fmChain_c0 {
 public:
-    static daAlinkHIO_fmChain_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_fmChain_c1 const m;
 };
 
 class daAlinkHIO_fmChain_c : public daAlinkHIO_data_c {
@@ -6570,7 +6546,7 @@ public:
 
 class daAlinkHIO_hookshot_c0 {
 public:
-    static daAlinkHIO_hookshot_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_hookshot_c1 const m;
 };
 
 class daAlinkHIO_hookshot_c : public daAlinkHIO_data_c {
@@ -6608,7 +6584,7 @@ public:
 
 class daAlinkHIO_spinner_c0 {
 public:
-    static daAlinkHIO_spinner_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_spinner_c1 const m;
 };
 
 class daAlinkHIO_spinner_c : public daAlinkHIO_data_c {
@@ -6664,7 +6640,7 @@ public:
 
 class daAlinkHIO_ironBall_c0 {
 public:
-    static daAlinkHIO_ironBall_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_ironBall_c1 const m;
 };
 
 class daAlinkHIO_ironBall_c : public daAlinkHIO_data_c {
@@ -6694,7 +6670,7 @@ public:
 
 class daAlinkHIO_copyRod_c0 {
 public:
-    static daAlinkHIO_copyRod_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_copyRod_c1 const m;
 };
 
 class daAlinkHIO_copyRod_c : public daAlinkHIO_data_c {
@@ -6722,7 +6698,7 @@ public:
 
 class daAlinkHIO_pickUp_c0 {
 public:
-    static daAlinkHIO_pickUp_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_pickUp_c1 const m;
 };
 
 class daAlinkHIO_pickUp_c : public daAlinkHIO_data_c {
@@ -6769,7 +6745,7 @@ public:
 
 class daAlinkHIO_board_c0 {
 public:
-    static daAlinkHIO_board_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_board_c1 const m;
 };
 
 class daAlinkHIO_board_c : public daAlinkHIO_data_c {
@@ -6802,7 +6778,7 @@ public:
 
 class daAlinkHIO_bottle_c0 {
 public:
-    static daAlinkHIO_bottle_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_bottle_c1 const m;
 };
 
 class daAlinkHIO_bottle_c : public daAlinkHIO_data_c {
@@ -6850,7 +6826,7 @@ public:
     static daAlinkHIO_ironBall_c0 const mIronBall;
     static daAlinkHIO_copyRod_c0 const mCopyRod;
     static daAlinkHIO_zwLight_c0 const mZoraArmorPL;
-    static daAlinkHIO_item_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_item_c1 const m;
 };
 
 class daAlinkHIO_item_c : public daAlinkHIO_data_c {
@@ -6909,7 +6885,7 @@ public:
 
 class daAlinkHIO_ladder_c0 {
 public:
-    static daAlinkHIO_ladder_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_ladder_c1 const m;
 };
 
 class daAlinkHIO_ladder_c : public daAlinkHIO_data_c {
@@ -6949,7 +6925,7 @@ public:
 
 class daAlinkHIO_roofHang_c0 {
 public:
-    static daAlinkHIO_roofHang_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_roofHang_c1 const m;
 };
 
 class daAlinkHIO_roofHang_c : public daAlinkHIO_data_c {
@@ -6987,7 +6963,7 @@ public:
 
 class daAlinkHIO_grab_c0 {
 public:
-    static daAlinkHIO_grab_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_grab_c1 const m;
 };
 
 class daAlinkHIO_grab_c : public daAlinkHIO_data_c {
@@ -7062,7 +7038,7 @@ public:
 
 class daAlinkHIO_swim_c0 {
 public:
-    static daAlinkHIO_swim_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_swim_c1 const m;
 };
 
 class daAlinkHIO_swim_c : public daAlinkHIO_data_c {
@@ -7138,7 +7114,7 @@ public:
 
 class daAlinkHIO_wlMove_c0 {
 public:
-    static daAlinkHIO_wlMove_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlMove_c1 const m;
 };
 
 class daAlinkHIO_wlMove_c : public daAlinkHIO_data_c {
@@ -7181,7 +7157,7 @@ public:
 
 class daAlinkHIO_wlMoveNoP_c0 {
 public:
-    static daAlinkHIO_wlMoveNoP_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlMoveNoP_c1 const m;
 };
 
 class daAlinkHIO_wlMoveNoP_c : public daAlinkHIO_data_c {
@@ -7220,7 +7196,7 @@ public:
 
 class daAlinkHIO_wlAtnMove_c0 {
 public:
-    static daAlinkHIO_wlAtnMove_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtnMove_c1 const m;
 };
 
 class daAlinkHIO_wlAtnMove_c : public daAlinkHIO_data_c {
@@ -7252,7 +7228,7 @@ public:
 
 class daAlinkHIO_wlHowl_c0 {
 public:
-    static daAlinkHIO_wlHowl_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlHowl_c1 const m;
 };
 
 class daAlinkHIO_wlHowl_c : public daAlinkHIO_data_c {
@@ -7286,7 +7262,7 @@ public:
 
 class daAlinkHIO_wlSideStep_c0 {
 public:
-    static daAlinkHIO_wlSideStep_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlSideStep_c1 const m;
 };
 
 class daAlinkHIO_wlSideStep_c : public daAlinkHIO_data_c {
@@ -7316,7 +7292,7 @@ public:
 
 class daAlinkHIO_wlBackJump_c0 {
 public:
-    static daAlinkHIO_wlBackJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlBackJump_c1 const m;
 };
 
 class daAlinkHIO_wlBackJump_c : public daAlinkHIO_data_c {
@@ -7361,7 +7337,7 @@ public:
 
 class daAlinkHIO_wlAutoJump_c0 {
 public:
-    static daAlinkHIO_wlAutoJump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAutoJump_c1 const m;
 };
 
 class daAlinkHIO_wlAutoJump_c : public daAlinkHIO_data_c {
@@ -7390,7 +7366,7 @@ public:
 
 class daAlinkHIO_wlPush_c0 {
 public:
-    static daAlinkHIO_wlPush_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlPush_c1 const m;
 };
 
 class daAlinkHIO_wlPush_c : public daAlinkHIO_data_c {
@@ -7426,7 +7402,7 @@ public:
 
 class daAlinkHIO_wlLie_c0 {
 public:
-    static daAlinkHIO_wlLie_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlLie_c1 const m;
 };
 
 class daAlinkHIO_wlLie_c : public daAlinkHIO_data_c {
@@ -7465,7 +7441,7 @@ public:
 
 class daAlinkHIO_wlWallHang_c0 {
 public:
-    static daAlinkHIO_wlWallHang_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlWallHang_c1 const m;
 };
 
 class daAlinkHIO_wlWallHang_c : public daAlinkHIO_data_c {
@@ -7497,7 +7473,7 @@ public:
 
 class daAlinkHIO_wlDamNormal_c0 {
 public:
-    static daAlinkHIO_wlDamNormal_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlDamNormal_c1 const m;
 };
 
 class daAlinkHIO_wlDamNormal_c : public daAlinkHIO_data_c {
@@ -7532,12 +7508,12 @@ public:
 
 class daAlinkHIO_wlDamLarge_c0 {
 public:
-    static daAlinkHIO_wlDamLaHu_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlDamLaHu_c1 const m;
 };
 
 class daAlinkHIO_wlDamHuge_c0 {
 public:
-    static daAlinkHIO_wlDamLaHu_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlDamLaHu_c1 const m;
 };
 
 class daAlinkHIO_wlDamLaHu_c : public daAlinkHIO_data_c {
@@ -7566,7 +7542,7 @@ public:
 
 class daAlinkHIO_wlDamCaught_c0 {
 public:
-    static daAlinkHIO_wlDamCaught_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlDamCaught_c1 const m;
 };
 
 class daAlinkHIO_wlDamCaught_c : public daAlinkHIO_data_c {
@@ -7599,7 +7575,7 @@ public:
 
 class daAlinkHIO_wlDamFall_c0 {
 public:
-    static daAlinkHIO_wlDamFall_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlDamFall_c1 const m;
 };
 
 class daAlinkHIO_wlDamFall_c : public daAlinkHIO_data_c {
@@ -7626,7 +7602,7 @@ public:
 
 class daAlinkHIO_wlDamage_c0 {
 public:
-    static daAlinkHIO_wlDamage_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlDamage_c1 const m;
     static daAlinkHIO_wlDamNormal_c0 const mNormal;
     static daAlinkHIO_wlDamLarge_c0 const mLarge;
     static daAlinkHIO_wlDamHuge_c0 const mHuge;
@@ -7676,7 +7652,7 @@ public:
 
 class daAlinkHIO_wlSlide_c0 {
 public:
-    static daAlinkHIO_wlSlide_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlSlide_c1 const m;
 };
 
 class daAlinkHIO_wlSlide_c : public daAlinkHIO_data_c {
@@ -7711,7 +7687,7 @@ public:
 
 class daAlinkHIO_wlRope_c0 {
 public:
-    static daAlinkHIO_wlRope_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlRope_c1 const m;
 };
 
 class daAlinkHIO_wlRope_c : public daAlinkHIO_data_c {
@@ -7747,17 +7723,17 @@ public:
 
 class daAlinkHIO_wlAtWaTl_c0 {
 public:
-    static daAlinkHIO_wlAtWait_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtWait_c1 const m;
 };
 
 class daAlinkHIO_wlAtWaSc_c0 {
 public:
-    static daAlinkHIO_wlAtWait_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtWait_c1 const m;
 };
 
 class daAlinkHIO_wlAtWaLr_c0 {
 public:
-    static daAlinkHIO_wlAtWait_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtWait_c1 const m;
 };
 
 class daAlinkHIO_wlAtWait_c : public daAlinkHIO_data_c {
@@ -7784,7 +7760,7 @@ public:
 
 class daAlinkHIO_wlAtRoll_c0 {
 public:
-    static daAlinkHIO_wlAtRoll_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtRoll_c1 const m;
 };
 
 class daAlinkHIO_wlAtRoll_c : public daAlinkHIO_data_c {
@@ -7819,7 +7795,7 @@ public:
 
 class daAlinkHIO_wlAtNjump_c0 {
 public:
-    static daAlinkHIO_wlAtNjump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtNjump_c1 const m;
 };
 
 class daAlinkHIO_wlAtNjump_c : public daAlinkHIO_data_c {
@@ -7860,7 +7836,7 @@ public:
 
 class daAlinkHIO_wlAtCjump_c0 {
 public:
-    static daAlinkHIO_wlAtCjump_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtCjump_c1 const m;
 };
 
 class daAlinkHIO_wlAtCjump_c : public daAlinkHIO_data_c {
@@ -7888,7 +7864,7 @@ public:
 
 class daAlinkHIO_wlAtLand_c0 {
 public:
-    static daAlinkHIO_wlAtLand_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtLand_c1 const m;
 };
 
 class daAlinkHIO_wlAtLand_c : public daAlinkHIO_data_c {
@@ -7924,7 +7900,7 @@ public:
 
 class daAlinkHIO_wlAtDown_c0 {
 public:
-    static daAlinkHIO_wlAtDown_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtDown_c1 const m;
 };
 
 class daAlinkHIO_wlAtDown_c : public daAlinkHIO_data_c {
@@ -7961,7 +7937,7 @@ public:
 
 class daAlinkHIO_wlAtLock_c0 {
 public:
-    static daAlinkHIO_wlAtLock_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtLock_c1 const m;
 };
 
 class daAlinkHIO_wlAtLock_c : public daAlinkHIO_data_c {
@@ -8001,7 +7977,7 @@ public:
 
 class daAlinkHIO_wlAtBite_c0 {
 public:
-    static daAlinkHIO_wlAtBite_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlAtBite_c1 const m;
 };
 
 class daAlinkHIO_wlAtBite_c : public daAlinkHIO_data_c {
@@ -8046,7 +8022,7 @@ public:
     static  daAlinkHIO_wlAtDown_c0 const mWlAtDown;
     static  daAlinkHIO_wlAtLock_c0 const mWlAtLock;
     static  daAlinkHIO_wlAtBite_c0 const mWlAtBite;
-    static  daAlinkHIO_wlAttack_c1 const m;
+    static DUSK_GAME_DATA  daAlinkHIO_wlAttack_c1 const m;
 };
 
 class daAlinkHIO_wlAttack_c : public daAlinkHIO_data_c {
@@ -8093,7 +8069,7 @@ public:
 
 class daAlinkHIO_wlPoint_c0 {
 public:
-    static daAlinkHIO_wlPoint_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlPoint_c1 const m;
 };
 
 class daAlinkHIO_wlPoint_c : public daAlinkHIO_data_c {
@@ -8129,7 +8105,7 @@ public:
 
 class daAlinkHIO_wlChain_c0 {
 public:
-    static daAlinkHIO_wlChain_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlChain_c1 const m;
 };
 
 class daAlinkHIO_wlChain_c : public daAlinkHIO_data_c {
@@ -8186,7 +8162,7 @@ public:
 
 class daAlinkHIO_wlSwim_c0 {
 public:
-    static daAlinkHIO_wlSwim_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlSwim_c1 const m;
 };
 
 class daAlinkHIO_wlSwim_c : public daAlinkHIO_data_c {
@@ -8215,7 +8191,7 @@ public:
 
 class daAlinkHIO_wlGrab_c0 {
 public:
-    static daAlinkHIO_wlGrab_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlGrab_c1 const m;
 };
 
 class daAlinkHIO_wlGrab_c : public daAlinkHIO_data_c {
@@ -8245,7 +8221,7 @@ public:
 
 class daAlinkHIO_wlBall_c0 {
 public:
-    static daAlinkHIO_wlBall_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wlBall_c1 const m;
 };
 
 class daAlinkHIO_wlBall_c : public daAlinkHIO_data_c {
@@ -8300,7 +8276,7 @@ public:
     static daAlinkHIO_wlSwim_c0 const mWlSwim;
     static daAlinkHIO_wlGrab_c0 const mWlGrab;
     static daAlinkHIO_wlBall_c0 const mWlBall;
-    static daAlinkHIO_wolf_c1 const m;
+    static DUSK_GAME_DATA daAlinkHIO_wolf_c1 const m;
 };
 
 class daAlinkHIO_wolf_c : public daAlinkHIO_data_c {
@@ -8449,8 +8425,10 @@ struct daAlink_cutHorseParamTbl {
     /* 0xA */ u8 m_cutType;
 };  // Size: 0xC
 
+#if !TARGET_PC
 inline BOOL dComIfGs_isTransformLV(int i_no);
 inline BOOL dComIfGs_isEventBit(const u16);
+#endif
 
 static fopAc_ac_c* daAlink_searchPortal(fopAc_ac_c* i_actor, void* i_data);
 static fopAc_ac_c* daAlink_searchCanoe(fopAc_ac_c* i_actor, void* i_data);
diff --git a/include/d/actor/d_a_arrow.h b/include/d/actor/d_a_arrow.h
index 682ffd43d7..f15cf1aca8 100644
--- a/include/d/actor/d_a_arrow.h
+++ b/include/d/actor/d_a_arrow.h
@@ -110,7 +110,6 @@ public:
 
     void setModelMatrix(MtxP mtx) { mpModel->setBaseTRMtx(mtx); }
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ dBgS_ArrowLinChk field_0x56c;
     /* 0x5DC */ dBgS_ObjLinChk field_0x5dc;
@@ -161,7 +160,7 @@ private:
     /* 0xA10 */ dPa_hermiteEcallBack_c field_0xa10;
     /* 0xA28 */ int (daArrow_c::*mProcFunc)();
 
-    static s16 m_count;
+    static DUSK_GAME_DATA s16 m_count;
 };
 
 STATIC_ASSERT(sizeof(daArrow_c) == 0xA34);
diff --git a/include/d/actor/d_a_b_dr.h b/include/d/actor/d_a_b_dr.h
index e15a6e7ca5..d9f72089f4 100644
--- a/include/d/actor/d_a_b_dr.h
+++ b/include/d/actor/d_a_b_dr.h
@@ -82,7 +82,6 @@ public:
     u8 onTarget() { return mTarget = true; }
     u8 isBack() { return arg0; }
 
-private:
     /* 0x05AC */ request_of_phase_process_class mPhase;
     /* 0x05B4 */ mDoExt_McaMorfSO* mpModelMorf;
     /* 0x05B8 */ J3DModel* mpPartModel;
diff --git a/include/d/actor/d_a_b_ds.h b/include/d/actor/d_a_b_ds.h
index ee737a955a..7013465e93 100644
--- a/include/d/actor/d_a_b_ds.h
+++ b/include/d/actor/d_a_b_ds.h
@@ -189,7 +189,6 @@ public:
     void onDemo() { mIsDemo = true; }
     void offDemo() { mIsDemo = false; }
 
-private:
     /* 0x05AC */ request_of_phase_process_class mPhase;
     /* 0x05B4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x05B8 */ mDoExt_McaMorfSO* mpSwordMorf;
diff --git a/include/d/actor/d_a_b_gnd.h b/include/d/actor/d_a_b_gnd.h
index 0827102eec..dcf6c94905 100644
--- a/include/d/actor/d_a_b_gnd.h
+++ b/include/d/actor/d_a_b_gnd.h
@@ -189,12 +189,6 @@ public:
     /* 0x2740 */ u8 field_0x2740;
     /* 0x2744 */ dMsgFlow_c mMsgFlow;
 #if TARGET_PC
-    cXyz mReinsInterpPrev[2][16];
-    cXyz mReinsInterpCurr[2][16];
-    cXyz mReinsTexInterpPrev[2];
-    cXyz mReinsTexInterpCurr[2];
-    bool mReinsInterpPrevValid;
-    bool mReinsInterpCurrValid;
     s8 mDemoCamSyncTicks;
 #endif
 };
diff --git a/include/d/actor/d_a_b_mgn.h b/include/d/actor/d_a_b_mgn.h
index 272d02b1ef..1ad1dd5cf7 100644
--- a/include/d/actor/d_a_b_mgn.h
+++ b/include/d/actor/d_a_b_mgn.h
@@ -92,7 +92,6 @@ public:
     bool isDown() { return mDownFlag != 0; }
     bool isAppear() { return mAppearFlag != 0; }
 
-private:
     /* 0x05AC */ request_of_phase_process_class mMgnPhase;
     /* 0x05B4 */ request_of_phase_process_class mMgnePhase;
     /* 0x05BC */ mDoExt_McaMorfSO* mpMgnModelMorf;
diff --git a/include/d/actor/d_a_b_tn.h b/include/d/actor/d_a_b_tn.h
index 7de1007d28..87b9cd2fae 100644
--- a/include/d/actor/d_a_b_tn.h
+++ b/include/d/actor/d_a_b_tn.h
@@ -131,7 +131,6 @@ public:
     int CreateHeap();
     int create();
 
-private:
     /* 0x05AC */ request_of_phase_process_class mPhaseReq1;
     /* 0x05B4 */ request_of_phase_process_class mPhaseReq2;
     /* 0x05BC */ J3DModel* mpPartModels[16];
diff --git a/include/d/actor/d_a_b_yo.h b/include/d/actor/d_a_b_yo.h
index a133d364d6..3550b95a1c 100644
--- a/include/d/actor/d_a_b_yo.h
+++ b/include/d/actor/d_a_b_yo.h
@@ -80,7 +80,6 @@ public:
     void setDrawOff() { mIsInactive = 1; }
     bool isEnemyDemoEnd() { return (u8)mIsEnemyDemoEnd != 0; }
 
-private:
     /* 0x05AC */ request_of_phase_process_class mPhase1;
     /* 0x05B4 */ request_of_phase_process_class mPhase2;
     /* 0x05BC */ request_of_phase_process_class mPhase3;
diff --git a/include/d/actor/d_a_b_yo_ice.h b/include/d/actor/d_a_b_yo_ice.h
index 2ad2e5388d..e0f064fa9d 100644
--- a/include/d/actor/d_a_b_yo_ice.h
+++ b/include/d/actor/d_a_b_yo_ice.h
@@ -51,7 +51,6 @@ public:
 
     void setSubNumber(int i_subNumber) { mSubNumber = i_subNumber; }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ J3DModel* mpModel;
     /* 0x5B8 */ Z2Creature mCreatureSound;
diff --git a/include/d/actor/d_a_b_zant_magic.h b/include/d/actor/d_a_b_zant_magic.h
index 0d05f9bd41..e37b055bfd 100644
--- a/include/d/actor/d_a_b_zant_magic.h
+++ b/include/d/actor/d_a_b_zant_magic.h
@@ -24,7 +24,6 @@ public:
     int _delete();
     int create();
 
-private:
     /* 0x5AC */ Mtx field_0x5ac;
     /* 0x5DC */ cXyz field_0x5dc;
     /* 0x5E8 */ f32 field_0x5e8;
diff --git a/include/d/actor/d_a_b_zant_mobile.h b/include/d/actor/d_a_b_zant_mobile.h
index 3af85c56b1..18dcdbabc1 100644
--- a/include/d/actor/d_a_b_zant_mobile.h
+++ b/include/d/actor/d_a_b_zant_mobile.h
@@ -33,7 +33,6 @@ public:
     bool isSearchContinue() { return mSearchContinue != false; }
     void offSearchContinue() { mSearchContinue = false; }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x5B8 */ mDoExt_brkAnm* mpBrk;
diff --git a/include/d/actor/d_a_balloon_2D.h b/include/d/actor/d_a_balloon_2D.h
index 193ecadbaa..80aa3e3b02 100644
--- a/include/d/actor/d_a_balloon_2D.h
+++ b/include/d/actor/d_a_balloon_2D.h
@@ -67,7 +67,7 @@ public:
     void hide() { mIsVisible = 0; }
     u8 isVisible() { return mIsVisible; }
 
-    static daBalloon2D_c* myclass;
+    static DUSK_GAME_DATA daBalloon2D_c* myclass;
 
     struct ScoreCount {
         cXyz field_0x0;
diff --git a/include/d/actor/d_a_bg.h b/include/d/actor/d_a_bg.h
index 0a9859198b..51407a06c8 100644
--- a/include/d/actor/d_a_bg.h
+++ b/include/d/actor/d_a_bg.h
@@ -57,7 +57,6 @@ public:
     inline int execute();
     inline int isDelete();
 
-private:
     /* 0x568 */ u8 field_0x568[0x570 - 0x568];
     /* 0x570 */ daBg_Part mBgParts[6];
     /* 0x5E8 */ dBgW* mpBgW;
diff --git a/include/d/actor/d_a_bg_obj.h b/include/d/actor/d_a_bg_obj.h
index fc4df6ab4e..aab9572183 100644
--- a/include/d/actor/d_a_bg_obj.h
+++ b/include/d/actor/d_a_bg_obj.h
@@ -89,10 +89,10 @@ public:
 
     void setAction(u8 i_action) { mAction = i_action; }
 
-    static createHeapFunc mCreateHeapFunc[];
-    static createInitFunc mCreateInitFunc[];
-    static executeFunc mExecuteFunc[];
-    static tgSetFunc mTgSetFunc[];
+    static DUSK_GAME_DATA createHeapFunc mCreateHeapFunc[];
+    static DUSK_GAME_DATA createInitFunc mCreateInitFunc[];
+    static DUSK_GAME_DATA executeFunc mExecuteFunc[];
+    static DUSK_GAME_DATA tgSetFunc mTgSetFunc[];
 
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* field_0x5a8[2][2];
diff --git a/include/d/actor/d_a_boomerang.h b/include/d/actor/d_a_boomerang.h
index 6dcff6ef9f..2b527afe45 100644
--- a/include/d/actor/d_a_boomerang.h
+++ b/include/d/actor/d_a_boomerang.h
@@ -25,7 +25,6 @@ public:
     void onReserve() { mReserve = 1; }
     void offReserve() { mReserve = 0; }
 
-private:
     /* 0x04 */ J2DScreen* m_cursorYellowScrn;
     /* 0x08 */ J2DPane* m_cursorYellowAllPane;
     /* 0x0C */ J2DPane* m_cursorYellow0Pane;
@@ -126,7 +125,6 @@ public:
     bool getLockCntMax() { return m_lockCnt >= BOOMERANG_LOCK_MAX; }
     void onLockDistanceCancel() { onStateFlg0(FLG0_LOCK_DIST_CANCEL); }
 
-private:
     /* 0x568 */ J3DModel* mp_boomModel;
     /* 0x56C */ J3DModel* mp_shippuModel;
     /* 0x570 */ J3DAnmTextureSRTKey* m_windBtk;
@@ -190,12 +188,12 @@ STATIC_ASSERT(sizeof(daBoomerang_c) == 0xDE4);
 
 class daBoomerang_HIO_c0 {
 public:
-    static u16 const m_lockWaitTime;
-    static f32 const m_minCircleR;
-    static f32 const m_middleCircleR;
-    static f32 const m_maxCircleR;
-    static f32 const m_scale;
-    static f32 const m_lockWindScale;
+    static DUSK_GAME_DATA u16 const m_lockWaitTime;
+    static DUSK_GAME_DATA f32 const m_minCircleR;
+    static DUSK_GAME_DATA f32 const m_middleCircleR;
+    static DUSK_GAME_DATA f32 const m_maxCircleR;
+    static DUSK_GAME_DATA f32 const m_scale;
+    static DUSK_GAME_DATA f32 const m_lockWindScale;
 };
 
 #endif /* D_A_BOOMERANG_H */
diff --git a/include/d/actor/d_a_bullet.h b/include/d/actor/d_a_bullet.h
index d6f9135654..d925502779 100644
--- a/include/d/actor/d_a_bullet.h
+++ b/include/d/actor/d_a_bullet.h
@@ -18,7 +18,7 @@ class daBullet_Param_c {
 public:
     virtual ~daBullet_Param_c() {}
 
-    static daBullet_HIOParam const m;
+    static DUSK_GAME_DATA daBullet_HIOParam const m;
 };
 
 #if DEBUG
@@ -80,8 +80,8 @@ public:
     int wait(void*);
     int move(void*);
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 };
 
 STATIC_ASSERT(sizeof(daBullet_c) == 0x95c);
diff --git a/include/d/actor/d_a_canoe.h b/include/d/actor/d_a_canoe.h
index bf34a5eee7..bcd7615e18 100644
--- a/include/d/actor/d_a_canoe.h
+++ b/include/d/actor/d_a_canoe.h
@@ -65,7 +65,6 @@ public:
         field_0x1456 = 15;
     }
 
-private:
     /* 0x0568 */ request_of_phase_process_class mPhaseReq;
     /* 0x0570 */ J3DModel* mpModel;
     /* 0x0574 */ J3DModel* mpPaddleModel;
diff --git a/include/d/actor/d_a_coach_fire.h b/include/d/actor/d_a_coach_fire.h
index c5f890dc3d..1e8aa2d661 100644
--- a/include/d/actor/d_a_coach_fire.h
+++ b/include/d/actor/d_a_coach_fire.h
@@ -33,7 +33,7 @@ public:
 
     const CoachFireAttr& attr() { return M_attr; }
 
-    static CoachFireAttr const M_attr;
+    static DUSK_GAME_DATA CoachFireAttr const M_attr;
 
     inline ~daCoachFire_c();
 
@@ -42,7 +42,6 @@ public:
     void setNoHitTimer() { noHitTimer = 20; }
     inline int execute();
 
-private:
     /* 0x568 */ LIGHT_INFLUENCE mLightInfluence;
     /* 0x588 */ dCcD_Stts mStts;
     /* 0x5C4 */ dCcD_Sph mSph;
diff --git a/include/d/actor/d_a_cow.h b/include/d/actor/d_a_cow.h
index 403dc2aef6..e215256b91 100644
--- a/include/d/actor/d_a_cow.h
+++ b/include/d/actor/d_a_cow.h
@@ -208,7 +208,6 @@ public:
     u8 getCowIn() { return mCowIn; }
     u8 getNoNearCheckTimer() { return mNoNearCheckTimer; }
 
-private:
     /* 0x568 */ u16 mFlags;
     /* 0x56c */ request_of_phase_process_class mPhase;
     /* 0x574 */ mDoExt_McaMorfSO* mpMorf;
diff --git a/include/d/actor/d_a_crod.h b/include/d/actor/d_a_crod.h
index 84938d454a..02311fbeb5 100644
--- a/include/d/actor/d_a_crod.h
+++ b/include/d/actor/d_a_crod.h
@@ -48,7 +48,6 @@ public:
     static f32 getFlyInitY() { return 40.0f; }
     static f32 getFlyInitZ() { return 50.0f; }
 
-private:
     /* 0x568 */ J3DModel* mpBallModel;
     /* 0x56C */ mDoExt_bckAnm mBck;
     /* 0x588 */ J3DAnmTevRegKey* mpBallBrk;
diff --git a/include/d/actor/d_a_cstaF.h b/include/d/actor/d_a_cstaF.h
index 0e8b5c1ca7..982aa061a8 100644
--- a/include/d/actor/d_a_cstaF.h
+++ b/include/d/actor/d_a_cstaF.h
@@ -38,9 +38,8 @@ public:
     struct BckTbl {
         u16 idx[4];
     };
-    static const BckTbl m_bckIdxTable[];
+    static DUSK_GAME_DATA const BckTbl m_bckIdxTable[];
 
-private:
     /* 0x5A0 */ const char* m_arcName;
     /* 0x5A4 */ request_of_phase_process_class m_phase;
     /* 0x5AC */ J3DModel* mp_model;
diff --git a/include/d/actor/d_a_cstatue.h b/include/d/actor/d_a_cstatue.h
index e20e683398..2b74240fb2 100644
--- a/include/d/actor/d_a_cstatue.h
+++ b/include/d/actor/d_a_cstatue.h
@@ -99,9 +99,8 @@ public:
         mWarpMode = daCstatueWarpMode_Active;
     }
 
-    static u16 const m_bckIdxTable[daCstatueType_N][7];
+    static DUSK_GAME_DATA u16 const m_bckIdxTable[daCstatueType_N][7];
 
-private:
     /* 0x568 */ const char* mResName;
     /* 0x56C */ request_of_phase_process_class mPhaseReq;
     /* 0x574 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_demo_item.h b/include/d/actor/d_a_demo_item.h
index ed6d195f5e..62780f572f 100644
--- a/include/d/actor/d_a_demo_item.h
+++ b/include/d/actor/d_a_demo_item.h
@@ -55,7 +55,6 @@ public:
     void setOffsetPos(cXyz i_pos) { mOffsetPos = i_pos; }
     void setMaxScale(f32 i_scale) { mMaxScale = i_scale; }
 
-private:
     /* 0x92C */ cXyz mOffsetPos;
     /* 0x938 */ f32 mMaxScale;
     /* 0x93C */ u8 field_0x93c;
diff --git a/include/d/actor/d_a_door_boss.h b/include/d/actor/d_a_door_boss.h
index afd7984bf1..722afc0a84 100644
--- a/include/d/actor/d_a_door_boss.h
+++ b/include/d/actor/d_a_door_boss.h
@@ -50,7 +50,6 @@ public:
 
     void setAction(u8 i_action) { mAction = i_action; }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpDoorModel;
     /* 0x574 */ J3DModel* mpLockModel;
diff --git a/include/d/actor/d_a_door_bossL1.h b/include/d/actor/d_a_door_bossL1.h
index 7e14025cd2..c0b8f2b44a 100644
--- a/include/d/actor/d_a_door_bossL1.h
+++ b/include/d/actor/d_a_door_bossL1.h
@@ -76,7 +76,6 @@ public:
 
     void setAction(u8 action) { mAction = action; }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase1;
     /* 0x570 */ request_of_phase_process_class mPhase2;
     /* 0x578 */ request_of_phase_process_class mPhase3;
diff --git a/include/d/actor/d_a_door_bossL5.h b/include/d/actor/d_a_door_bossL5.h
index 832f575ac1..d876bab9c8 100644
--- a/include/d/actor/d_a_door_bossL5.h
+++ b/include/d/actor/d_a_door_bossL5.h
@@ -72,7 +72,6 @@ public:
         return 1;
     }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase1;
     /* 0x570 */ request_of_phase_process_class mPhase2;
     /* 0x578 */ request_of_phase_process_class mPhase3;
diff --git a/include/d/actor/d_a_door_dbdoor00.h b/include/d/actor/d_a_door_dbdoor00.h
index 9b2f65e756..ec976c7f6b 100644
--- a/include/d/actor/d_a_door_dbdoor00.h
+++ b/include/d/actor/d_a_door_dbdoor00.h
@@ -41,7 +41,6 @@ public:
 
     void setAction(u8 i_action) { mAction = i_action; }
 
-// private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ request_of_phase_process_class mPhaseReq2;
     /* 0x578 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_door_knob00.h b/include/d/actor/d_a_door_knob00.h
index 577b26b58e..742b8921c9 100644
--- a/include/d/actor/d_a_door_knob00.h
+++ b/include/d/actor/d_a_door_knob00.h
@@ -73,7 +73,6 @@ public:
     void onFlag(u16 flag) { field_0x60c |= flag; }
     int checkFlag(u16 flag) { return field_0x60c & flag; }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase1;
     /* 0x570 */ request_of_phase_process_class mPhase2;
     /* 0x578 */ J3DModel* mModel1;
diff --git a/include/d/actor/d_a_door_mbossL1.h b/include/d/actor/d_a_door_mbossL1.h
index 2bd95d920b..7b76f903bc 100644
--- a/include/d/actor/d_a_door_mbossL1.h
+++ b/include/d/actor/d_a_door_mbossL1.h
@@ -121,7 +121,6 @@ public:
         mAction = action;
     }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase1;
     /* 0x570 */ request_of_phase_process_class mPhase2;
     /* 0x578 */ request_of_phase_process_class mPhase3;
diff --git a/include/d/actor/d_a_door_push.h b/include/d/actor/d_a_door_push.h
index 5beb3aa564..f648ef208b 100644
--- a/include/d/actor/d_a_door_push.h
+++ b/include/d/actor/d_a_door_push.h
@@ -49,7 +49,6 @@ public:
     void setAction(u8 i_action) { mAction = i_action; }
     u32 getSceneNo() { return fopAcM_GetParamBit(this, 4, 6); }
 
-// private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel[2];
     /* 0x5B0 */ dBgW* mpDoorBgW;
diff --git a/include/d/actor/d_a_door_shutter.h b/include/d/actor/d_a_door_shutter.h
index a8e99f1295..c3b134ddb8 100644
--- a/include/d/actor/d_a_door_shutter.h
+++ b/include/d/actor/d_a_door_shutter.h
@@ -123,7 +123,6 @@ public:
     bool checkFlag(u16 flag) { return field_0x68e & flag; }
     void setAction(u8 action) { mAction = action; }
 
-private:
     /* 0x56C */ request_of_phase_process_class mPhase1;
     /* 0x574 */ request_of_phase_process_class mPhase2;
     /* 0x57C */ J3DModel* mModel1;
diff --git a/include/d/actor/d_a_dshutter.h b/include/d/actor/d_a_dshutter.h
index 479349c072..fb6d56ba97 100644
--- a/include/d/actor/d_a_dshutter.h
+++ b/include/d/actor/d_a_dshutter.h
@@ -65,15 +65,15 @@ public:
     f32 getCloseBoundSpeed() { return CLOSE_BOUND_SPEED; }
     f32 getCloseBoundRatio() { return CLOSE_BOUND_RATIO; }
 
-    static f32 const OPEN_SIZE;
-    static f32 const OPEN_ACCEL;
-    static f32 const OPEN_SPEED;
-    static f32 const OPEN_BOUND_SPEED;
-    static f32 const OPEN_BOUND_RATIO;
-    static f32 const CLOSE_ACCEL;
-    static f32 const CLOSE_SPEED;
-    static f32 const CLOSE_BOUND_SPEED;
-    static f32 const CLOSE_BOUND_RATIO;
+    static DUSK_GAME_DATA f32 const OPEN_SIZE;
+    static DUSK_GAME_DATA f32 const OPEN_ACCEL;
+    static DUSK_GAME_DATA f32 const OPEN_SPEED;
+    static DUSK_GAME_DATA f32 const OPEN_BOUND_SPEED;
+    static DUSK_GAME_DATA f32 const OPEN_BOUND_RATIO;
+    static DUSK_GAME_DATA f32 const CLOSE_ACCEL;
+    static DUSK_GAME_DATA f32 const CLOSE_SPEED;
+    static DUSK_GAME_DATA f32 const CLOSE_BOUND_SPEED;
+    static DUSK_GAME_DATA f32 const CLOSE_BOUND_RATIO;
 
     /* 0x5A0 */ dComIfG_resLoader_c mResLoader;
     /* 0x5B0 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_e_ai.h b/include/d/actor/d_a_e_ai.h
index d2f1b6ec06..78c4174338 100644
--- a/include/d/actor/d_a_e_ai.h
+++ b/include/d/actor/d_a_e_ai.h
@@ -48,7 +48,6 @@ public:
     int CreateHeap();
     int Create();
 
-private:
     /* 0x5AC */ JPABaseEmitter* mpEmitter;
     /* 0x5B0 */ request_of_phase_process_class m_phase;
     /* 0x5B8 */ u8 field_0x5b8;
diff --git a/include/d/actor/d_a_e_bg.h b/include/d/actor/d_a_e_bg.h
index c14b0cf533..b3b0e1d8bf 100644
--- a/include/d/actor/d_a_e_bg.h
+++ b/include/d/actor/d_a_e_bg.h
@@ -45,7 +45,6 @@ public:
     void setBgId(unsigned int i_bgId) { mBgId = i_bgId; }
     bool isBomb() { return mIsBomb; }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorfSO;
     /* 0x5B8 */ mDoExt_brkAnm* mpBrkAnm;
diff --git a/include/d/actor/d_a_e_db.h b/include/d/actor/d_a_e_db.h
index 4f10715443..a95722a6d1 100644
--- a/include/d/actor/d_a_e_db.h
+++ b/include/d/actor/d_a_e_db.h
@@ -80,12 +80,6 @@ public:
     /* 0x125C */ u32 field_0x125c;
     /* 0x1260 */ u8 field_0x1260[0x126C - 0x1260];
     /* 0x126C */ u8 HIOInit;
-#if TARGET_PC
-    cXyz mStalkLineInterpPrev[12];
-    cXyz mStalkLineInterpCurr[12];
-    bool mStalkLineInterpPrevValid;
-    bool mStalkLineInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_db_class) == 0x1270);
diff --git a/include/d/actor/d_a_e_dk.h b/include/d/actor/d_a_e_dk.h
index 381f8e1a62..2c7d46b84f 100644
--- a/include/d/actor/d_a_e_dk.h
+++ b/include/d/actor/d_a_e_dk.h
@@ -45,7 +45,6 @@ public:
     int create();
     daE_DK_c();
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorfSO;
     /* 0x5B8 */ mDoExt_McaMorfSO* mpCoreMorfSO;
diff --git a/include/d/actor/d_a_e_dt.h b/include/d/actor/d_a_e_dt.h
index 1296a78e5b..0fdb13f4e5 100644
--- a/include/d/actor/d_a_e_dt.h
+++ b/include/d/actor/d_a_e_dt.h
@@ -83,7 +83,6 @@ public:
     MtxP getBackMtx() { return mpMorf->getModel()->getAnmMtx(1); }
     fpc_ProcID getDemoId() { return mDemoID; }
 
-private:
     /* 0x05AC */ request_of_phase_process_class mPhase[3];
     /* 0x05C4 */ J3DModel* mpChestModel;
     /* 0x05C8 */ J3DModel* mpSpitModel;
@@ -175,14 +174,14 @@ private:
 STATIC_ASSERT(sizeof(daE_DT_c) == 0x1174);
 
 struct E_DT_n {
-    static f32 eDt_ShakeFrame[10];
-    static f32 eDt_ShakeFrameDemo[10];
-    static dCcD_SrcSph cc_dt_body_src;
-    static dCcD_SrcSph cc_dt_tongue_src;
-    static int mDt_OtamaNum;
-    static int mDt_OtamaNo[20];
-    static int m_fall_no;
-    static cXyz m_tongue_pos;
+    static DUSK_GAME_DATA f32 eDt_ShakeFrame[10];
+    static DUSK_GAME_DATA f32 eDt_ShakeFrameDemo[10];
+    static DUSK_GAME_DATA dCcD_SrcSph cc_dt_body_src;
+    static DUSK_GAME_DATA dCcD_SrcSph cc_dt_tongue_src;
+    static DUSK_GAME_DATA int mDt_OtamaNum;
+    static DUSK_GAME_DATA int mDt_OtamaNo[20];
+    static DUSK_GAME_DATA int m_fall_no;
+    static DUSK_GAME_DATA cXyz m_tongue_pos;
 };
 
 
diff --git a/include/d/actor/d_a_e_fb.h b/include/d/actor/d_a_e_fb.h
index a4494c5e7a..ae48f77ea6 100644
--- a/include/d/actor/d_a_e_fb.h
+++ b/include/d/actor/d_a_e_fb.h
@@ -40,7 +40,6 @@ public:
     cPhs_Step create();
     daE_FB_c();
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x5B8 */ mDoExt_invisibleModel mInvisibleModel;
diff --git a/include/d/actor/d_a_e_fk.h b/include/d/actor/d_a_e_fk.h
index 390e4e3420..fb18f74792 100644
--- a/include/d/actor/d_a_e_fk.h
+++ b/include/d/actor/d_a_e_fk.h
@@ -52,7 +52,6 @@ public:
     void CreateChk();
     int Create();
 
-private:
     /* 0x5AC */ u8 field_0x5AC[0x5B1 - 0x5AC];
     /* 0x5B1 */ u8 mUpDownMode;
     /* 0x5B2 */ u8 field_0x5B2[0x5B6 - 0x5B2];
diff --git a/include/d/actor/d_a_e_fz.h b/include/d/actor/d_a_e_fz.h
index e0b838aa51..e40232b74f 100644
--- a/include/d/actor/d_a_e_fz.h
+++ b/include/d/actor/d_a_e_fz.h
@@ -63,7 +63,6 @@ public:
     s32 CreateHeap();
     s32 create();
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;   /**< Phase request used when creating the actor. */
     /* 0x5B4 */ J3DModel* mpModel;                          /**< Pointer to the Mini Freezard's model. */
     /* 0x5B8 */ mDoExt_invisibleModel mInvisibleModel;      /**< Invisible model used for the Mini Freezard. */
diff --git a/include/d/actor/d_a_e_ge.h b/include/d/actor/d_a_e_ge.h
index c202e75231..3c4d4ffbee 100644
--- a/include/d/actor/d_a_e_ge.h
+++ b/include/d/actor/d_a_e_ge.h
@@ -61,7 +61,6 @@ public:
 
     u8 getGroupNo() { return mGroupNo; }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorfSO;
     /* 0x5B8 */ Z2CreatureEnemy mSound;
@@ -101,7 +100,7 @@ private:
     /* 0xB9E */ u8 field_0xb9e;
     /* 0xB9F */ u8 mHIOInit;
 
-    static actionFunc l_actionmenu[9];
+    static DUSK_GAME_DATA actionFunc l_actionmenu[9];
 };
 
 STATIC_ASSERT(sizeof(daE_GE_c) == 0xBA0);
diff --git a/include/d/actor/d_a_e_gi.h b/include/d/actor/d_a_e_gi.h
index adadfd03b8..a731797f32 100644
--- a/include/d/actor/d_a_e_gi.h
+++ b/include/d/actor/d_a_e_gi.h
@@ -47,7 +47,6 @@ public:
     bool isBattleOn() { return mIsBattleOn; }
     bool isAttackStart() { return mIsAttackStart; }
     
-private:
     /* 0x05AC */ request_of_phase_process_class mPhase;
     /* 0x05B4 */ mDoExt_McaMorfSO* mpModelMorf;
     /* 0x05B8 */ J3DModel* mpSwordModel;
diff --git a/include/d/actor/d_a_e_gm.h b/include/d/actor/d_a_e_gm.h
index 370dea9150..de8c0d6acc 100644
--- a/include/d/actor/d_a_e_gm.h
+++ b/include/d/actor/d_a_e_gm.h
@@ -62,7 +62,6 @@ public:
     BOOL checkAction(actionFunc action) { return mAction == action; }
     BOOL checkOldAction(actionFunc action) { return mOldAction == action; }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ dBgS_AcchCir mAcchCir;
     /* 0x5F4 */ dBgS_ObjAcch mObjAcch;
diff --git a/include/d/actor/d_a_e_hb.h b/include/d/actor/d_a_e_hb.h
index 3069bcd325..a7e0241007 100644
--- a/include/d/actor/d_a_e_hb.h
+++ b/include/d/actor/d_a_e_hb.h
@@ -73,12 +73,6 @@ public:
     /* 0x124C */ f32 field_0x124c;
     /* 0x1250 */ u8 field_0x1250[0x1264 - 0x1250];
     /* 0x1264 */ u8 HIOInit;
-#if TARGET_PC
-    cXyz mStalkLineInterpPrev[12];
-    cXyz mStalkLineInterpCurr[12];
-    bool mStalkLineInterpPrevValid;
-    bool mStalkLineInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_hb_class) == 0x1268);
diff --git a/include/d/actor/d_a_e_hm.h b/include/d/actor/d_a_e_hm.h
index 85f6e5422c..9be48a53f3 100644
--- a/include/d/actor/d_a_e_hm.h
+++ b/include/d/actor/d_a_e_hm.h
@@ -65,7 +65,6 @@ public:
     void CheckWall();
     void CreateStyle();
     int Create();
-private:
     /* 0x5AC */ u8 field_0x5ac;
     /* 0x5AD */ u8 field_0x5ad;
     /* 0x5AE */ u8 field_0x5ae;
diff --git a/include/d/actor/d_a_e_hp.h b/include/d/actor/d_a_e_hp.h
index 8941f1e2a6..86b092f915 100644
--- a/include/d/actor/d_a_e_hp.h
+++ b/include/d/actor/d_a_e_hp.h
@@ -96,6 +96,9 @@ public:
     /* 0xDE0 */ cXyz field_0xde0;
     /* 0xDEC */ u8 field_0xdec[0xdf9 - 0xdec];
     /* 0xDF9 */ u8 field_0xdf9;
+#if TARGET_PC
+    bool mItemCheckHandled;
+#endif
 };
 
 STATIC_ASSERT(sizeof(daE_HP_c) == 0xdfc);
diff --git a/include/d/actor/d_a_e_hz.h b/include/d/actor/d_a_e_hz.h
index 539d808cf5..e48a72ee69 100644
--- a/include/d/actor/d_a_e_hz.h
+++ b/include/d/actor/d_a_e_hz.h
@@ -64,7 +64,6 @@ public:
     void setInitPos();
     int create();
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;
     /* 0x5B4 */ request_of_phase_process_class mPhaseReq2;
     /* 0x5BC */ mDoExt_McaMorfSO* mpMorfSO;
diff --git a/include/d/actor/d_a_e_kk.h b/include/d/actor/d_a_e_kk.h
index 890da0eba2..a249cafc74 100644
--- a/include/d/actor/d_a_e_kk.h
+++ b/include/d/actor/d_a_e_kk.h
@@ -49,7 +49,6 @@ public:
     int CreateHeap();
     int create();
 
-private:
     /* 0x05AC */ request_of_phase_process_class mPhaseReq;
     /* 0x05B4 */ mDoExt_McaMorfSO* mpMorfSO;
     /* 0x05B8 */ mDoExt_McaMorfSO* mpWeaponMorfSO;
diff --git a/include/d/actor/d_a_e_mb.h b/include/d/actor/d_a_e_mb.h
index 527cf30eac..f36c744879 100644
--- a/include/d/actor/d_a_e_mb.h
+++ b/include/d/actor/d_a_e_mb.h
@@ -44,12 +44,6 @@ public:
     /* 0x88C */ u8 field_0x88C[0x8C8 - 0x88C];
     /* 0x8C8 */ s8 field_0x8c8;
     /* 0x8C9 */ u8 mInitHIO;
-#if TARGET_PC
-    cXyz mRopeInterpPrev[16];
-    cXyz mRopeInterpCurr[16];
-    bool mRopeInterpPrevValid;
-    bool mRopeInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_mb_class) == 0x8cc);
diff --git a/include/d/actor/d_a_e_oc.h b/include/d/actor/d_a_e_oc.h
index ada1b5310b..2d40d9bcbc 100644
--- a/include/d/actor/d_a_e_oc.h
+++ b/include/d/actor/d_a_e_oc.h
@@ -87,7 +87,6 @@ public:
     daE_OC_c* getTalkOc() { return mpTalk; }
     J3DModel* getOcModel() { return mpMorf->getModel(); }
 
-private:
     /* 0x5a0 */ request_of_phase_process_class mPhaseReqs[2];
     /* 0x5bc */ mDoExt_McaMorfSO* mpMorf;
     /* 0x5c0 */ J3DModel* mpModel;
@@ -159,14 +158,14 @@ private:
 STATIC_ASSERT(sizeof(daE_OC_c) == 0xe88);
 
 struct E_OC_n {
-    static f32 const oc_attackb_trans[10];
-    static f32 const oc_attackc_trans[10];
-    static dCcD_SrcSph cc_sph_src;
-    static dCcD_SrcSph at_sph_src;
-    static daE_OC_c* m_battle_oc;
-    static daE_OC_c* m_damage_oc;
-    static daE_OC_c* m_death_oc;
-    static daE_OC_c* m_talk_oc;
+    static DUSK_GAME_DATA f32 const oc_attackb_trans[10];
+    static DUSK_GAME_DATA f32 const oc_attackc_trans[10];
+    static DUSK_GAME_DATA dCcD_SrcSph cc_sph_src;
+    static DUSK_GAME_DATA dCcD_SrcSph at_sph_src;
+    static DUSK_GAME_DATA daE_OC_c* m_battle_oc;
+    static DUSK_GAME_DATA daE_OC_c* m_damage_oc;
+    static DUSK_GAME_DATA daE_OC_c* m_death_oc;
+    static DUSK_GAME_DATA daE_OC_c* m_talk_oc;
 };
 
 #endif /* D_A_E_OC_H */
diff --git a/include/d/actor/d_a_e_oct_bg.h b/include/d/actor/d_a_e_oct_bg.h
index cd5b6b27cd..9033e03736 100644
--- a/include/d/actor/d_a_e_oct_bg.h
+++ b/include/d/actor/d_a_e_oct_bg.h
@@ -54,7 +54,6 @@ public:
     u32 checkAction(actionFunc func) { return field_0xb58 == func; }
     bool checkNormalAttk() { return checkAction(&daE_OctBg_c::normal_attack); }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ mDoExt_McaMorfSO* field_0x5b4;
     /* 0x5B8 */ mDoExt_brkAnm* field_0x5b8;
diff --git a/include/d/actor/d_a_e_ot.h b/include/d/actor/d_a_e_ot.h
index 54e8399b7b..3505062e3c 100644
--- a/include/d/actor/d_a_e_ot.h
+++ b/include/d/actor/d_a_e_ot.h
@@ -54,7 +54,6 @@ public:
         /* 0x4 */ ACT_DAMAGE,
     };
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x5B8 */ J3DModel* mpEggModel;
diff --git a/include/d/actor/d_a_e_pm.h b/include/d/actor/d_a_e_pm.h
index edec93c6a2..35368eff61 100644
--- a/include/d/actor/d_a_e_pm.h
+++ b/include/d/actor/d_a_e_pm.h
@@ -84,7 +84,6 @@ public:
     u8 SwitchChk() { return mStage; }
     u8 DoorChk() { return mDoorAction; }
 
-private:
     /* 0x5AC */ fpc_ProcID mPuppetID[4];
     /* 0x5BC */ u8 field_0x5bc[0x5DC - 0x5BC];
     /* 0x5DC */ u8 mDoorAction;
diff --git a/include/d/actor/d_a_e_s1.h b/include/d/actor/d_a_e_s1.h
index 5cbae84696..a631ba47ac 100644
--- a/include/d/actor/d_a_e_s1.h
+++ b/include/d/actor/d_a_e_s1.h
@@ -81,15 +81,6 @@ public:
     /* 0x306D */ u8 field_0x306D[0x307C - 0x306D];
     /* 0x307C */ u32 mBodyEffEmtrID;
     /* 0x3080 */ u8 mInitHIO;
-
-#if TARGET_PC
-    static const int HAIR_STRAND_COUNT = 22;
-    static const int HAIR_SEGMENT_COUNT = 16;
-    cXyz mHairInterpPrev[HAIR_STRAND_COUNT * HAIR_SEGMENT_COUNT];
-    cXyz mHairInterpCurr[HAIR_STRAND_COUNT * HAIR_SEGMENT_COUNT];
-    bool mHairInterpPrevValid;
-    bool mHairInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_s1_class) == 0x3084);
diff --git a/include/d/actor/d_a_e_sb.h b/include/d/actor/d_a_e_sb.h
index e015ecc5bc..bd7d8c9bdc 100644
--- a/include/d/actor/d_a_e_sb.h
+++ b/include/d/actor/d_a_e_sb.h
@@ -57,7 +57,6 @@ public:
     int Delete();
     void setBaseMtx();
     cPhs_Step Create();
-private:
     /* 0x5AC */ int field_0x5ac;
     /* 0x5B0 */ int field_0x5b0;
     /* 0x5B4 */ int field_0x5b4;
@@ -78,7 +77,6 @@ private:
 public:
     /* 0x5EC */ cXyz* field_0x5ec;
     /* 0x5F0 */ f32 field_0x5f0;
-private:
     /* 0x5F4 */ cXyz field_0x5f4;
     /* 0x600 */ s16 field_0x600;
     /* 0x602 */ u8 field_0x602;
diff --git a/include/d/actor/d_a_e_sw.h b/include/d/actor/d_a_e_sw.h
index b073dae952..6f6a71f16d 100644
--- a/include/d/actor/d_a_e_sw.h
+++ b/include/d/actor/d_a_e_sw.h
@@ -82,7 +82,6 @@ public:
     bool d_checkOldAction(void (daE_SW_c::*action)()) {
         return field_0xb0c == action;
     }
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpModelMorf;
     /* 0x5B8 */ Z2CreatureEnemy mSound;
diff --git a/include/d/actor/d_a_e_tt.h b/include/d/actor/d_a_e_tt.h
index f3b79a69b3..38dc53ac3f 100644
--- a/include/d/actor/d_a_e_tt.h
+++ b/include/d/actor/d_a_e_tt.h
@@ -47,7 +47,6 @@ public:
     int CreateHeap();
     int create();
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhaseReq;
     /* 0x5B4 */ request_of_phase_process_class mPhaseReq2;
     /* 0x5BC */ mDoExt_McaMorfSO* mpMorfSO;
diff --git a/include/d/actor/d_a_e_vt.h b/include/d/actor/d_a_e_vt.h
index 4b6082adae..b55bb4891a 100644
--- a/include/d/actor/d_a_e_vt.h
+++ b/include/d/actor/d_a_e_vt.h
@@ -146,7 +146,6 @@ public:
     int create();
     daE_VA_c();
 
-private:
     /* 0x005AC */ request_of_phase_process_class mPhase;
     /* 0x005B4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x005B8 */ mDoExt_McaMorfSO* mpEndEfMorf;
diff --git a/include/d/actor/d_a_e_wb.h b/include/d/actor/d_a_e_wb.h
index aecbac96a1..770e537f2e 100644
--- a/include/d/actor/d_a_e_wb.h
+++ b/include/d/actor/d_a_e_wb.h
@@ -221,12 +221,6 @@ public:
     /* 0x17E4 */ u8 field_0x17e4[0x17e8 - 0x17e4];
     /* 0x17E8 */ f32 ride_speed_max;  ///< @brief Speed rate for riding calculations.
 #if TARGET_PC
-    cXyz himo_mat_interp_prev[2][16];
-    cXyz himo_mat_interp_curr[2][16];
-    cXyz himo_tex_interp_prev[2];
-    cXyz himo_tex_interp_curr[2];
-    bool himo_interp_prev_valid;
-    bool himo_interp_curr_valid;
     s8 demo_cam_sync_ticks;
 #endif
 };
diff --git a/include/d/actor/d_a_e_ww.h b/include/d/actor/d_a_e_ww.h
index fc1083c34e..f1ebac248a 100644
--- a/include/d/actor/d_a_e_ww.h
+++ b/include/d/actor/d_a_e_ww.h
@@ -59,7 +59,6 @@ public:
     void setAttack() { mActionMode = 10; }
     f32 const getSpeedF() { return speedF; }
 
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpModelMorf;
     /* 0x5B8 */ Z2CreatureEnemy mSound;
diff --git a/include/d/actor/d_a_e_yd.h b/include/d/actor/d_a_e_yd.h
index 44d6036600..188e435ba5 100644
--- a/include/d/actor/d_a_e_yd.h
+++ b/include/d/actor/d_a_e_yd.h
@@ -74,12 +74,6 @@ public:
     /* 0x1250 */ f32 field_0x1250;
     /* 0x1254 */ u8 field_0x1254[0x1268 - 0x1254];
     /* 0x1268 */ u8 field_0x1268;
-#if TARGET_PC
-    cXyz mLineMatInterpPrev[12];
-    cXyz mLineMatInterpCurr[12];
-    bool mLineMatInterpPrevValid;
-    bool mLineMatInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_yd_class) == 0x126c);
diff --git a/include/d/actor/d_a_e_yg.h b/include/d/actor/d_a_e_yg.h
index 6be19933cb..69a85430a8 100644
--- a/include/d/actor/d_a_e_yg.h
+++ b/include/d/actor/d_a_e_yg.h
@@ -63,15 +63,6 @@ public:
     /* 0x0BB4 */ yg_ke_s mYgKes[13];
     /* 0x1880 */ mDoExt_3DlineMat0_c mLineMat;
     /* 0x189C */ u8 mIsFirstSpawn;
-
-#if TARGET_PC
-    static const int TENTACLE_STRAND_COUNT = 13;
-    static const int TENTACLE_SEGMENT_COUNT = 10;
-    cXyz mTentacleInterpPrev[TENTACLE_STRAND_COUNT * TENTACLE_SEGMENT_COUNT];
-    cXyz mTentacleInterpCurr[TENTACLE_STRAND_COUNT * TENTACLE_SEGMENT_COUNT];
-    bool mTentacleInterpPrevValid;
-    bool mTentacleInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_yg_class) == 0x18a0);
diff --git a/include/d/actor/d_a_e_yh.h b/include/d/actor/d_a_e_yh.h
index 63e8ac1882..519e5e2779 100644
--- a/include/d/actor/d_a_e_yh.h
+++ b/include/d/actor/d_a_e_yh.h
@@ -77,12 +77,6 @@ public:
     /* 0x1260 */ u32 field_0x1260;
     /* 0x1260 */ u8 field_0x1264[0x1270 - 0x1264];
     /* 0x1270 */ bool mIsHIOOwner;
-#if TARGET_PC
-    cXyz mLineInterpPrev[12];
-    cXyz mLineInterpCurr[12];
-    bool mLineInterpPrevValid;
-    bool mLineInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(e_yh_class) == 0x1274);
diff --git a/include/d/actor/d_a_e_ym.h b/include/d/actor/d_a_e_ym.h
index 3217592e13..699d14d98f 100644
--- a/include/d/actor/d_a_e_ym.h
+++ b/include/d/actor/d_a_e_ym.h
@@ -122,7 +122,6 @@ public:
     u8 getSwitchBit() { return mSwitchBit; }
     u8 isHide() { return mIsHide; }
     
-private:
     /* 0x5AC */ request_of_phase_process_class mPhase;
     /* 0x5B4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x5B8 */ mDoExt_brkAnm* mpBrk;
@@ -215,7 +214,7 @@ private:
 STATIC_ASSERT(sizeof(daE_YM_c) == 0xAF8);
 
 struct E_YM_n {
-    static dCcD_SrcSph cc_sph_src;
+    static DUSK_GAME_DATA dCcD_SrcSph cc_sph_src;
 };
 
 
diff --git a/include/d/actor/d_a_e_zs.h b/include/d/actor/d_a_e_zs.h
index d15b384650..93dbd82d89 100644
--- a/include/d/actor/d_a_e_zs.h
+++ b/include/d/actor/d_a_e_zs.h
@@ -39,7 +39,6 @@ public:
     int CreateHeap();
     int create();
 
-private:
     /* 0x5ac */ request_of_phase_process_class mPhase;
     /* 0x5b4 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x5b8 */ Z2CreatureEnemy mSound;
diff --git a/include/d/actor/d_a_formation_mng.h b/include/d/actor/d_a_formation_mng.h
index 79163f9cec..c308eb5352 100644
--- a/include/d/actor/d_a_formation_mng.h
+++ b/include/d/actor/d_a_formation_mng.h
@@ -311,10 +311,10 @@ struct daFmtMng_c : public fopAc_ac_c {
     }
 
     static FmtMngAttributes const& attr() { return M_attr; }
-    static FmtMngAttributes const M_attr;
+    static DUSK_GAME_DATA FmtMngAttributes const M_attr;
 
     typedef void (daFmtMng_c::*ActionFunc)();
-    static daFmtMng_c::ActionFunc ActionTable[10];
+    static DUSK_GAME_DATA daFmtMng_c::ActionFunc ActionTable[10];
 
     /* 0x568 */ FmtPos_c* mPos;
     /* 0x56C */ FmtMember_c* mMember;
diff --git a/include/d/actor/d_a_grass.h b/include/d/actor/d_a_grass.h
index 4b07bea1d5..fa887b546a 100644
--- a/include/d/actor/d_a_grass.h
+++ b/include/d/actor/d_a_grass.h
@@ -41,9 +41,9 @@ public:
     static void deleteRoomGrass(int);
     static void deleteRoomFlower(int);
 
-    static daGrass_c* m_myObj;
-    static dGrass_packet_c* m_grass;
-    static dFlower_packet_c* m_flower;
+    static DUSK_GAME_DATA daGrass_c* m_myObj;
+    static DUSK_GAME_DATA dGrass_packet_c* m_grass;
+    static DUSK_GAME_DATA dFlower_packet_c* m_flower;
 
     /* 0x568 */ u8 unk_0x568[0x570 - 0x568];
 };
diff --git a/include/d/actor/d_a_horse.h b/include/d/actor/d_a_horse.h
index 7e8ef8c343..2074570517 100644
--- a/include/d/actor/d_a_horse.h
+++ b/include/d/actor/d_a_horse.h
@@ -196,9 +196,6 @@ public:
     void copyReinPos();
     void setReinPosHandSubstance(int);
     void setReinPosNormalSubstance();
-#if TARGET_PC
-    void lerpControlPoints(f32 alpha);
-#endif
     void bgCheck();
     bool checkSpecialWallHitSubstance(cXyz const&) const;
     void setServiceWaitTimer();
@@ -351,8 +348,8 @@ public:
         m_modelData->getMaterialNodePointer(5)->getShape()->hide();
     }
 
-    static u16 const m_footJointTable[];
-    static f32 const m_callLimitDistance2;
+    static DUSK_GAME_DATA u16 const m_footJointTable[];
+    static DUSK_GAME_DATA f32 const m_callLimitDistance2;
 
     /* 0x0568 */ request_of_phase_process_class m_phase;
     /* 0x0570 */ J3DModel* m_model;
@@ -567,7 +564,7 @@ public:
 
 class daHorse_hio_c0 {
 public:
-    static const daHorse_hio_c1 m;
+    static DUSK_GAME_DATA const daHorse_hio_c1 m;
 };
 
 class daHorse_hio_c : public JORReflexible {
diff --git a/include/d/actor/d_a_hozelda.h b/include/d/actor/d_a_hozelda.h
index 0c640e779c..d87542ccbc 100644
--- a/include/d/actor/d_a_hozelda.h
+++ b/include/d/actor/d_a_hozelda.h
@@ -29,8 +29,8 @@ public:
     static void setMorfFrame(u8 i_frame) { mMorfFrame = i_frame; }
     static void decMorfFrame() { cLib_calcTimer<u8>(&mMorfFrame); }
 
-    static u8 mEyeMoveFlg;
-    static u8 mMorfFrame;
+    static DUSK_GAME_DATA u8 mEyeMoveFlg;
+    static DUSK_GAME_DATA u8 mMorfFrame;
 
     /* 0x0F4 */ f32 field_0xf4;
     /* 0x0F8 */ f32 field_0xf8;
@@ -50,7 +50,7 @@ struct daHoZelda_hio_c1 {
 struct daHoZelda_hio_c0 {
     daHoZelda_hio_c0() {}
 
-    static daHoZelda_hio_c1 const m;
+    static DUSK_GAME_DATA daHoZelda_hio_c1 const m;
 };
 
 class daHoZelda_hio_c : public JORReflexible {
diff --git a/include/d/actor/d_a_itembase.h b/include/d/actor/d_a_itembase.h
index fa4d246062..374e4b7df2 100644
--- a/include/d/actor/d_a_itembase.h
+++ b/include/d/actor/d_a_itembase.h
@@ -32,6 +32,12 @@ struct daItemBase_data {
 class daItemBase_c : public fopAc_ac_c {
 public:
     u8 getItemNo();
+#if TARGET_PC
+    u8 getDisplayItemNo() const {
+        return mDisplayItemNo != 0xFF ? mDisplayItemNo : m_itemNo;
+    }
+    void setDisplayItemNo(u8 itemNo) { mDisplayItemNo = itemNo; }
+#endif
     void hide();
     void show();
     void changeDraw();
@@ -60,7 +66,7 @@ public:
     virtual u8 getCollisionH();
     virtual u8 getCollisionR();
 
-    static daItemBase_data const m_data;
+    static DUSK_GAME_DATA daItemBase_data const m_data;
 
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mpModel;
@@ -79,6 +85,9 @@ public:
     /* 0x928 */ s16 m_get_timer;
     /* 0x92A */ u8 m_itemNo;
     /* 0x92B */ u8 field_0x92b;
+#if TARGET_PC
+    u8 mDisplayItemNo = 0xFF;
+#endif
 };
 
 #endif /* D_A_D_A_ITEMBASE_H */
diff --git a/include/d/actor/d_a_kago.h b/include/d/actor/d_a_kago.h
index 33ec51672f..ba0e77a37c 100644
--- a/include/d/actor/d_a_kago.h
+++ b/include/d/actor/d_a_kago.h
@@ -140,7 +140,6 @@ public:
     void setEatYm() { field_0x6d8 |= (u8) 4; }
     MtxP getMouthMtx() { return mAnm_p->getModel()->getAnmMtx(7); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ mDoExt_McaMorfSO* mAnm_p;
     /* 0x574 */ Z2CreatureEnemy mSound;
diff --git a/include/d/actor/d_a_mant.h b/include/d/actor/d_a_mant.h
index 6d5b173d1a..e6f3d71a9c 100644
--- a/include/d/actor/d_a_mant.h
+++ b/include/d/actor/d_a_mant.h
@@ -92,10 +92,7 @@ public:
     /* 0x39A4 */ cM_rnd_c mMantRng;
 #endif
 };
-#if TARGET_PC
-STATIC_ASSERT(sizeof(mant_class) == 0x39ac);
-#else
+
 STATIC_ASSERT(sizeof(mant_class) == 0x39a4);
-#endif
 
 #endif /* D_A_MANT_H */
diff --git a/include/d/actor/d_a_mg_rod.h b/include/d/actor/d_a_mg_rod.h
index 97a0bb1c72..76863f33d5 100644
--- a/include/d/actor/d_a_mg_rod.h
+++ b/include/d/actor/d_a_mg_rod.h
@@ -299,13 +299,6 @@ public:
     /* 0x168C */ u8 field_0x168c;
     /* 0x168D */ u8 field_0x168d;
     /* 0x168E */ u8 HIOInit;
-
-#if TARGET_PC
-    cXyz mLineInterpPrev[MG_ROD_LURE_LINE_LEN];
-    cXyz mLineInterpCurr[MG_ROD_LURE_LINE_LEN];
-    bool mLineInterpPrevValid;
-    bool mLineInterpCurrValid;
-#endif
 };
 
 #endif /* D_A_MG_ROD_H */
diff --git a/include/d/actor/d_a_midna.h b/include/d/actor/d_a_midna.h
index c9e84ee9d4..1371dce12c 100644
--- a/include/d/actor/d_a_midna.h
+++ b/include/d/actor/d_a_midna.h
@@ -32,7 +32,7 @@ public:
 
 class daMidna_hio_c0 {
 public:
-    static daMidna_hio_c1 const m;
+    static DUSK_GAME_DATA daMidna_hio_c1 const m;
 };
 
 STATIC_ASSERT(sizeof(daMidna_hio_c0::m) == 0x20);
@@ -87,8 +87,8 @@ public:
     /* 0x0FC */ f32 mNowOffsetX;
     /* 0x100 */ f32 mNowOffsetY;
 
-    static bool sEyeMoveFlg;
-    static u8 sMorfFrame;
+    static DUSK_GAME_DATA bool sEyeMoveFlg;
+    static DUSK_GAME_DATA u8 sMorfFrame;
 };
 
 STATIC_ASSERT(sizeof(daMidna_matAnm_c) == 0x104);
@@ -420,10 +420,9 @@ public:
 
     static u32 getOtherHeapSize() { return 0x1D0; }
 
-    static daMidna_texData_s const m_texDataTable[21];
-    static daMidna_anmData_s const m_anmDataTable[53];
+    static DUSK_GAME_DATA daMidna_texData_s const m_texDataTable[21];
+    static DUSK_GAME_DATA daMidna_anmData_s const m_anmDataTable[53];
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ J3DModel* mpShadowModel;
diff --git a/include/d/actor/d_a_mirror.h b/include/d/actor/d_a_mirror.h
index e2f9a51e30..ecf1c127be 100644
--- a/include/d/actor/d_a_mirror.h
+++ b/include/d/actor/d_a_mirror.h
@@ -58,8 +58,8 @@ public:
     static u32 getMirrorRoomPrm() { return 0xFF03; }
 
     typedef int (daMirror_c::*entryModelFunc)(J3DModel*);
-    static entryModelFunc m_entryModel;
-    static daMirror_c* m_myObj;
+    static DUSK_GAME_DATA entryModelFunc m_entryModel;
+    static DUSK_GAME_DATA daMirror_c* m_myObj;
 
     /* 0x570 */ dMirror_packet_c mPacket;
     /* 0x6f8 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_movie_player.h b/include/d/actor/d_a_movie_player.h
index c382e0d1f7..785f9458ab 100644
--- a/include/d/actor/d_a_movie_player.h
+++ b/include/d/actor/d_a_movie_player.h
@@ -4,6 +4,7 @@
 #if !TARGET_PC
 #include <thp.h>
 #else
+#include <dolphin/thp.h>
 #include <atomic>
 #include <chrono>
 #endif
@@ -17,29 +18,6 @@ struct daMP_THPReadBuffer {
 };
 
 #if TARGET_PC
-// Copying here because thp.h is probably erroneous in the dolphin lib,
-// and it's kind of a problem being there (Aurora owns the headers).
-// TODO: Move this stuff in decomp?
-typedef struct THPAudioRecordHeader {
-    BE(u32) offsetNextChannel;
-    BE(u32) sampleSize;
-    BE(s16) lCoef[8][2];
-    BE(s16) rCoef[8][2];
-    BE(s16) lYn1;
-    BE(s16) lYn2;
-    BE(s16) rYn1;
-    BE(s16) rYn2;
-} THPAudioRecordHeader;
-
-typedef struct THPAudioDecodeInfo {
-    u8* encodeData;
-    u32 offsetNibbles;
-    u8 predictor;
-    u8 scale;
-    s16 yn1;
-    s16 yn2;
-} THPAudioDecodeInfo;
-
 typedef struct THPTextureSet {
 	u8* ytexture;
 	u8* utexture;
@@ -86,21 +64,11 @@ typedef struct THPHeader {
 	/* 0x2C */ BE(u32) finalFrameDataOffsets;
 } THPHeader;
 
-static u32 THPAudioDecode(s16* audioBuffer, u8* audioFrame, s32 flag);
-static s32 __THPAudioGetNewSample(THPAudioDecodeInfo* info);
-static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr);
-
 #define THP_AUDIO_BUFFER_COUNT 3
 #define THP_READ_BUFFER_COUNT  10
 #define THP_TEXTURE_SET_COUNT  3
 #endif
 
-#if TARGET_PC
-namespace dusk {
-    void MoviePlayerShutdown();
-}
-#endif
-
 struct daMP_THPPlayer {
     /* 0x000 */ DVDFileInfo fileInfo;
 	/* 0x03C */ THPHeader header;
@@ -170,9 +138,8 @@ public:
     static int daMP_c_Callback_Main(daMP_c*);
     static int daMP_c_Callback_Draw(daMP_c*);
 
-    static daMP_c* m_myObj;
+    static DUSK_GAME_DATA daMP_c* m_myObj;
 
-private:
     /* 0x568 */ u32 (*mpGetMovieRestFrame)(void);
     /* 0x56C */ void (*mpSetPercentMovieVol)(f32);
     /* 0x570 */ u32 (*mpTHPGetTotalFrame)(void);
diff --git a/include/d/actor/d_a_myna.h b/include/d/actor/d_a_myna.h
index 0ef55d11ad..511f7b11e6 100644
--- a/include/d/actor/d_a_myna.h
+++ b/include/d/actor/d_a_myna.h
@@ -131,8 +131,8 @@ public:
     typedef void (daMyna_c::*ProcFunc)();
     typedef int (daMyna_c::*BaseMotionFunc)(int);
 
-    static dCcD_SrcSph const mCcDSph;
-    static daMyna_c::BaseMotionFunc mBaseMotionTBL[7];
+    static DUSK_GAME_DATA dCcD_SrcSph const mCcDSph;
+    static DUSK_GAME_DATA daMyna_c::BaseMotionFunc mBaseMotionTBL[7];
 
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ mDoExt_McaMorfSO* mpMorf;
diff --git a/include/d/actor/d_a_nbomb.h b/include/d/actor/d_a_nbomb.h
index 4c5eb820ff..15c91043ff 100644
--- a/include/d/actor/d_a_nbomb.h
+++ b/include/d/actor/d_a_nbomb.h
@@ -91,7 +91,7 @@ public:
 
     s16 getExTime() { return mExTime; }
 
-    static const char* m_arcNameList[6];
+    static DUSK_GAME_DATA const char* m_arcNameList[6];
 
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_npc.h b/include/d/actor/d_a_npc.h
index 70e3e01270..51425bb912 100644
--- a/include/d/actor/d_a_npc.h
+++ b/include/d/actor/d_a_npc.h
@@ -29,7 +29,7 @@ struct daNpc_GetParam3 {  // name unknown
 };
 
 class daNpcT_ActorMngr_c {
-private:
+public:
     /* 0x0 */ fpc_ProcID mActorID;
 
 public:
@@ -44,7 +44,7 @@ public:
 };
 
 class daNpcT_MatAnm_c : public J3DMaterialAnm {
-private:
+public:
     /* 0x0F4 */ mutable f32 field_0xF4;
     /* 0x0F8 */ mutable f32 field_0xF8;
     /* 0x0FC */ f32 mNowOffsetX;
@@ -102,7 +102,6 @@ public:
     }
     void setOffset(int i_offset) { mOffset = i_offset; }
 
-private:
     /* 0x00 */ sequenceStepData_c const* mpSeqData;
     /* 0x04 */ int mStepNum;
     /* 0x08 */ int mNo;
@@ -217,7 +216,7 @@ public:
 };
 
 class daNpcT_JntAnm_c {
-private:
+public:
     /* 0x000 */ daNpcT_ActorMngr_c mActrMngr;
     /* 0x008 */ cXyz mPos;
     /* 0x014 */ cXyz mAttnPos;
@@ -776,12 +775,12 @@ public:
         return chkFindActor(daPy_getPlayerActorClass(), param_0, param_1);
     }
 
-    static dCcD_SrcGObjInf const mCcDObjData;
-    static dCcD_SrcCyl mCcDCyl;
-    static dCcD_SrcSph mCcDSph;
-    static fopAc_ac_c* mFindActorPtrs[50];
-    static s16 mSrchName;
-    static int mFindCount;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjData;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA fopAc_ac_c* mFindActorPtrs[50];
+    static DUSK_GAME_DATA s16 mSrchName;
+    static DUSK_GAME_DATA int mFindCount;
 
     enum Mode {
         /*  0 */ MODE_ENTER,
diff --git a/include/d/actor/d_a_npc2.h b/include/d/actor/d_a_npc2.h
index 58343a47b0..2453ba1f30 100644
--- a/include/d/actor/d_a_npc2.h
+++ b/include/d/actor/d_a_npc2.h
@@ -15,7 +15,6 @@ public:
     fopAc_ac_c* getActor();
     virtual ~daBaseNpc_acMngr_c() {}
 
-private:
     /* 0x04 */ fpc_ProcID mActorId;
 };
 
@@ -113,9 +112,9 @@ public:
     virtual void drawOtherMdls();
     virtual bool dbgDraw();
 
-    static dCcD_SrcGObjInf const mCcDObj;
-    static dCcD_SrcCyl mCcDCyl;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObj;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 
 public:
     /* 0x56C */ dBgS_ObjAcch mAcch;
@@ -173,9 +172,9 @@ public:
     virtual int ToFore() { return 1; }
     virtual int ToBack() { return 1; }
 
-    static const char* m_name;
-    static int m_dzb_id;
-    static MoveBGActor_SetFunc m_set_func;
+    static DUSK_GAME_DATA const char* m_name;
+    static DUSK_GAME_DATA int m_dzb_id;
+    static DUSK_GAME_DATA MoveBGActor_SetFunc m_set_func;
 
 public:
     /* 0xA14 */ dBgW* mpBgw;
diff --git a/include/d/actor/d_a_npc4.h b/include/d/actor/d_a_npc4.h
index 6532d92842..1bf39f54ec 100644
--- a/include/d/actor/d_a_npc4.h
+++ b/include/d/actor/d_a_npc4.h
@@ -12,7 +12,7 @@
 #include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
 
 class daNpcF_ActorMngr_c {
-private:
+public:
     /* 0x0 */ fpc_ProcID mActorID;
 
 public:
@@ -52,7 +52,7 @@ BOOL daNpcF_chkPassed(cXyz i_pos, dPnt* i_points, u16 i_idx, u16 i_num, BOOL i_i
 BOOL daNpcF_chkDoBtnEqSpeak(fopAc_ac_c* i_actor_p);
 
 class daNpcF_SPCurve_c {
-private:
+public:
     /* 0x00 */ u16 mNurbs;
     /* 0x02 */ u16 field_0x02;
     /* 0x04 */ u8 mIsReversed;
@@ -119,7 +119,7 @@ public:
 };  // Size: 0x630
 
 class daNpcF_MatAnm_c : public J3DMaterialAnm {
-private:
+public:
     /* 0x0F4 */ mutable f32 field_0xF4;
     /* 0x0F8 */ mutable f32 field_0xF8;
     /* 0x0FC */ f32 mNowOffsetX;
@@ -138,7 +138,7 @@ public:
 };
 
 class daNpcF_Lookat_c {
-private:
+public:
     /* 0x00 */ cXyz mJointPos[4];
     /* 0x30 */ cXyz* mAttnPos_p;
     /* 0x34 */ csXyz mAngularMoveDis[4];
@@ -394,19 +394,18 @@ public:
     void onHide() { mHide = true; }
     void offHide() { mHide = false; }
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
-    static dCcD_SrcSph mCcDSph;
-    static fopAc_ac_c* mFindActorPList[100];
-    static s32 mFindCount;
-    static s16 mSrchActorName;
-    static char mFileNameBuf[0x15];
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA fopAc_ac_c* mFindActorPList[100];
+    static DUSK_GAME_DATA s32 mFindCount;
+    static DUSK_GAME_DATA s16 mSrchActorName;
+    static DUSK_GAME_DATA char mFileNameBuf[0x15];
 };
 
 STATIC_ASSERT(sizeof(daNpcF_c) == 0xB48);
 
 class daNpcF_MoveBgActor_c : public daNpcF_c {
-private:
 public:
     // these functions are inferred based on daBaseNpc_moveBgActor_c -
     // defining them in this order fixes weak function order for this class in d_a_npc
diff --git a/include/d/actor/d_a_npc_aru.h b/include/d/actor/d_a_npc_aru.h
index a0a30a676f..a41e45acba 100644
--- a/include/d/actor/d_a_npc_aru.h
+++ b/include/d/actor/d_a_npc_aru.h
@@ -17,7 +17,7 @@ class daNpc_Aru_Param_c {
 public:
     virtual ~daNpc_Aru_Param_c() {}
 
-    static daNpc_Aru_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Aru_HIOParam const m;
 };
 
 #if DEBUG
@@ -171,10 +171,9 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
     void setLastIn() { mLastGoatIn = true; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[7];
-    static cutFunc DUSK_CONST mCutList[7];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[7];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[7];
 
-private:
     /* 0xE40 */ NPC_ARU_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_ash.h b/include/d/actor/d_a_npc_ash.h
index 084569a66e..e9f6e3427a 100644
--- a/include/d/actor/d_a_npc_ash.h
+++ b/include/d/actor/d_a_npc_ash.h
@@ -12,7 +12,7 @@ public:
     daNpcAsh_Param_c() {}
     virtual ~daNpcAsh_Param_c() {}
 
-    static const daNpcAsh_HIOParam m;
+    static DUSK_GAME_DATA const daNpcAsh_HIOParam m;
 };
 
 #if DEBUG
@@ -143,9 +143,8 @@ public:
     inline bool step(s16, bool);
     inline void playExpression();
 
-    static EventFn mEvtSeqList[6];
+    static DUSK_GAME_DATA EventFn mEvtSeqList[6];
 
-private:
     /* 0xB48 */ Z2Creature mCreatureSound;
     /* 0xBD8 */ J3DModel* mModelBow;
     /* 0xBDC */ J3DModel* mModelQuiver;
diff --git a/include/d/actor/d_a_npc_ashB.h b/include/d/actor/d_a_npc_ashB.h
index 12037188c6..9b158acf2d 100644
--- a/include/d/actor/d_a_npc_ashB.h
+++ b/include/d/actor/d_a_npc_ashB.h
@@ -12,7 +12,7 @@ class daNpcAshB_Param_c {
 public:
     virtual ~daNpcAshB_Param_c() {}
 
-    static const daNpcAshB_HIOParam m;
+    static DUSK_GAME_DATA const daNpcAshB_HIOParam m;
 };
 
 #if DEBUG
@@ -135,9 +135,8 @@ public:
     inline bool step(s16, int, f32);
     inline void playExpression();
 
-    static EventFn DUSK_CONST mEvtSeqList[2];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[2];
 
-private:
     /* 0xB48 */ Z2Creature mCreatureSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_npc_bans.h b/include/d/actor/d_a_npc_bans.h
index b09143caa7..0da1a71b92 100644
--- a/include/d/actor/d_a_npc_bans.h
+++ b/include/d/actor/d_a_npc_bans.h
@@ -22,7 +22,7 @@ class daNpc_Bans_Param_c {
 public:
     virtual ~daNpc_Bans_Param_c() {}
 
-    static daNpc_Bans_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Bans_HIOParam const m;
 };
 
 #if DEBUG
@@ -117,8 +117,8 @@ public:
         return rv;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[4];
-    static cutFunc DUSK_CONST mCutList[4];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[4];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[4];
 
     /* 0x0F7C */ mDoExt_McaMorfSO* mpScoopMorf;
     /* 0x0F80 */ NPC_BANS_HIO_CLASS* mHIO;
diff --git a/include/d/actor/d_a_npc_besu.h b/include/d/actor/d_a_npc_besu.h
index f0e26e1538..04579f595b 100644
--- a/include/d/actor/d_a_npc_besu.h
+++ b/include/d/actor/d_a_npc_besu.h
@@ -15,7 +15,7 @@ class daNpc_Besu_Param_c {
 public:
     virtual ~daNpc_Besu_Param_c() {}
 
-    static const daNpc_Besu_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Besu_HIOParam m;
 };
 
 #if DEBUG
@@ -140,10 +140,9 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xff00) >> 8; }
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xff0000) >> 16; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[15];
-    static cutFunc DUSK_CONST mCutList[15];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[15];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[15];
 
-private:
     /* 0x0E40 */ mDoExt_McaMorfSO* mpCupModelMorf;
     /* 0x0E44 */ NPC_BESU_HIO_CLASS* mpHIO;
     /* 0x0E48 */ J3DModel* mpClothModel[1];
diff --git a/include/d/actor/d_a_npc_blue_ns.h b/include/d/actor/d_a_npc_blue_ns.h
index 8920bc1be5..8235ad7b25 100644
--- a/include/d/actor/d_a_npc_blue_ns.h
+++ b/include/d/actor/d_a_npc_blue_ns.h
@@ -14,7 +14,7 @@ class daNpcBlueNS_Param_c {
 public:
     virtual ~daNpcBlueNS_Param_c() {}
 
-    static const daNpcBlueNS_HIOParam m;
+    static DUSK_GAME_DATA const daNpcBlueNS_HIOParam m;
 };
 
 #if DEBUG
@@ -124,7 +124,7 @@ public:
         return var_r30;
     }
 
-    static EventFn DUSK_CONST mEvtSeqList[];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[];
 
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ u8 field_0xBD8[0xBDC - 0xBD8];
diff --git a/include/d/actor/d_a_npc_bou.h b/include/d/actor/d_a_npc_bou.h
index 25dd490fd9..d0379b9a1b 100644
--- a/include/d/actor/d_a_npc_bou.h
+++ b/include/d/actor/d_a_npc_bou.h
@@ -16,7 +16,7 @@ struct daNpc_Bou_HIOParam {
 public:
     virtual ~daNpc_Bou_Param_c() {}
 
-    static const daNpc_Bou_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Bou_HIOParam m;
  };
 
 #if DEBUG
@@ -114,8 +114,8 @@ public:
     virtual int drawDbgInfo();
     virtual void changeAnm(int*, int*);
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[9];
-    static cutFunc DUSK_CONST mCutList[9];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[9];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[9];
 
     int getFlowNodeNo() {
         u16 nodeNo = home.angle.x;
@@ -168,7 +168,6 @@ public:
         return 0;
     }
 
-private:
     /* 0xE40 */ NPC_BOU_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl1;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_bouS.h b/include/d/actor/d_a_npc_bouS.h
index 27eafb48fd..7d6f48fb53 100644
--- a/include/d/actor/d_a_npc_bouS.h
+++ b/include/d/actor/d_a_npc_bouS.h
@@ -29,7 +29,7 @@ class daNpcBouS_Param_c {
 public:
     virtual ~daNpcBouS_Param_c() {}
 
-    static daNpcBouS_HIOParam const m;
+    static DUSK_GAME_DATA daNpcBouS_HIOParam const m;
 };
 
 #if DEBUG
@@ -128,9 +128,8 @@ public:
         mForcibleTalk = 1;
     }
 
-    static eventFunc mEvtSeqList[4];
+    static DUSK_GAME_DATA eventFunc mEvtSeqList[4];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_cd.h b/include/d/actor/d_a_npc_cd.h
index 3f942a5988..21483c29c1 100644
--- a/include/d/actor/d_a_npc_cd.h
+++ b/include/d/actor/d_a_npc_cd.h
@@ -25,7 +25,7 @@ public:
     J3DModelData* getObjMdlDataP(int);
     virtual ~daNpcCd_c() {}
 
-    static dCcD_SrcCyl const m_cylDat;
+    static DUSK_GAME_DATA dCcD_SrcCyl const m_cylDat;
 
     /* 0x56C */ request_of_phase_process_class mPhase1;
     /* 0x574 */ request_of_phase_process_class mPhase2;
@@ -101,7 +101,7 @@ public:
 
 STATIC_ASSERT(sizeof(daNpcCd_HIO_c) == 0x29BC);
 
-extern daNpcCd_HIO_c l_Cd_HIO;
+DUSK_GAME_EXTERN daNpcCd_HIO_c l_Cd_HIO;
 inline f32 HIO_atnOfs(int param_1) {
     s16 rv;
     if (param_1 < 16) {
diff --git a/include/d/actor/d_a_npc_cd2.h b/include/d/actor/d_a_npc_cd2.h
index 3d2eaa87c5..d37a09f99e 100644
--- a/include/d/actor/d_a_npc_cd2.h
+++ b/include/d/actor/d_a_npc_cd2.h
@@ -87,7 +87,7 @@ struct daNpcCd2_HIO_c : public fOpAcm_HIO_entry_c {
     /* 0x20C4 */ daNpcCd2_HIO_WChild_c field_0x20c4[14];
 };
 
-extern daNpcCd2_HIO_c l_Cd2_HIO;
+DUSK_GAME_EXTERN daNpcCd2_HIO_c l_Cd2_HIO;
 
 inline s16 Cd2_HIO_atnOfs(int param_1) {
     s16 rv;
@@ -269,7 +269,7 @@ public:
     J3DAnmTexPattern* getTexAnmP(int);
     virtual ~daNpcCd2_c() {}
 
-    static dCcD_SrcCyl const m_cylDat;
+    static DUSK_GAME_DATA dCcD_SrcCyl const m_cylDat;
 
     /* 0x56C */ request_of_phase_process_class mPhase1;
     /* 0x574 */ request_of_phase_process_class mPhase2;
diff --git a/include/d/actor/d_a_npc_cdn3.h b/include/d/actor/d_a_npc_cdn3.h
index 84a98ebd74..f3b920c81c 100644
--- a/include/d/actor/d_a_npc_cdn3.h
+++ b/include/d/actor/d_a_npc_cdn3.h
@@ -334,52 +334,52 @@ public:
         actionFunc mExecFn;
     };
 
-    static const ActionPair ActionTable[8];
-    static seqFunc* m_funcTbl[44];
-    static seqFunc m_seq00_funcTbl[2];
-    static seqFunc m_seq01_funcTbl[2];
-    static seqFunc m_seq02_funcTbl[2];
-    static seqFunc m_seq03_funcTbl[2];
-    static seqFunc m_seq04_funcTbl[2];
-    static seqFunc m_seq05_funcTbl[4];
-    static seqFunc m_seq06_funcTbl[4];
-    static seqFunc m_seq07_funcTbl[2];
-    static seqFunc m_seq08_funcTbl[7];
-    static seqFunc m_seq09_funcTbl[2];
-    static seqFunc m_seq10_funcTbl[2];
-    static seqFunc m_seq11_funcTbl[6];
-    static seqFunc m_seq12_funcTbl[2];
-    static seqFunc m_seq13_funcTbl[6];
-    static seqFunc m_seq14_funcTbl[2];
-    static seqFunc m_seq15_funcTbl[2];
-    static seqFunc m_seq16_funcTbl[7];
-    static seqFunc m_seq17_funcTbl[2];
-    static seqFunc m_seq18_funcTbl[2];
-    static seqFunc m_seq19_funcTbl[7];
-    static seqFunc m_seq20_funcTbl[2];
-    static seqFunc m_seq21_funcTbl[2];
-    static seqFunc m_seq22_funcTbl[4];
-    static seqFunc m_seq23_funcTbl[7];
-    static seqFunc m_seq24_funcTbl[5];
-    static seqFunc m_seq25_funcTbl[7];
-    static seqFunc m_seq26_funcTbl[3];
-    static seqFunc m_seq27_funcTbl[2];
-    static seqFunc m_seq28_funcTbl[3];
-    static seqFunc m_seq29_funcTbl[3];
-    static seqFunc m_seq30_funcTbl[6];
-    static seqFunc m_seq31_funcTbl[6];
-    static seqFunc m_seq32_funcTbl[7];
-    static seqFunc m_seq33_funcTbl[7];
-    static seqFunc m_seq34_funcTbl[9];
-    static seqFunc m_seq35_funcTbl[2];
-    static seqFunc m_seq36_funcTbl[4];
-    static seqFunc m_seq37_funcTbl[2];
-    static seqFunc m_seq38_funcTbl[2];
-    static seqFunc m_seq39_funcTbl[2];
-    static seqFunc m_seq40_funcTbl[3];
-    static seqFunc m_seq41_funcTbl[2];
-    static seqFunc m_seq42_funcTbl[2];
-    static seqFunc m_seq43_funcTbl[3];
+    static DUSK_GAME_DATA const ActionPair ActionTable[8];
+    static DUSK_GAME_DATA seqFunc* m_funcTbl[44];
+    static DUSK_GAME_DATA seqFunc m_seq00_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq01_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq02_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq03_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq04_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq05_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq06_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq07_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq08_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq09_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq10_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq11_funcTbl[6];
+    static DUSK_GAME_DATA seqFunc m_seq12_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq13_funcTbl[6];
+    static DUSK_GAME_DATA seqFunc m_seq14_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq15_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq16_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq17_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq18_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq19_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq20_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq21_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq22_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq23_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq24_funcTbl[5];
+    static DUSK_GAME_DATA seqFunc m_seq25_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq26_funcTbl[3];
+    static DUSK_GAME_DATA seqFunc m_seq27_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq28_funcTbl[3];
+    static DUSK_GAME_DATA seqFunc m_seq29_funcTbl[3];
+    static DUSK_GAME_DATA seqFunc m_seq30_funcTbl[6];
+    static DUSK_GAME_DATA seqFunc m_seq31_funcTbl[6];
+    static DUSK_GAME_DATA seqFunc m_seq32_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq33_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq34_funcTbl[9];
+    static DUSK_GAME_DATA seqFunc m_seq35_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq36_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq37_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq38_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq39_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq40_funcTbl[3];
+    static DUSK_GAME_DATA seqFunc m_seq41_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq42_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq43_funcTbl[3];
 
     /* 0xAC8 */ J3DModel* field_0xac8;
     /* 0xACC */ J3DModel* field_0xacc;
diff --git a/include/d/actor/d_a_npc_chat.h b/include/d/actor/d_a_npc_chat.h
index a835a4c49d..88ddc9a8b3 100644
--- a/include/d/actor/d_a_npc_chat.h
+++ b/include/d/actor/d_a_npc_chat.h
@@ -11,7 +11,7 @@ class daNpcChat_Param_c {
 public:
     virtual ~daNpcChat_Param_c() {}
 
-    static daNpcChat_HIOParam const m;
+    static DUSK_GAME_DATA daNpcChat_HIOParam const m;
 };
 
 #if DEBUG
@@ -102,9 +102,8 @@ public:
     void setFear() { mFear = true; }
     void setTalkFlag() { mTalkFlag = true; }
 
-    static eventFunc DUSK_CONST mEvtSeqList[1];
+    static DUSK_GAME_DATA eventFunc DUSK_CONST mEvtSeqList[1];
 
-private:
     /* 0xB48 */ Z2CreatureCitizen mSound;
     /* 0xBEC */ u8 field_0xbec[0xbf0 - 0xbec];
     /* 0xBF0 */ J3DModel* mObjModel;
diff --git a/include/d/actor/d_a_npc_chin.h b/include/d/actor/d_a_npc_chin.h
index e4bfdb6a61..1e87de4e9f 100644
--- a/include/d/actor/d_a_npc_chin.h
+++ b/include/d/actor/d_a_npc_chin.h
@@ -12,7 +12,7 @@ class daNpcChin_Param_c {
 public:
     virtual ~daNpcChin_Param_c() {}
 
-    static daNpcChin_HIOParam const m;
+    static DUSK_GAME_DATA daNpcChin_HIOParam const m;
 };
 
 #if DEBUG
@@ -183,7 +183,7 @@ public:
     inline void ForcibleTalk_Off() { field_0xe06 = 0; }
     inline u8 getForcibleTalk2() { return field_0xe06; }
 
-    static eventFunc mEvtSeqList[8];
+    static DUSK_GAME_DATA eventFunc mEvtSeqList[8];
 
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
diff --git a/include/d/actor/d_a_npc_clerka.h b/include/d/actor/d_a_npc_clerka.h
index 92236edb03..6479bae503 100644
--- a/include/d/actor/d_a_npc_clerka.h
+++ b/include/d/actor/d_a_npc_clerka.h
@@ -14,7 +14,7 @@ class daNpc_clerkA_Param_c {
 public:
     virtual ~daNpc_clerkA_Param_c() {}
 
-    static const daNpc_clerkA_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_clerkA_HIOParam m;
 };
 
 #if DEBUG
@@ -124,10 +124,9 @@ public:
 
     u8 getMaxNumItem() { return (fopAcM_GetParam(this) & 0xF000000) >> 24; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0x0F7C */ NPC_CLERKA_HIO_CLASS* mpHIO;
     /* 0x0F80 */ dCcD_Cyl mCyl;
     /* 0x10BC */ u8 mType;
diff --git a/include/d/actor/d_a_npc_clerkb.h b/include/d/actor/d_a_npc_clerkb.h
index 79e13f3a0e..9bc2a39a3a 100644
--- a/include/d/actor/d_a_npc_clerkb.h
+++ b/include/d/actor/d_a_npc_clerkb.h
@@ -15,7 +15,7 @@ class daNpc_clerkB_Param_c {
 public:
     virtual ~daNpc_clerkB_Param_c() {}
 
-    static const daNpc_clerkB_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_clerkB_HIOParam m;
 };
 
 #if DEBUG
@@ -137,10 +137,9 @@ public:
 
     u8 getMaxNumItem() { return (fopAcM_GetParam(this) & 0xF000000) >> 24; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0x0F7C */ mDoExt_bpkAnm mBpkAnm2;
     /* 0x0F7C */ NPC_CLERKB_HIO_CLASS* mpHIO;
     /* 0x0F98 */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_npc_clerkt.h b/include/d/actor/d_a_npc_clerkt.h
index e21f000c32..a476f83449 100644
--- a/include/d/actor/d_a_npc_clerkt.h
+++ b/include/d/actor/d_a_npc_clerkt.h
@@ -12,7 +12,7 @@ class daNpcClerkt_Param_c {
 public:
     virtual ~daNpcClerkt_Param_c() {}
 
-    static const daNpcClerkt_HIOParam m;
+    static DUSK_GAME_DATA const daNpcClerkt_HIOParam m;
 };
 
 #if DEBUG
@@ -125,10 +125,9 @@ public:
         }
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0x0F7C */ NPC_CLERKT_HIO_CLASS* mpHIO;
     /* 0x0F80 */ dCcD_Cyl mCyl;
     /* 0x10BC */ u8 mType;
diff --git a/include/d/actor/d_a_npc_coach.h b/include/d/actor/d_a_npc_coach.h
index 3917d6f11c..e0ecd63fc2 100644
--- a/include/d/actor/d_a_npc_coach.h
+++ b/include/d/actor/d_a_npc_coach.h
@@ -295,9 +295,8 @@ public:
 
     const daNpcCoach_Attr_c& attr() const { return M_attr; }
 
-    static daNpcCoach_Attr_c const M_attr;
+    static DUSK_GAME_DATA daNpcCoach_Attr_c const M_attr;
     static u16 const ParticleName[10];
-private:
     /* 0x0568 */ daNpcChHorse_c mChHorse;
     /* 0x0E7C */ daNpcChHarness_c mChHarness;
     /* 0x15D0 */ daNpcChCoach_c mChCoach;
diff --git a/include/d/actor/d_a_npc_doc.h b/include/d/actor/d_a_npc_doc.h
index 7d9c6dabfe..191a2e5bf2 100644
--- a/include/d/actor/d_a_npc_doc.h
+++ b/include/d/actor/d_a_npc_doc.h
@@ -12,7 +12,7 @@ class daNpc_Doc_Param_c {
 public:
     virtual ~daNpc_Doc_Param_c() {}
 
-    static const daNpc_Doc_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Doc_HIOParam m;
 };
 
 #if DEBUG
@@ -133,10 +133,9 @@ public:
         return (fopAcM_GetParam(this) & 0xFF00) >> 8;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_DOC_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_doorboy.h b/include/d/actor/d_a_npc_doorboy.h
index 7d6cb47436..3fd6ef1ce8 100644
--- a/include/d/actor/d_a_npc_doorboy.h
+++ b/include/d/actor/d_a_npc_doorboy.h
@@ -12,7 +12,7 @@ class daNpcDoorBoy_Param_c {
 public:
     virtual ~daNpcDoorBoy_Param_c() {}
 
-    static daNpcDoorBoy_HIOParam const m;
+    static DUSK_GAME_DATA daNpcDoorBoy_HIOParam const m;
 };
 
 #if DEBUG
@@ -78,9 +78,8 @@ public:
     inline int getTimeHour();
     inline bool isDummyTalk();
 
-    static EventFn DUSK_CONST mEvtSeqList[1];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[1];
 
-private:
     /* 0xB48 */ Z2CreatureCitizen mSound;
     /* 0xBEC */ u8 field_0xbec[0xbf0 - 0xbec];
     /* 0xBF0 */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_drainSol.h b/include/d/actor/d_a_npc_drainSol.h
index d61fb243b3..7a197a8a1f 100644
--- a/include/d/actor/d_a_npc_drainSol.h
+++ b/include/d/actor/d_a_npc_drainSol.h
@@ -11,7 +11,7 @@ class daNpcDrSol_Param_c {
 public:
     virtual ~daNpcDrSol_Param_c() {}
 
-    static const daNpcDrSol_HIOParam m;
+    static DUSK_GAME_DATA const daNpcDrSol_HIOParam m;
 };
 
 #if DEBUG
diff --git a/include/d/actor/d_a_npc_fairy.h b/include/d/actor/d_a_npc_fairy.h
index d5c1d2fa0e..ff2df4260b 100644
--- a/include/d/actor/d_a_npc_fairy.h
+++ b/include/d/actor/d_a_npc_fairy.h
@@ -94,7 +94,7 @@ class daNpc_Fairy_Param_c {
 public:
     virtual ~daNpc_Fairy_Param_c() {}
 
-    static daNpc_Fairy_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Fairy_HIOParam const m;
 };
 
 #if DEBUG
@@ -294,9 +294,8 @@ public:
     u8 getSceneNo1() { return (fopAcM_GetParam(this) >> 8) & 0xFF; }
     u8 getSceneNo2() { return (fopAcM_GetParam(this) >> 16) & 0xFF; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[18];
-    static cutFunc DUSK_CONST mCutList[18];
-private:
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[18];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[18];
     /* 0x0E40 */ NPC_FAIRY_HIO_CLASS* mHIO;
     /* 0x0E44 */ dCcD_Cyl mCyl;
     /* 0x0F80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_fairy_seirei.h b/include/d/actor/d_a_npc_fairy_seirei.h
index 62b3cbcc6c..d47b2a17eb 100644
--- a/include/d/actor/d_a_npc_fairy_seirei.h
+++ b/include/d/actor/d_a_npc_fairy_seirei.h
@@ -13,7 +13,7 @@ class daNpc_FairySeirei_Param_c {
 public:
     virtual ~daNpc_FairySeirei_Param_c() {}
 
-    static daNpc_FairySeirei_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_FairySeirei_HIOParam const m;
 };
 
 #if DEBUG
@@ -90,10 +90,9 @@ public:
 
     int getSeneNo() { return (fopAcM_GetParam(this) >> 8) & 0xFF; }
 
-    static DUSK_CONST char* mCutNameList[1];
-    static DUSK_CONST cutFunc mCutList[1];
+    static DUSK_GAME_DATA DUSK_CONST char* mCutNameList[1];
+    static DUSK_GAME_DATA DUSK_CONST cutFunc mCutList[1];
 
-private:
     /* 0xE40 */ NPC_FAIRY_SEIREI_HIO_CLASS* mpHIO;
     /* 0xE44 */ u8 mType;
     /* 0xE48 */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_npc_gnd.h b/include/d/actor/d_a_npc_gnd.h
index d76fae5d61..cb0289055e 100644
--- a/include/d/actor/d_a_npc_gnd.h
+++ b/include/d/actor/d_a_npc_gnd.h
@@ -11,7 +11,7 @@ class daNpc_Gnd_Param_c {
 public:
     virtual ~daNpc_Gnd_Param_c() {}
 
-    static const daNpc_Gnd_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Gnd_HIOParam m;
 };
 
 #if DEBUG
@@ -96,10 +96,9 @@ public:
     s32 getNeckJointNo() { return 3; }
     s32 getBackboneJointNo() { return 1; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_GND_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl1;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_gra.h b/include/d/actor/d_a_npc_gra.h
index 117aa9ade0..f16b445195 100644
--- a/include/d/actor/d_a_npc_gra.h
+++ b/include/d/actor/d_a_npc_gra.h
@@ -21,7 +21,7 @@ class daNpc_grA_Param_c {
 public:
     virtual ~daNpc_grA_Param_c() {}
 
-    static daNpc_grA_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_grA_HIOParam const m;
 };
 
 #if DEBUG
@@ -138,11 +138,10 @@ public:
     void addCarryNum() { field_0x1692++; }
     u8 getPathNoFromParam() { return home.angle.z; }
     void setGateWalk() { field_0x14D0 = 1; }
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[12];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[12];
     typedef BOOL (daNpc_grA_c::*cut_type)(int);
-    static cut_type DUSK_CONST mEvtCutList[];
+    static DUSK_GAME_DATA cut_type DUSK_CONST mEvtCutList[];
 
-private:
     typedef BOOL (daNpc_grA_c::*daNpc_grA_c_Action)(void*);
     
     /* 0x0B48 */ Z2Creature mCreature;
diff --git a/include/d/actor/d_a_npc_grc.h b/include/d/actor/d_a_npc_grc.h
index 072a4f9fd2..53a483b51d 100644
--- a/include/d/actor/d_a_npc_grc.h
+++ b/include/d/actor/d_a_npc_grc.h
@@ -12,7 +12,7 @@ class daNpc_grC_Param_c {
 public:
     virtual ~daNpc_grC_Param_c() {}
 
-    static daNpc_grC_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_grC_HIOParam const m;
 };
 
 #if DEBUG
@@ -89,10 +89,9 @@ public:
     void setPrtcl();
     void adjustShapeAngle() {}
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList;
-    static EventFn DUSK_CONST mEvtCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList;
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtCutList[1];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ int field_0xbd8;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_grd.h b/include/d/actor/d_a_npc_grd.h
index e8a9e19baf..64afa3ef2c 100644
--- a/include/d/actor/d_a_npc_grd.h
+++ b/include/d/actor/d_a_npc_grd.h
@@ -11,7 +11,7 @@ class daNpc_Grd_Param_c {
 public:
     virtual ~daNpc_Grd_Param_c() {}
 
-    static daNpc_Grd_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Grd_HIOParam const m;
 };
 
 #if DEBUG
@@ -81,10 +81,9 @@ public:
     BOOL ECut_nodToGrz(int);
     void adjustShapeAngle() {}
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
-    static cutFunc DUSK_CONST mEvtCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[2];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_grm.h b/include/d/actor/d_a_npc_grm.h
index addd5485be..c820eabbc3 100644
--- a/include/d/actor/d_a_npc_grm.h
+++ b/include/d/actor/d_a_npc_grm.h
@@ -12,7 +12,7 @@ class daNpc_grM_Param_c {
 public:
     virtual ~daNpc_grM_Param_c() {}
 
-    static daNpc_grM_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_grM_HIOParam const m;
 };
 
 #if DEBUG
@@ -131,10 +131,9 @@ public:
     BOOL checkChangeJoint(int param_0) { return param_0 == JNT_HEAD; }
     BOOL checkRemoveJoint(int param_0) { return param_0 == JNT_MOUTH; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0x0F7C */ NPC_GRM_HIO_CLASS* mpHIO;
     /* 0x0F80 */ dCcD_Cyl mCyl;
     /* 0x10BC */ u8 mType;
diff --git a/include/d/actor/d_a_npc_grmc.h b/include/d/actor/d_a_npc_grmc.h
index 4d1752c266..1d87c39a4d 100644
--- a/include/d/actor/d_a_npc_grmc.h
+++ b/include/d/actor/d_a_npc_grmc.h
@@ -38,7 +38,7 @@ class daNpc_grMC_Param_c {
 public:
     virtual ~daNpc_grMC_Param_c() {}
 
-    static daNpc_grMC_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_grMC_HIOParam const m;
 };
 
 class daNpc_grMC_c : public dShopSystem_c {
@@ -124,10 +124,9 @@ public:
     BOOL checkRemoveJoint(int param_1) { return param_1 == JNT_MOUTH; }
     u16 getEyeballMaterialNo() { return 1; };
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0x0F7C */ NPC_GRMC_HIO_CLASS* mpHIO;
     /* 0x0F80 */ dCcD_Cyl mCyl;
     /* 0x10BC */ u8 mType;
diff --git a/include/d/actor/d_a_npc_gro.h b/include/d/actor/d_a_npc_gro.h
index 0881270516..8bc6c8c93e 100644
--- a/include/d/actor/d_a_npc_gro.h
+++ b/include/d/actor/d_a_npc_gro.h
@@ -20,7 +20,7 @@ class daNpc_grO_Param_c {
 public:
     virtual ~daNpc_grO_Param_c() {}
 
-    static daNpc_grO_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_grO_HIOParam const m;
 };
 
 #if DEBUG
@@ -85,10 +85,9 @@ public:
     int test(void*);
     void adjustShapeAngle() {}
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[3];
-    static cutFunc DUSK_CONST mEvtCutList[3];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[3];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[3];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ J3DModel* mpOtherModel[1];
     /* 0xBDC */ daNpcF_MatAnm_c* mpMatAnm;
diff --git a/include/d/actor/d_a_npc_grr.h b/include/d/actor/d_a_npc_grr.h
index 280df27a48..4caf927d75 100644
--- a/include/d/actor/d_a_npc_grr.h
+++ b/include/d/actor/d_a_npc_grr.h
@@ -11,7 +11,7 @@ class daNpc_grR_Param_c {
 public:
     virtual ~daNpc_grR_Param_c() {}
 
-    static daNpc_grR_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_grR_HIOParam const m;
 };
 
 #if DEBUG
@@ -83,10 +83,9 @@ public:
     int test(void*);
     void adjustShapeAngle() {}
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList;
-    static cutFunc DUSK_CONST mEvtCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[1];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_grs.h b/include/d/actor/d_a_npc_grs.h
index d08b4ec008..9c1ac788dc 100644
--- a/include/d/actor/d_a_npc_grs.h
+++ b/include/d/actor/d_a_npc_grs.h
@@ -11,7 +11,7 @@ class daNpc_grS_Param_c {
 public:
     virtual ~daNpc_grS_Param_c() {}
 
-    static const daNpc_grS_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_grS_HIOParam m;
 };
 
 #if DEBUG
@@ -84,10 +84,9 @@ public:
     void setPrtcl();
     void adjustShapeAngle() {}
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
-    static cutFunc DUSK_CONST mEvtCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[2];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_npc_grz.h b/include/d/actor/d_a_npc_grz.h
index 555b1f09e2..249720276f 100644
--- a/include/d/actor/d_a_npc_grz.h
+++ b/include/d/actor/d_a_npc_grz.h
@@ -28,7 +28,7 @@ class daNpc_Grz_Param_c {
 public:
     virtual ~daNpc_Grz_Param_c() {}
 
-    static daNpc_Grz_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Grz_HIOParam const m;
 };
 
 #if DEBUG
@@ -116,10 +116,9 @@ public:
 
     u8 getPathNoFromParam() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[7];
-    static cutFunc DUSK_CONST mEvtCutList[7];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[7];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[7];
 
-private:
     /* 0x0B48 */ Z2Creature mSound;
     /* 0x0BD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0x0BDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_guard.h b/include/d/actor/d_a_npc_guard.h
index bae98e223c..59a6719c9d 100644
--- a/include/d/actor/d_a_npc_guard.h
+++ b/include/d/actor/d_a_npc_guard.h
@@ -60,9 +60,8 @@ public:
 
     u32 getPathID() { return fopAcM_GetParam(this) >> 0x10 & 0xFF; }
 
-    static actionFunc ActionTable[7][2];
+    static DUSK_GAME_DATA actionFunc ActionTable[7][2];
 
-private:
     /* 0xAC8 */ J3DModel* mpModel;
     /* 0xACC */ J3DModel* mpModel2;
     /* 0xAD0 */ J3DAnmTransformKey* mpAnmKey;
diff --git a/include/d/actor/d_a_npc_gwolf.h b/include/d/actor/d_a_npc_gwolf.h
index e9c37a38bb..f7f4bc5a8e 100644
--- a/include/d/actor/d_a_npc_gwolf.h
+++ b/include/d/actor/d_a_npc_gwolf.h
@@ -19,7 +19,7 @@ class daNpc_GWolf_Param_c {
 public:
     virtual ~daNpc_GWolf_Param_c() {}
 
-    static daNpc_GWolf_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_GWolf_HIOParam const m;
 };
 
 #if DEBUG
@@ -104,10 +104,9 @@ public:
     void setHowlingEndFlag() { field_0xe1c = 2; }
     void setHowlingFlag() { field_0xe1c = 1; }
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[5];
-    static cutFunc DUSK_CONST mEvtCutList[5];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[5];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[5];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_hanjo.h b/include/d/actor/d_a_npc_hanjo.h
index 6e912cb638..76d354b743 100644
--- a/include/d/actor/d_a_npc_hanjo.h
+++ b/include/d/actor/d_a_npc_hanjo.h
@@ -23,7 +23,7 @@ class daNpc_Hanjo_Param_c {
 public:
     virtual ~daNpc_Hanjo_Param_c() {}
 
-    static const daNpc_Hanjo_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Hanjo_HIOParam m;
 };
 
 #if DEBUG
@@ -217,11 +217,10 @@ public:
 
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xff00) >> 8; }
 
-    static dCcD_SrcGObjInf const mStoneCcDObjInfo;
-    static char DUSK_CONST* DUSK_CONST mCutNameList[6];
-    static cutFunc DUSK_CONST mCutList[6];
-    static dCcD_SrcSph DUSK_CONST mStoneCcDSph;
-private:
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mStoneCcDObjInfo;
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[6];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[6];
+    static DUSK_GAME_DATA dCcD_SrcSph DUSK_CONST mStoneCcDSph;
     /* 0x0E40 */ NPC_HANJO_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mModel1;
     /* 0x0E48 */ J3DModel* mModel2;
diff --git a/include/d/actor/d_a_npc_henna0.h b/include/d/actor/d_a_npc_henna0.h
index 112904d144..63da974cde 100644
--- a/include/d/actor/d_a_npc_henna0.h
+++ b/include/d/actor/d_a_npc_henna0.h
@@ -12,7 +12,7 @@
  *
  */
 class d_a_npc_henna0 : public fopAc_ac_c {
-    private:
+    public:
         /* 0x568 */ u8 field_0x568[0x828 - 0x568];
 };
 
diff --git a/include/d/actor/d_a_npc_hoz.h b/include/d/actor/d_a_npc_hoz.h
index 72ec648696..57a2169c78 100644
--- a/include/d/actor/d_a_npc_hoz.h
+++ b/include/d/actor/d_a_npc_hoz.h
@@ -13,7 +13,7 @@ class daNpc_Hoz_Param_c {
 public:
     virtual ~daNpc_Hoz_Param_c() {}
 
-    static const daNpc_Hoz_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Hoz_HIOParam m;
 };
 
 #if DEBUG
@@ -125,10 +125,9 @@ public:
     bool getGameStartFlag() { return mGameStartFlag; }
     void setPotBreakFlag() { mPotBreakFlag = true; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[8];
-    static cutFunc DUSK_CONST mCutList[];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[8];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[];
 
-private:
     /* 0xE40 */ NPC_HOZ_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_impal.h b/include/d/actor/d_a_npc_impal.h
index 7b8234717a..f6753be0e2 100644
--- a/include/d/actor/d_a_npc_impal.h
+++ b/include/d/actor/d_a_npc_impal.h
@@ -12,7 +12,7 @@ class daNpcImpal_Param_c {
 public:
     virtual ~daNpcImpal_Param_c() {}
 
-    static const daNpcImpal_HIOParam m;
+    static DUSK_GAME_DATA const daNpcImpal_HIOParam m;
 };
 
 #if DEBUG
@@ -121,9 +121,8 @@ public:
     inline void setLookMode(int i_lookMode);
     inline void deleteObstacle();
 
-    static EventFn mEvtSeqList[4];
+    static DUSK_GAME_DATA EventFn mEvtSeqList[4];
 
-private:
     /* 0xB48 */ Z2Creature mCreatureSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_ins.h b/include/d/actor/d_a_npc_ins.h
index 3f8b40a9a0..fd133a7a79 100644
--- a/include/d/actor/d_a_npc_ins.h
+++ b/include/d/actor/d_a_npc_ins.h
@@ -12,7 +12,7 @@ class daNpcIns_Param_c {
 public:
     virtual ~daNpcIns_Param_c() {}
 
-    static daNpcIns_HIOParam const m;
+    static DUSK_GAME_DATA daNpcIns_HIOParam const m;
 };
 
 #if DEBUG
@@ -119,9 +119,8 @@ public:
     inline void playExpression();
     BOOL chkAction(actionFunc action) { return action == mAction; }
 
-    static eventFunc mEvtSeqList[1];
+    static DUSK_GAME_DATA eventFunc mEvtSeqList[1];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ J3DModel* mpUmbrellaModel;
     /* 0xBDC */ J3DModel* mpKagoModel;
diff --git a/include/d/actor/d_a_npc_jagar.h b/include/d/actor/d_a_npc_jagar.h
index 3c4a4ac723..e933d28bf4 100644
--- a/include/d/actor/d_a_npc_jagar.h
+++ b/include/d/actor/d_a_npc_jagar.h
@@ -25,7 +25,7 @@ class daNpc_Jagar_Param_c {
 public:
     virtual ~daNpc_Jagar_Param_c() {}
 
-    static const daNpc_Jagar_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Jagar_HIOParam m;
 };
 
 #if DEBUG
@@ -223,9 +223,8 @@ public:
         return 0;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[7];
-    static cutFunc DUSK_CONST mCutList[7];
-private:
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[7];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[7];
     /* 0x0E40 */ NPC_JAGAR_HIO_CLASS* mpHIO;
     /* 0x0E44 */ dCcD_Cyl mCyl1;
     /* 0x0F80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_kakashi.h b/include/d/actor/d_a_npc_kakashi.h
index 7a5cca61f3..a21117376d 100644
--- a/include/d/actor/d_a_npc_kakashi.h
+++ b/include/d/actor/d_a_npc_kakashi.h
@@ -14,7 +14,7 @@ class daNpc_Kakashi_Param_c {
 public:
     virtual ~daNpc_Kakashi_Param_c() {}
 
-    static const daNpc_Kakashi_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Kakashi_HIOParam m;
 };
 
 #if DEBUG
@@ -113,10 +113,9 @@ public:
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
     u8 getBitSW2() { return (fopAcM_GetParam(this) & 0xFF0000) >> 16; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[4];
-    static int (daNpc_Kakashi_c::* DUSK_CONST mCutList[])(int);
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[4];
+    static DUSK_GAME_DATA int (daNpc_Kakashi_c::* DUSK_CONST mCutList[])(int);
 
-private:
     /* 0x0E40 */ NPC_KAKASHI_HIO_CLASS* mpHIO;
     /* 0x0E44 */ Z2SoundObjSimple mSound;
     /* 0x0E64 */ dCcD_Cyl mCcCyl;
diff --git a/include/d/actor/d_a_npc_kasi_hana.h b/include/d/actor/d_a_npc_kasi_hana.h
index e355ed8c55..302c3d84ab 100644
--- a/include/d/actor/d_a_npc_kasi_hana.h
+++ b/include/d/actor/d_a_npc_kasi_hana.h
@@ -25,7 +25,7 @@ class daNpcKasiHana_Param_c {
 public:
     virtual ~daNpcKasiHana_Param_c() {}
 
-    static daNpcKasiHana_HIOParam const m;
+    static DUSK_GAME_DATA daNpcKasiHana_HIOParam const m;
 };
 
 #if DEBUG
@@ -201,12 +201,11 @@ public:
     BOOL pl_front_check() { return actor_front_check(daPy_getPlayerActorClass()); }
     void setEscapePathDir() { if (pl_front_check()) mPath.reverse(); }
 
-    static EventFn mEvtSeqList[6];
-    static daTagEscape_c* mTargetTag;
-    static f32 mTargetTagDist;
-    static s16 mWolfAngle;
+    static DUSK_GAME_DATA EventFn mEvtSeqList[6];
+    static DUSK_GAME_DATA daTagEscape_c* mTargetTag;
+    static DUSK_GAME_DATA f32 mTargetTagDist;
+    static DUSK_GAME_DATA s16 mWolfAngle;
 
-private:
     /* 0x0B48 */ Z2CreatureCitizen mSound;
     /* 0x0BEC */ u8 field_0xbec[0xbf0 - 0xbec];
     /* 0x0BF0 */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_kasi_kyu.h b/include/d/actor/d_a_npc_kasi_kyu.h
index 8353648675..8ba34391c7 100644
--- a/include/d/actor/d_a_npc_kasi_kyu.h
+++ b/include/d/actor/d_a_npc_kasi_kyu.h
@@ -14,7 +14,7 @@ class daNpcKasiKyu_Param_c {
 public:
     virtual ~daNpcKasiKyu_Param_c() {}
 
-    static daNpcKasiKyu_HIOParam const m;
+    static DUSK_GAME_DATA daNpcKasiKyu_HIOParam const m;
 };
 
 #if DEBUG
@@ -120,12 +120,11 @@ public:
     void chgWeightLight() { mCcStts.SetWeight(0xD8); }
     BOOL pl_front_check() { return actor_front_check(daPy_getPlayerActorClass()); }
 
-    static EventFn DUSK_CONST mEvtSeqList[1];
-    static daTagEscape_c* mTargetTag;
-    static f32 mTargetTagDist;
-    static s16 mWolfAngle;
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[1];
+    static DUSK_GAME_DATA daTagEscape_c* mTargetTag;
+    static DUSK_GAME_DATA f32 mTargetTagDist;
+    static DUSK_GAME_DATA s16 mWolfAngle;
 
-private:
     /* 0x0B48 */ Z2CreatureCitizen mSound;
     /* 0x0BEC */ u8 field_0xbec[0xbf0 - 0xbec];
     /* 0x0BF0 */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_kasi_mich.h b/include/d/actor/d_a_npc_kasi_mich.h
index 460c5c191a..08361fe134 100644
--- a/include/d/actor/d_a_npc_kasi_mich.h
+++ b/include/d/actor/d_a_npc_kasi_mich.h
@@ -23,7 +23,7 @@ class daNpcKasiMich_Param_c {
 public:
     virtual ~daNpcKasiMich_Param_c() {}
 
-    static daNpcKasiMich_HIOParam const m;
+    static DUSK_GAME_DATA daNpcKasiMich_HIOParam const m;
 };
 
 #if DEBUG
@@ -121,12 +121,11 @@ public:
     void chgWeightLight() { mCcStts.SetWeight(0xD8); }
     BOOL pl_front_check() { return actor_front_check(daPy_getPlayerActorClass()); }
 
-    static EventFn DUSK_CONST mEvtSeqList[1];
-    static daTagEscape_c* mTargetTag;
-    static f32 mTargetTagDist;
-    static s16 mWolfAngle;
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[1];
+    static DUSK_GAME_DATA daTagEscape_c* mTargetTag;
+    static DUSK_GAME_DATA f32 mTargetTagDist;
+    static DUSK_GAME_DATA s16 mWolfAngle;
 
-private:
     /* 0x0B48 */ Z2CreatureCitizen mSound;
     /* 0x0BEC */ u8 field_0xbec[0xbf0 - 0xbec];
     /* 0x0BF0 */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_kdk.h b/include/d/actor/d_a_npc_kdk.h
index 6f701e33af..a647cc706d 100644
--- a/include/d/actor/d_a_npc_kdk.h
+++ b/include/d/actor/d_a_npc_kdk.h
@@ -12,7 +12,7 @@
  *
  */
 class daNpcKdk_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ u8 field_0x568[0xFA0 - 0x568];
 };
 
diff --git a/include/d/actor/d_a_npc_kkri.h b/include/d/actor/d_a_npc_kkri.h
index a5e74880a9..1265f6e27f 100644
--- a/include/d/actor/d_a_npc_kkri.h
+++ b/include/d/actor/d_a_npc_kkri.h
@@ -11,7 +11,7 @@ class daNpc_Kkri_Param_c {
 public:
     virtual ~daNpc_Kkri_Param_c() {}
 
-    static const daNpc_Kkri_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Kkri_HIOParam m;
 };
 
 #if DEBUG
@@ -118,10 +118,9 @@ public:
         return mpMorf[0]->getModel()->getAnmMtx(5);
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[3];
-    static int (daNpc_Kkri_c::* DUSK_CONST mCutList[])(int);
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[3];
+    static DUSK_GAME_DATA int (daNpc_Kkri_c::* DUSK_CONST mCutList[])(int);
 
-private:
     /* 0xE40 */ NPC_KKRI_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCcCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_kn.h b/include/d/actor/d_a_npc_kn.h
index 37b248fbe5..7df2cfa247 100644
--- a/include/d/actor/d_a_npc_kn.h
+++ b/include/d/actor/d_a_npc_kn.h
@@ -25,7 +25,7 @@ class daNpc_Kn_Param_c {
 public:
     virtual ~daNpc_Kn_Param_c() {}
 
-    static const daNpc_Kn_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Kn_HIOParam m;
 };
 
 #if DEBUG
@@ -412,16 +412,15 @@ public:
     virtual ~daNpc_Kn_c();
     virtual bool afterSetMotionAnm(int, int, f32, int);
     
-    static const dCcD_SrcGObjInf mCcDObjData;
-    static char DUSK_CONST* DUSK_CONST mCutNameList[21];
-    static cutFunc DUSK_CONST mCutList[21];
-    static dCcD_SrcCyl mCcDCyl;
-    static dCcD_SrcSph mCcDSph;
-    static s16 mSrchName;
-    static fopAc_ac_c* mFindActorPtrs[50];
-    static int mFindCount;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjData;
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[21];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[21];
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA s16 mSrchName;
+    static DUSK_GAME_DATA fopAc_ac_c* mFindActorPtrs[50];
+    static DUSK_GAME_DATA int mFindCount;
 
-private:
     /* 0x0E44 */ J3DModel* mpPodModel;
     /* 0x0E48 */ mDoExt_invisibleModel mInvisModel;
     /* 0x0E50 */ dKy_tevstr_c mTevStr;
diff --git a/include/d/actor/d_a_npc_knj.h b/include/d/actor/d_a_npc_knj.h
index 8aa5ff860a..7738d231b2 100644
--- a/include/d/actor/d_a_npc_knj.h
+++ b/include/d/actor/d_a_npc_knj.h
@@ -11,7 +11,7 @@ class daNpc_Knj_Param_c {
 public:
     virtual ~daNpc_Knj_Param_c() {}
 
-    static const daNpc_Knj_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Knj_HIOParam m;
 };
 
 #if DEBUG
@@ -80,10 +80,9 @@ public:
                    i_faceMotionStepNum, i_motionSequenceData, i_motionStepNum, i_evtData,
                    i_arcNames) {}
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_KNJ_HIO_CLASS* mpHIO;
     /* 0xE44 */ u8 mType;
     /* 0xE48 */ actionFunc mNextAction;
diff --git a/include/d/actor/d_a_npc_kolin.h b/include/d/actor/d_a_npc_kolin.h
index 819eb81078..860ae1b942 100644
--- a/include/d/actor/d_a_npc_kolin.h
+++ b/include/d/actor/d_a_npc_kolin.h
@@ -18,7 +18,7 @@ class daNpc_Kolin_Param_c {
 public:
     virtual ~daNpc_Kolin_Param_c() {}
 
-    static daNpc_Kolin_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Kolin_HIOParam const m;
 };
 
 #if DEBUG
@@ -120,8 +120,8 @@ public:
     virtual void changeAnm(int*, int*);
     virtual void changeBck(int*, int*);
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[11];
-    static cutFunc DUSK_CONST mCutList[11];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[11];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[11];
 
     u32 getFlowNodeNo() {
         u16 nodeNo = home.angle.x;
@@ -161,7 +161,6 @@ public:
         return 0;
     }
 
-private:
     /* 0x0E40 */ NPC_KOLIN_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mpClothModel;
     /* 0x0E48 */ dCcD_Cyl field_0xe48;
diff --git a/include/d/actor/d_a_npc_kolinb.h b/include/d/actor/d_a_npc_kolinb.h
index b3858a908e..4655234347 100644
--- a/include/d/actor/d_a_npc_kolinb.h
+++ b/include/d/actor/d_a_npc_kolinb.h
@@ -12,7 +12,7 @@ class daNpc_Kolinb_Param_c {
 public:
     virtual ~daNpc_Kolinb_Param_c() {}
 
-    static daNpc_Kolinb_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Kolinb_HIOParam const m;
 };
 
 #if DEBUG
@@ -150,8 +150,8 @@ public:
     s32 getBackboneJointNo() { return mType == 2 ? ZRCB_JNT_BACKBONE1 : KOLINB_JNT_BACKBONE1; }
     s32 getNeckJointNo() { return mType == 2 ? ZRCB_JNT_NECK : KOLINB_JNT_NECK; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[7];
-    static cutFunc DUSK_CONST mCutList[7];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[7];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[7];
 
     u32 getFlowNodeNo() {
         u16 nodeNo = home.angle.x;
@@ -166,7 +166,6 @@ public:
 
     u32 getModelType() { return fopAcM_GetParam(this) >> 28; }
 
-private:
     /* 0xE40 */ NPC_KOLINB_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl field_0xe44;
     /* 0xF80 */ Mtx mMtx;
diff --git a/include/d/actor/d_a_npc_kyury.h b/include/d/actor/d_a_npc_kyury.h
index 62ba0433cf..7322dfd905 100644
--- a/include/d/actor/d_a_npc_kyury.h
+++ b/include/d/actor/d_a_npc_kyury.h
@@ -11,7 +11,7 @@ class daNpc_Kyury_Param_c {
 public:
     virtual ~daNpc_Kyury_Param_c() {}
 
-    static const daNpc_Kyury_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Kyury_HIOParam m;
 };
 
 #if DEBUG
@@ -123,10 +123,9 @@ public:
         return nodeNo;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0xE40 */ NPC_KYURY_HIO_CLASS* mpHIO;
     /* 0xE44 */ J3DModel* mpModel[2];
     /* 0xE4C */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_npc_len.h b/include/d/actor/d_a_npc_len.h
index da5a0e0777..b22a0059e0 100644
--- a/include/d/actor/d_a_npc_len.h
+++ b/include/d/actor/d_a_npc_len.h
@@ -14,7 +14,7 @@ class daNpc_Len_Param_c {
 public:
     virtual ~daNpc_Len_Param_c() {}
 
-    static const daNpc_Len_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Len_HIOParam m;
 };
 
 #if DEBUG
@@ -100,8 +100,8 @@ public:
     s32 getFootRJointNo() { return 32; }
     BOOL chkXYItems() { return TRUE; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[4];
-    static cutFunc DUSK_CONST mCutList[4];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[4];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[4];
 
     int getFlowNodeNo() {
         u16 nodeNo = home.angle.x;
@@ -113,7 +113,6 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xff0000) >> 16; }
 
-private:
     /* 0xE40 */ NPC_LEN_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_lud.h b/include/d/actor/d_a_npc_lud.h
index b84e6aafac..a2be5fa65d 100644
--- a/include/d/actor/d_a_npc_lud.h
+++ b/include/d/actor/d_a_npc_lud.h
@@ -12,7 +12,7 @@ class daNpc_Lud_Param_c {
 public:
     virtual ~daNpc_Lud_Param_c() {}
 
-    static const daNpc_Lud_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Lud_HIOParam m;
 };
 
 #if DEBUG
@@ -111,10 +111,9 @@ public:
     }
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xff0000) >> 16; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[8];
-    static cutFunc DUSK_CONST mCutList[8];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[8];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[8];
 
-private:
     /* 0xE40 */ mDoExt_McaMorfSO* mpBowlMorf;
     /* 0xE44 */ NPC_LUD_HIO_CLASS* mpHIO;
     /* 0xE48 */ J3DModel* mpModel[2];
diff --git a/include/d/actor/d_a_npc_maro.h b/include/d/actor/d_a_npc_maro.h
index b8ec85b9fb..8acd11e43c 100644
--- a/include/d/actor/d_a_npc_maro.h
+++ b/include/d/actor/d_a_npc_maro.h
@@ -14,7 +14,7 @@ class daNpc_Maro_Param_c {
 public:
     virtual ~daNpc_Maro_Param_c() {}
 
-    static const daNpc_Maro_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Maro_HIOParam m;
 };
 
 #if DEBUG
@@ -167,8 +167,8 @@ public:
     void startChoccai() { field_0x1134 = 1; }
     void endChoccai() { field_0x1134 = 0; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[17];
-    static cutFunc DUSK_CONST mCutList[17];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[17];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[17];
 
     u8 getGroupId() {
         return (fopAcM_GetParam(this) & 0xF0000000) >> 28;
@@ -187,7 +187,6 @@ public:
         return (fopAcM_GetParam(this) & 0xF000000) >> 24;
     }
 
-private:
     /* 0x0F7C */ NPC_MARO_HIO_CLASS* mpHIO;
     /* 0x0F80 */ dCcD_Cyl mCyl1;
     /* 0x10BC */ int field_0x10bc;
diff --git a/include/d/actor/d_a_npc_midp.h b/include/d/actor/d_a_npc_midp.h
index 810f9eca45..3021051d77 100644
--- a/include/d/actor/d_a_npc_midp.h
+++ b/include/d/actor/d_a_npc_midp.h
@@ -20,7 +20,7 @@ class daNpc_midP_Param_c {
 public:
     virtual ~daNpc_midP_Param_c() {}
 
-    static const daNpc_midP_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_midP_HIOParam m;
 };
 
 #if DEBUG
@@ -148,10 +148,9 @@ public:
         return nodeNo;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_MIDP_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_moi.h b/include/d/actor/d_a_npc_moi.h
index eb00654fd9..94e1ef8861 100644
--- a/include/d/actor/d_a_npc_moi.h
+++ b/include/d/actor/d_a_npc_moi.h
@@ -26,7 +26,7 @@ class daNpc_Moi_Param_c {
 public:
     virtual ~daNpc_Moi_Param_c() {}
 
-    static const daNpc_Moi_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Moi_HIOParam m;
 };
 
 #if DEBUG
@@ -158,10 +158,9 @@ public:
     bool chkSFight() { return field_0x166b == 1; }
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xff00) >> 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[5];
-    static cutFunc DUSK_CONST mCutList[5];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[5];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[5];
 
-private:
     /* 0x0E40 */ NPC_MOI_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mpModel[6];
     /* 0x0E5C */ dCcD_Cyl mCyl[4];
diff --git a/include/d/actor/d_a_npc_moir.h b/include/d/actor/d_a_npc_moir.h
index 0cc8be336a..f217ab7698 100644
--- a/include/d/actor/d_a_npc_moir.h
+++ b/include/d/actor/d_a_npc_moir.h
@@ -23,7 +23,7 @@ class daNpcMoiR_Param_c {
 public:
     virtual ~daNpcMoiR_Param_c() {}
 
-    static daNpcMoiR_HIOParam const m;
+    static DUSK_GAME_DATA daNpcMoiR_HIOParam const m;
 };
 
 #if DEBUG
@@ -212,9 +212,8 @@ public:
     inline void setLookMode(int i_lookMode);
     inline void searchActors();
 
-    static EventFn mEvtSeqList[4];
+    static DUSK_GAME_DATA EventFn mEvtSeqList[4];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ J3DModel* mpHeadgearModel;
     /* 0xBDC */ daNpcF_MatAnm_c* mpMatAnm;
diff --git a/include/d/actor/d_a_npc_myna2.h b/include/d/actor/d_a_npc_myna2.h
index 4cb0356832..e2172eb4cd 100644
--- a/include/d/actor/d_a_npc_myna2.h
+++ b/include/d/actor/d_a_npc_myna2.h
@@ -13,7 +13,7 @@ class daNpc_myna2_Param_c {
 public:
     virtual ~daNpc_myna2_Param_c() {}
 
-    static const daNpc_myna2_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_myna2_HIOParam m;
 };
 
 #if DEBUG
@@ -87,8 +87,8 @@ public:
 
     int getType() { return mType; }
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[5];
-    static EventFn DUSK_CONST mEvtCutList[];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[5];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtCutList[];
 
     /* 0xB48 */ u8 field_0xB48[0xB4C - 0xB48];
     /* 0xB4C */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_pachi_besu.h b/include/d/actor/d_a_npc_pachi_besu.h
index be623faf38..2cc79d2364 100644
--- a/include/d/actor/d_a_npc_pachi_besu.h
+++ b/include/d/actor/d_a_npc_pachi_besu.h
@@ -11,7 +11,7 @@ class daNpc_Pachi_Besu_Param_c {
 public:
     virtual ~daNpc_Pachi_Besu_Param_c() {}
 
-    static daNpc_Pachi_Besu_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Pachi_Besu_HIOParam const m;
 };
 
 #if DEBUG
@@ -144,10 +144,9 @@ public:
     void setTagPos(cXyz const& i_pos) { mTagPos = i_pos; }
     void setLookPos(cXyz const& i_pos) { mLookPos = i_pos; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[11];
-    static cutFunc DUSK_CONST mCutList[11];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[11];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[11];
 
-private:
     /* 0xE40 */ NPC_PACHI_BESU_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_pachi_maro.h b/include/d/actor/d_a_npc_pachi_maro.h
index ffb33d1fbc..be398f85e0 100644
--- a/include/d/actor/d_a_npc_pachi_maro.h
+++ b/include/d/actor/d_a_npc_pachi_maro.h
@@ -21,7 +21,7 @@ class daNpc_Pachi_Maro_Param_c {
 public:
     virtual ~daNpc_Pachi_Maro_Param_c() {}
 
-    static daNpc_Pachi_Maro_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Pachi_Maro_HIOParam const m;
 };
 
 #if DEBUG
@@ -184,10 +184,9 @@ public:
     void setFMotion_Niramu_to_Besu() { mFMotion = 1; }
     void setFMotion_LookNone() { mFMotion = 2; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[11];
-    static cutFunc DUSK_CONST mCutList[11];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[11];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[11];
 
-private:
     /* 0xE40 */ NPC_PACHI_MARO_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_pachi_taro.h b/include/d/actor/d_a_npc_pachi_taro.h
index 9faee13c23..e424292f6c 100644
--- a/include/d/actor/d_a_npc_pachi_taro.h
+++ b/include/d/actor/d_a_npc_pachi_taro.h
@@ -20,7 +20,7 @@ class daNpc_Pachi_Taro_Param_c {
 public:
     virtual ~daNpc_Pachi_Taro_Param_c() {}
 
-    static daNpc_Pachi_Taro_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Pachi_Taro_HIOParam const m;
 };
 
 #if DEBUG
@@ -196,10 +196,9 @@ public:
     void setTagPos(cXyz const& i_pos) { mTagPos = i_pos; }
     void setLookPos(cXyz const& i_pos) { mLookPos = i_pos; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[11];
-    static cutFunc DUSK_CONST mCutList[11];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[11];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[11];
 
-private:
     /* 0x0E40 */ NPC_PACHI_TARO_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mpModels[2];
     /* 0x0E4C */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_npc_passer.h b/include/d/actor/d_a_npc_passer.h
index f6c05ae7a5..e166e635b9 100644
--- a/include/d/actor/d_a_npc_passer.h
+++ b/include/d/actor/d_a_npc_passer.h
@@ -92,38 +92,37 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) >> 16) & 0xFF; }
     BOOL isStop() { return TRUE; }
 
-    static actionFunc ActionTable[5][2];
-    static seqFunc* m_funcTbl[28];
-    static seqFunc m_seq00_funcTbl[2];
-    static seqFunc m_seq01_funcTbl[2];
-    static seqFunc m_seq02_funcTbl[2];
-    static seqFunc m_seq03_funcTbl[2];
-    static seqFunc m_seq04_funcTbl[2];
-    static seqFunc m_seq05_funcTbl[4];
-    static seqFunc m_seq06_funcTbl[4];
-    static seqFunc m_seq07_funcTbl[2];
-    static seqFunc m_seq08_funcTbl[7];
-    static seqFunc m_seq09_funcTbl[2];
-    static seqFunc m_seq10_funcTbl[2];
-    static seqFunc m_seq11_funcTbl[6];
-    static seqFunc m_seq12_funcTbl[2];
-    static seqFunc m_seq13_funcTbl[6];
-    static seqFunc m_seq14_funcTbl[2];
-    static seqFunc m_seq15_funcTbl[2];
-    static seqFunc m_seq16_funcTbl[7];
-    static seqFunc m_seq17_funcTbl[2];
-    static seqFunc m_seq18_funcTbl[2];
-    static seqFunc m_seq19_funcTbl[7];
-    static seqFunc m_seq20_funcTbl[2];
-    static seqFunc m_seq21_funcTbl[2];
-    static seqFunc m_seq22_funcTbl[4];
-    static seqFunc m_seq23_funcTbl[7];
-    static seqFunc m_seq24_funcTbl[5];
-    static seqFunc m_seq25_funcTbl[7];
-    static seqFunc m_seq26_funcTbl[3];
-    static seqFunc m_seq27_funcTbl[1];
+    static DUSK_GAME_DATA actionFunc ActionTable[5][2];
+    static DUSK_GAME_DATA seqFunc* m_funcTbl[28];
+    static DUSK_GAME_DATA seqFunc m_seq00_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq01_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq02_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq03_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq04_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq05_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq06_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq07_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq08_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq09_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq10_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq11_funcTbl[6];
+    static DUSK_GAME_DATA seqFunc m_seq12_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq13_funcTbl[6];
+    static DUSK_GAME_DATA seqFunc m_seq14_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq15_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq16_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq17_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq18_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq19_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq20_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq21_funcTbl[2];
+    static DUSK_GAME_DATA seqFunc m_seq22_funcTbl[4];
+    static DUSK_GAME_DATA seqFunc m_seq23_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq24_funcTbl[5];
+    static DUSK_GAME_DATA seqFunc m_seq25_funcTbl[7];
+    static DUSK_GAME_DATA seqFunc m_seq26_funcTbl[3];
+    static DUSK_GAME_DATA seqFunc m_seq27_funcTbl[1];
 
-private:
     /* 0xAC8 */ J3DModel* mpModel;
     /* 0xACC */ PathTrace_c m_path;
     /* 0xAF4 */ daNpcPasser_c::actionFunc* mAction;
diff --git a/include/d/actor/d_a_npc_passer2.h b/include/d/actor/d_a_npc_passer2.h
index 529b99fc35..148a3b2981 100644
--- a/include/d/actor/d_a_npc_passer2.h
+++ b/include/d/actor/d_a_npc_passer2.h
@@ -51,9 +51,8 @@ public:
     u8 getRunMotionType() { return fopAcM_GetParam(this) >> 30; }
     u8 getPathID() { return (fopAcM_GetParam(this) >> 16) & 0xFF; }
 
-    static actionFunc ActionTable[1][2];
+    static DUSK_GAME_DATA actionFunc ActionTable[1][2];
 
-private:
     /* 0x9EC */ J3DModel* mpModel;
     /* 0x9F0 */ PathTrace_c m_path;
     /* 0xA18 */ actionFunc* mAction;
diff --git a/include/d/actor/d_a_npc_post.h b/include/d/actor/d_a_npc_post.h
index 5450dbfe68..ef44f7ee1e 100644
--- a/include/d/actor/d_a_npc_post.h
+++ b/include/d/actor/d_a_npc_post.h
@@ -22,7 +22,7 @@ class daNpc_Post_Param_c {
 public:
     virtual ~daNpc_Post_Param_c() {}
 
-    static daNpc_Post_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Post_HIOParam const m;
 };
 
 #if DEBUG
@@ -153,10 +153,9 @@ public:
 
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0x0E40 */ mDoExt_McaMorfSO* mpFlagModelMorf;
     /* 0x0E44 */ NPC_POST_HIO_CLASS* mHIO;
     /* 0x0E48 */ J3DModel* mpLetterModels[2];
diff --git a/include/d/actor/d_a_npc_pouya.h b/include/d/actor/d_a_npc_pouya.h
index c94f777d87..4af1d1ce68 100644
--- a/include/d/actor/d_a_npc_pouya.h
+++ b/include/d/actor/d_a_npc_pouya.h
@@ -11,7 +11,7 @@ class daNpc_Pouya_Param_c {
 public:
     virtual ~daNpc_Pouya_Param_c() {}
 
-    static const daNpc_Pouya_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Pouya_HIOParam m;
 };
 
 #if DEBUG
@@ -146,10 +146,9 @@ public:
 
     MtxP getHeadMtx() { return mpMorf[0]->getModel()->getAnmMtx(4); }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[3];
-    static cutFunc DUSK_CONST mCutList[3];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[3];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[3];
 
-private:
     /* 0xE40 */ NPC_POUYA_HIO_CLASS* mpHIO;
     /* 0xE44 */ J3DModel* mpModel[1];
     /* 0xE48 */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_npc_prayer.h b/include/d/actor/d_a_npc_prayer.h
index fd1afa2ddf..438bc784f9 100644
--- a/include/d/actor/d_a_npc_prayer.h
+++ b/include/d/actor/d_a_npc_prayer.h
@@ -11,7 +11,7 @@ class daNpcPray_Param_c {
 public:
     virtual ~daNpcPray_Param_c() {}
 
-    static const daNpcPray_HIOParam m;
+    static DUSK_GAME_DATA const daNpcPray_HIOParam m;
 };
 
 #if DEBUG
@@ -77,9 +77,8 @@ public:
 
     s16 getMessageNo() { return (fopAcM_GetParam(this) >> 8) & 0xFFFF; } 
 
-    static EvtSeq DUSK_CONST mEvtSeqList[];
+    static DUSK_GAME_DATA EvtSeq DUSK_CONST mEvtSeqList[];
 
-private:
     /* 0xB48 */ Z2CreatureCitizen mSound;
     /* 0xBEC */ u8 field_0xBEC[0xBF0 - 0xBEC];
     /* 0xBF0 */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_raca.h b/include/d/actor/d_a_npc_raca.h
index 985f370dbb..187ca700c7 100644
--- a/include/d/actor/d_a_npc_raca.h
+++ b/include/d/actor/d_a_npc_raca.h
@@ -20,7 +20,7 @@ class daNpc_Raca_Param_c {
 public:
     virtual ~daNpc_Raca_Param_c() {}
 
-    static daNpc_Raca_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Raca_HIOParam const m;
 };
 
 #if DEBUG
@@ -145,10 +145,9 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xFF0000) >> 16; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_RACA_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_rafrel.h b/include/d/actor/d_a_npc_rafrel.h
index ae804cf15a..0bb9e76194 100644
--- a/include/d/actor/d_a_npc_rafrel.h
+++ b/include/d/actor/d_a_npc_rafrel.h
@@ -22,7 +22,7 @@ class daNpcRafrel_Param_c {
 public:
     virtual ~daNpcRafrel_Param_c() {}
 
-    static const daNpcRafrel_HIOParam m;
+    static DUSK_GAME_DATA const daNpcRafrel_HIOParam m;
 };
 
 class daNpcRafrel_HIO_c : public mDoHIO_entry_c {
@@ -105,9 +105,8 @@ public:
 
     s16 getMessageNo() { return (fopAcM_GetParam(this) >> 8) & 0xFFFF; }
 
-    static int (daNpcRafrel_c::*mEvtSeqList[])(int);
+    static DUSK_GAME_DATA int (daNpcRafrel_c::*mEvtSeqList[])(int);
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ J3DModel* mpItemModel;
     /* 0xBDC */ daNpcF_MatAnm_c* mpMatAnm;
diff --git a/include/d/actor/d_a_npc_saru.h b/include/d/actor/d_a_npc_saru.h
index 05535786fe..dce1d7b4a3 100644
--- a/include/d/actor/d_a_npc_saru.h
+++ b/include/d/actor/d_a_npc_saru.h
@@ -21,7 +21,7 @@ class daNpc_Saru_Param_c {
 public:
     virtual ~daNpc_Saru_Param_c() {}
 
-    static const daNpc_Saru_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Saru_HIOParam m;
 };
 
 #if DEBUG
@@ -133,9 +133,8 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xff0000) >> 16; }
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xff00) >> 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[4];
-    static cutFunc DUSK_CONST mCutList[4];
-private:
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[4];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[4];
     /* 0xE40 */ NPC_SARU_HIO_CLASS* mpHIO;
     /* 0xE44 */ J3DModel* mpRoseModels[2];
     /* 0xE4C */ dCcD_Cyl field_0xe4c;
diff --git a/include/d/actor/d_a_npc_seib.h b/include/d/actor/d_a_npc_seib.h
index b7af300cee..855be4ac41 100644
--- a/include/d/actor/d_a_npc_seib.h
+++ b/include/d/actor/d_a_npc_seib.h
@@ -13,7 +13,7 @@ class daNpc_seiB_Param_c {
 public:
     virtual ~daNpc_seiB_Param_c() {};
 
-    static const daNpc_seiB_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_seiB_HIOParam m;
 };
 
 #if DEBUG
@@ -84,10 +84,9 @@ public:
                                 daNpcT_c(param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8)
                                 {}
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_SEIB_HIO_CLASS* mpHIO;
     /* 0xE44 */ u8 mType;
     /* 0xE48 */ actionFunc mActionFunc1;
diff --git a/include/d/actor/d_a_npc_seic.h b/include/d/actor/d_a_npc_seic.h
index bbdaf19431..609d38588b 100644
--- a/include/d/actor/d_a_npc_seic.h
+++ b/include/d/actor/d_a_npc_seic.h
@@ -22,7 +22,7 @@ class daNpc_seiC_Param_c {
 public:
     virtual ~daNpc_seiC_Param_c() {}
 
-    static const daNpc_seiC_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_seiC_HIOParam m;
 };
 
 #if DEBUG
@@ -87,10 +87,9 @@ public:
                                            i_faceMotionStepNum, i_motionSequenceData, i_motionStepNum, i_evtData,
                                            i_arcNames) {};
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_SEIC_HIO_CLASS* mpHIO;
     /* 0xE44 */ u8 mType;
     /* 0xE45 */ u8 field_0xe45[0xe48 - 0xe45];
diff --git a/include/d/actor/d_a_npc_seid.h b/include/d/actor/d_a_npc_seid.h
index f83d8a2909..91a1920598 100644
--- a/include/d/actor/d_a_npc_seid.h
+++ b/include/d/actor/d_a_npc_seid.h
@@ -22,7 +22,7 @@ class daNpc_seiD_Param_c {
 public:
     virtual ~daNpc_seiD_Param_c() {}
 
-    static const daNpc_seiD_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_seiD_HIOParam m;
 };
 
 #if DEBUG
@@ -86,10 +86,9 @@ public:
                                            i_faceMotionStepNum, i_motionSequenceData, i_motionStepNum, i_evtData,
                                            i_arcNames) {};
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_SEID_HIO_CLASS* mpHIO;
     /* 0xE44 */ u8 mType;
     /* 0xE48 */ actionFunc mAction;
diff --git a/include/d/actor/d_a_npc_seira.h b/include/d/actor/d_a_npc_seira.h
index 0528dd5c01..c4f2ef1a96 100644
--- a/include/d/actor/d_a_npc_seira.h
+++ b/include/d/actor/d_a_npc_seira.h
@@ -12,7 +12,7 @@ class daNpc_Seira_Param_c {
 public:
     virtual ~daNpc_Seira_Param_c() {}
 
-    static const daNpc_Seira_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Seira_HIOParam m;
 };
 
 #if DEBUG
@@ -114,10 +114,9 @@ public:
     BOOL checkChangeJoint(int val) { return val == 4; }
     BOOL checkRemoveJoint(int val) { return val == 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0x0F7C */ mDoExt_McaMorfSO* mpSeiraMorf;
     /* 0x0F80 */ NPC_SEIRA_HIO_CLASS* mpHIO;
     /* 0x0F80 */ dCcD_Cyl mCyl1;
diff --git a/include/d/actor/d_a_npc_seira2.h b/include/d/actor/d_a_npc_seira2.h
index b3157b2924..13aeb71e65 100644
--- a/include/d/actor/d_a_npc_seira2.h
+++ b/include/d/actor/d_a_npc_seira2.h
@@ -12,7 +12,7 @@ class daNpc_Seira2_Param_c {
 public:
     virtual ~daNpc_Seira2_Param_c() {}
 
-    static const daNpc_Seira2_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Seira2_HIOParam m;
 };
 
 #if DEBUG
@@ -106,10 +106,9 @@ public:
     BOOL checkChangeJoint(int val) { return val == 4; }
     BOOL checkRemoveJoint(int val) { return val == 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0x0F7C */ mDoExt_McaMorfSO* mpSeiraMorf;
     /* 0x0F80 */ NPC_SEIRA2_HIO_CLASS* mpHIO;
     /* 0x0F84 */ dCcD_Cyl mCyl1;
diff --git a/include/d/actor/d_a_npc_seirei.h b/include/d/actor/d_a_npc_seirei.h
index ca0c7f9985..b27f6084fc 100644
--- a/include/d/actor/d_a_npc_seirei.h
+++ b/include/d/actor/d_a_npc_seirei.h
@@ -13,7 +13,7 @@ class daNpc_Seirei_Param_c {
 public:
     virtual ~daNpc_Seirei_Param_c() {}
 
-    static daNpc_Seirei_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Seirei_HIOParam const m;
 };
 
 #if DEBUG
@@ -99,10 +99,9 @@ public:
     u32 getBitSW() { return (fopAcM_GetParam(this) & 0xFF000) >> 12; }
     bool getDoBtnChkFlag() { return (fopAcM_GetParam(this) & 0x100) == 0; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0xE40 */ NPC_SEIREI_HIO_CLASS* mpHIO;
     /* 0xE44 */ u8 mType;
     /* 0xE45 */ u8 arg0;
diff --git a/include/d/actor/d_a_npc_shad.h b/include/d/actor/d_a_npc_shad.h
index d33a6af350..59f1901059 100644
--- a/include/d/actor/d_a_npc_shad.h
+++ b/include/d/actor/d_a_npc_shad.h
@@ -12,7 +12,7 @@ class daNpcShad_Param_c : public JORReflexible {
 public:
     virtual ~daNpcShad_Param_c() {}
 
-    static const daNpcShad_HIOParam m;
+    static DUSK_GAME_DATA const daNpcShad_HIOParam m;
 };
 
 #if DEBUG
@@ -184,7 +184,7 @@ public:
     void lookat();
     BOOL drawDbgInfo();
 
-    static EventFn DUSK_CONST mEvtSeqList[14];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[14];
 
     u8 getPathID() { return (fopAcM_GetParam(this) >> 8) & 0xFF; }
     s16 getMessageNo() { return shape_angle.x; }
@@ -237,7 +237,6 @@ public:
         }
     }
 
-private:
     /* 0xB48 */ J3DModel* mBookKnifeModel;
     /* 0xB4C */ J3DModel* mKomonshoModel;
     /* 0xB50 */ Z2Creature mSound;
diff --git a/include/d/actor/d_a_npc_shaman.h b/include/d/actor/d_a_npc_shaman.h
index 76231f2756..1a462a7d00 100644
--- a/include/d/actor/d_a_npc_shaman.h
+++ b/include/d/actor/d_a_npc_shaman.h
@@ -20,7 +20,7 @@ class daNpc_Sha_Param_c {
 public:
     virtual ~daNpc_Sha_Param_c() {}
 
-    static daNpc_Sha_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Sha_HIOParam const m;
 };
 
 #if DEBUG
@@ -110,14 +110,13 @@ public:
         return nodeNo == 0xFFFF ? -1 : nodeNo;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
-    static const u16 mEvtBitLabels[6];
-    static const u16 mTmpBitLabels[6];
-    static const int mSceneChangeNoTable[48];
-    static queryFunc mQueries[48];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA const u16 mEvtBitLabels[6];
+    static DUSK_GAME_DATA const u16 mTmpBitLabels[6];
+    static DUSK_GAME_DATA const int mSceneChangeNoTable[48];
+    static DUSK_GAME_DATA queryFunc mQueries[48];
 
-private:
     /* 0xE40 */ NPC_SHA_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_shoe.h b/include/d/actor/d_a_npc_shoe.h
index 67b746546b..b93259b60f 100644
--- a/include/d/actor/d_a_npc_shoe.h
+++ b/include/d/actor/d_a_npc_shoe.h
@@ -11,7 +11,7 @@ class daNpcShoe_Param_c {
 public:
     virtual ~daNpcShoe_Param_c() {}
 
-    static const daNpcShoe_HIOParam m;
+    static DUSK_GAME_DATA const daNpcShoe_HIOParam m;
 };
 
 STATIC_ASSERT(sizeof(daNpcShoe_Param_c::m) == 0x6C);
@@ -110,9 +110,8 @@ public:
     inline bool chkFindPlayer();
     inline void playMotion();
 
-    static EventFn DUSK_CONST mEvtSeqList[1];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[1];
 
-private:
     /* 0xB48 */ J3DModel* mpModel1;
     /* 0xB4C */ J3DModel* mpModel2;
     /* 0xB50 */ Z2CreatureCitizen mCreature;
diff --git a/include/d/actor/d_a_npc_shop0.h b/include/d/actor/d_a_npc_shop0.h
index 21e6916ac1..aa6d9cdf33 100644
--- a/include/d/actor/d_a_npc_shop0.h
+++ b/include/d/actor/d_a_npc_shop0.h
@@ -22,7 +22,7 @@ public:
         /* 0x8 */ u32 mParam3;
     };
 
-    static param const mParam;
+    static DUSK_GAME_DATA param const mParam;
 };
 
 
@@ -52,7 +52,7 @@ public:
     int wait(void*);
     int talk(void*);
 
-    static dCcD_SrcCyl const mCylDat;
+    static DUSK_GAME_DATA dCcD_SrcCyl const mCylDat;
 
     /* 0x56c */ u8 mParam;
     /* 0x570 */ mDoExt_bckAnm mBckAnm;
diff --git a/include/d/actor/d_a_npc_sola.h b/include/d/actor/d_a_npc_sola.h
index 7b622d121c..b7fff5b57b 100644
--- a/include/d/actor/d_a_npc_sola.h
+++ b/include/d/actor/d_a_npc_sola.h
@@ -11,7 +11,7 @@ class daNpc_solA_Param_c {
 public:
     virtual ~daNpc_solA_Param_c() {}
 
-    static daNpc_solA_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_solA_HIOParam const m;
 };
 
 #if DEBUG
@@ -111,10 +111,9 @@ public:
     s32 getNeckJointNo() { return JNT_NECK; }
     s32 getBackboneJointNo() { return JNT_BACKBONE1; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_SOLA_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 field_0xf80;
diff --git a/include/d/actor/d_a_npc_soldierA.h b/include/d/actor/d_a_npc_soldierA.h
index f7c9153dd9..aaca72ec8b 100644
--- a/include/d/actor/d_a_npc_soldierA.h
+++ b/include/d/actor/d_a_npc_soldierA.h
@@ -20,7 +20,7 @@ class daNpc_SoldierA_Param_c {
 public:
     virtual ~daNpc_SoldierA_Param_c() {}
 
-    static daNpc_SoldierA_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_SoldierA_HIOParam const m;
 };
 
 #if DEBUG
@@ -79,10 +79,9 @@ public:
 
     u8 getType() { return mType; }
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[3];
-    static cutFunc DUSK_CONST mEvtCutList[3];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[3];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[3];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ J3DModel* mSpearModel;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_soldierB.h b/include/d/actor/d_a_npc_soldierB.h
index a99e10a813..d39f54edc5 100644
--- a/include/d/actor/d_a_npc_soldierB.h
+++ b/include/d/actor/d_a_npc_soldierB.h
@@ -11,7 +11,7 @@ class daNpc_SoldierB_Param_c {
 public:
     virtual ~daNpc_SoldierB_Param_c() {}
 
-    static daNpc_SoldierB_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_SoldierB_HIOParam const m;
 };
 
 #if DEBUG
@@ -75,10 +75,9 @@ public:
     int ECut_listenLake(int);
     int test(void*);
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
-    static cutFunc DUSK_CONST mEvtCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mEvtCutList[2];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ J3DModel* mSpearModel;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_taro.h b/include/d/actor/d_a_npc_taro.h
index 6e7e394406..83ff47fc07 100644
--- a/include/d/actor/d_a_npc_taro.h
+++ b/include/d/actor/d_a_npc_taro.h
@@ -14,7 +14,7 @@ class daNpc_Taro_Param_c {
 public:
     virtual ~daNpc_Taro_Param_c() {}
 
-    static daNpc_Taro_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Taro_HIOParam const m;
 };
 
 #if DEBUG
@@ -156,10 +156,9 @@ public:
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xff0000) >> 16; }
     u8 getBitSW2() { return (fopAcM_GetParam(this) & 0xff000000) >> 24; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[17];
-    static cutFunc DUSK_CONST mCutList[17];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[17];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[17];
 
-private:
     /* 0x0E40 */ NPC_TARO_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mModels[2];
     /* 0x0E4C */ dCcD_Cyl mCyl1;
diff --git a/include/d/actor/d_a_npc_the.h b/include/d/actor/d_a_npc_the.h
index c131d442f6..2a230afb8e 100644
--- a/include/d/actor/d_a_npc_the.h
+++ b/include/d/actor/d_a_npc_the.h
@@ -12,7 +12,7 @@ class daNpcThe_Param_c {
 public:
     virtual ~daNpcThe_Param_c() {}
 
-    static const daNpcThe_HIOParam m;
+    static DUSK_GAME_DATA const daNpcThe_HIOParam m;
 };
 
 STATIC_ASSERT(sizeof(daNpcThe_Param_c::m) == 0x6C);
@@ -208,7 +208,6 @@ public:
         }
     }
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
@@ -231,8 +230,8 @@ private:
     /* 0xE1D */ bool field_0xe1d;
     /* 0xE1E */ u8 mType;
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[4];
-    static EventFn DUSK_CONST mEvtCutList[4];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[4];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtCutList[4];
 };
 
 STATIC_ASSERT(sizeof(daNpcThe_c) == 0xE20);
diff --git a/include/d/actor/d_a_npc_theB.h b/include/d/actor/d_a_npc_theB.h
index 9179ddd652..e2bc9d410d 100644
--- a/include/d/actor/d_a_npc_theB.h
+++ b/include/d/actor/d_a_npc_theB.h
@@ -19,7 +19,7 @@ struct daNpcTheB_HIOParam {
 struct daNpcTheB_Param_c {
     virtual ~daNpcTheB_Param_c() {}
 
-    static daNpcTheB_HIOParam const m;
+    static DUSK_GAME_DATA daNpcTheB_HIOParam const m;
 };
 
 #if DEBUG
@@ -149,9 +149,8 @@ public:
         }
     }
 
-    static cutFunc mEvtSeqList[6];
+    static DUSK_GAME_DATA cutFunc mEvtSeqList[6];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_tkc.h b/include/d/actor/d_a_npc_tkc.h
index ab2c871be2..6ec0150e5c 100644
--- a/include/d/actor/d_a_npc_tkc.h
+++ b/include/d/actor/d_a_npc_tkc.h
@@ -36,7 +36,7 @@ class daNpcTkc_Param_c {
 public:
     virtual ~daNpcTkc_Param_c() {}
 
-    static daNpcTkc_HIOParam const m;
+    static DUSK_GAME_DATA daNpcTkc_HIOParam const m;
 };
 
 #if DEBUG
@@ -106,9 +106,8 @@ public:
     BOOL chkAction(actionFunc action) { return action == mAction; }
     void lookat();
 
-    static evtFunc mEvtSeqList[4];
+    static DUSK_GAME_DATA evtFunc mEvtSeqList[4];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_ActorMngr_c mActorMngr[1];
diff --git a/include/d/actor/d_a_npc_tkj.h b/include/d/actor/d_a_npc_tkj.h
index dc0e595cb7..3191f1ee3b 100644
--- a/include/d/actor/d_a_npc_tkj.h
+++ b/include/d/actor/d_a_npc_tkj.h
@@ -11,7 +11,7 @@ class daNpc_Tkj_Param_c {
 public:
     virtual ~daNpc_Tkj_Param_c() {}
 
-    static const daNpc_Tkj_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Tkj_HIOParam m;
 };
 
 #if DEBUG
@@ -94,10 +94,9 @@ public:
 
     int getPath() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static int (daNpcTkj_c::* DUSK_CONST mCutList[])(int);
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA int (daNpcTkj_c::* DUSK_CONST mCutList[])(int);
 
-private:
     /* 0xE40 */ NPC_TKJ_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCcCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_tks.h b/include/d/actor/d_a_npc_tks.h
index c2f7e6ff53..837a0c89ec 100644
--- a/include/d/actor/d_a_npc_tks.h
+++ b/include/d/actor/d_a_npc_tks.h
@@ -31,7 +31,7 @@ class daNpcTks_Param_c {
 public:
     virtual ~daNpcTks_Param_c() {}
 
-    static daNpcTks_HIOParam const m;
+    static DUSK_GAME_DATA daNpcTks_HIOParam const m;
 };
 
 #if DEBUG
@@ -134,7 +134,6 @@ public:
     inline void playTsuboAnm();
     inline int getPlayerArea();
 
-private:
     /* 0x0B48 */ Z2Creature mSound;
     /* 0x0BD8 */ daNpcTksTsubo_c mTksTsubo;
     /* 0x1160 */ daNpcF_MatAnm_c* mpMatAnm;
diff --git a/include/d/actor/d_a_npc_toby.h b/include/d/actor/d_a_npc_toby.h
index 7cce8adf7e..9abb7c032f 100644
--- a/include/d/actor/d_a_npc_toby.h
+++ b/include/d/actor/d_a_npc_toby.h
@@ -16,7 +16,7 @@ class daNpc_Toby_Param_c {
 public:
     virtual ~daNpc_Toby_Param_c() {}
 
-    static const daNpc_Toby_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Toby_HIOParam m;
 };
 
 #if DEBUG
@@ -129,10 +129,9 @@ public:
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
     u8 getBitSW() { return (fopAcM_GetParam(this) & 0xFF0000) >> 16; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[7];
-    static cutFunc DUSK_CONST mCutList[7];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[7];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[7];
 
-private:
     /* 0x0E40 */ NPC_TOBY_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mpTobyModels[1];
     /* 0x0E48 */ dCcD_Cyl mCyl1;
diff --git a/include/d/actor/d_a_npc_uri.h b/include/d/actor/d_a_npc_uri.h
index 0c29bd56ee..2650de4d64 100644
--- a/include/d/actor/d_a_npc_uri.h
+++ b/include/d/actor/d_a_npc_uri.h
@@ -22,7 +22,7 @@ class daNpc_Uri_Param_c {
 public:
     virtual ~daNpc_Uri_Param_c() {}
 
-    static const daNpc_Uri_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Uri_HIOParam m;
 };
 
 #if DEBUG
@@ -136,10 +136,9 @@ public:
 
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xff00) >> 8; }
 
-    static const char* mCutNameList[7];
-    static cutFunc DUSK_CONST mCutList[7];
+    static DUSK_GAME_DATA const char* mCutNameList[7];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[7];
 
-private:
     /* 0x0E40 */ NPC_URI_HIO_CLASS* mpHIO;
     /* 0x0E44 */ J3DModel* mpModel[1];
     /* 0x0E48 */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_npc_wrestler.h b/include/d/actor/d_a_npc_wrestler.h
index e4c98c8abb..c840259074 100644
--- a/include/d/actor/d_a_npc_wrestler.h
+++ b/include/d/actor/d_a_npc_wrestler.h
@@ -77,7 +77,7 @@ class daNpcWrestler_Param_c {
 public:
     virtual ~daNpcWrestler_Param_c() {}
 
-    static daNpcWrestler_HIOParam const m;
+    static DUSK_GAME_DATA daNpcWrestler_HIOParam const m;
 };
 
 class daNpcWrestler_HIO_Node_c: public JORReflexible {
@@ -230,9 +230,8 @@ public:
     inline void initDemoCamera_ReadyWrestler();
     inline void playExpression();
 
-    static EventFn DUSK_CONST mEvtSeqList[7];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtSeqList[7];
 
-private:
     /* 0xB48 */ Z2Creature mSound;
     /* 0xBD8 */ daNpcWrestler_HIOParam* field_0xbd8;
     /* 0xBDC */ daNpcWrestler_HIOParamSub* field_0xbdc;
diff --git a/include/d/actor/d_a_npc_yamid.h b/include/d/actor/d_a_npc_yamid.h
index 3133cbd84f..b9bb6bb288 100644
--- a/include/d/actor/d_a_npc_yamid.h
+++ b/include/d/actor/d_a_npc_yamid.h
@@ -20,7 +20,7 @@ class daNpc_yamiD_Param_c {
 public:
     virtual ~daNpc_yamiD_Param_c() {}
 
-    static daNpc_yamiD_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_yamiD_HIOParam const m;
 };
 
 #if DEBUG
@@ -129,10 +129,9 @@ public:
         field_0xe44.OffTgSetBit();
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0xE40 */ NPC_YAMID_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl field_0xe44;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_yamis.h b/include/d/actor/d_a_npc_yamis.h
index edf87ee174..272b0d5b72 100644
--- a/include/d/actor/d_a_npc_yamis.h
+++ b/include/d/actor/d_a_npc_yamis.h
@@ -11,7 +11,7 @@ class daNpc_yamiS_Param_c {
 public:
     virtual ~daNpc_yamiS_Param_c() {}
 
-    static const daNpc_yamiS_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_yamiS_HIOParam m;
 };
 
 #if DEBUG
@@ -124,10 +124,9 @@ public:
         field_0xe44.OffTgSetBit();
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0xE40 */ NPC_YAMIS_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl field_0xe44;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_yamit.h b/include/d/actor/d_a_npc_yamit.h
index 4f7a5393f8..0a12c2875d 100644
--- a/include/d/actor/d_a_npc_yamit.h
+++ b/include/d/actor/d_a_npc_yamit.h
@@ -12,7 +12,7 @@ class daNpc_yamiT_Param_c {
 public:
     virtual ~daNpc_yamiT_Param_c() {}
 
-    static const daNpc_yamiT_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_yamiT_HIOParam m;
 };
 
 #if DEBUG
@@ -123,10 +123,9 @@ public:
     }
     u8 _is_stopper_off() { return fopAcM_isSwitch(this, 0x3D) && fopAcM_isSwitch(this, 0x3E); }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[2];
-    static cutFunc DUSK_CONST mCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[2];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[2];
 
-private:
     /* 0xE40 */ NPC_YAMIT_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl field_0xe44;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_yelia.h b/include/d/actor/d_a_npc_yelia.h
index fb934a25c5..c86d8e6ac6 100644
--- a/include/d/actor/d_a_npc_yelia.h
+++ b/include/d/actor/d_a_npc_yelia.h
@@ -11,7 +11,7 @@ class daNpc_Yelia_Param_c {
 public:
     virtual ~daNpc_Yelia_Param_c() {}
 
-    static daNpc_Yelia_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_Yelia_HIOParam const m;
 };
 
 #if DEBUG
@@ -102,9 +102,8 @@ public:
         return no;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[6];
-    static int (daNpc_Yelia_c::*mCutList[6])(int);
-private:
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[6];
+    static DUSK_GAME_DATA int (daNpc_Yelia_c::*mCutList[6])(int);
     /* 0xE40 */ NPC_YELIA_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCcCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_ykm.h b/include/d/actor/d_a_npc_ykm.h
index 391203948d..5bbb5077f6 100644
--- a/include/d/actor/d_a_npc_ykm.h
+++ b/include/d/actor/d_a_npc_ykm.h
@@ -38,7 +38,7 @@ class daNpc_ykM_Param_c {
 public:
     virtual ~daNpc_ykM_Param_c() {}
 
-    static daNpc_ykM_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_ykM_HIOParam const m;
 };
 
 #if DEBUG
@@ -285,9 +285,8 @@ public:
     int getBitTRB() { return (u8)((fopAcM_GetParam(this) & 0x3F0000) >> 16); }
     u8 getPathID() { return (fopAcM_GetParam(this) & 0xFF00) >> 8; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[10];
-    static cutFunc DUSK_CONST mCutList[10];
-private:
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[10];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[10];
     /* 0x0E40 */ mDoExt_McaMorfSO* mFishModelMorf;
     /* 0x0E44 */ mDoExt_McaMorfSO* mLeafModelMorf;
     /* 0x0E48 */ NPC_YKM_HIO_CLASS* mpHIO;
diff --git a/include/d/actor/d_a_npc_ykw.h b/include/d/actor/d_a_npc_ykw.h
index 91517d4e17..43b3bca276 100644
--- a/include/d/actor/d_a_npc_ykw.h
+++ b/include/d/actor/d_a_npc_ykw.h
@@ -131,8 +131,8 @@ public:
         return (fopAcM_GetParam(this) & 0xf0) >> 4;
     }
 
-    static const char* mCutNameList[8];
-    static cutFunc DUSK_CONST mCutList[8];
+    static DUSK_GAME_DATA const char* mCutNameList[8];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[8];
 
     void setDialogueTmr1(int param_1) {
         field_0x1024 = param_1;
@@ -216,7 +216,7 @@ class daNpc_ykW_Param_c {
 public:
     virtual ~daNpc_ykW_Param_c() {}
 
-    static const daNpc_ykW_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_ykW_HIOParam m;
 };
 
 #endif /* D_A_NPC_YKW_H */
diff --git a/include/d/actor/d_a_npc_zanb.h b/include/d/actor/d_a_npc_zanb.h
index 6feaf3fc72..78c37f6c76 100644
--- a/include/d/actor/d_a_npc_zanb.h
+++ b/include/d/actor/d_a_npc_zanb.h
@@ -20,7 +20,7 @@ class daNpc_zanB_Param_c {
 public:
     virtual ~daNpc_zanB_Param_c() {}
 
-    static daNpc_zanB_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_zanB_HIOParam const m;
 };
 
 #if DEBUG
@@ -99,10 +99,9 @@ public:
         return nodeNo;
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[1];
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[1];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_ZANB_HIO_CLASS* mHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_zant.h b/include/d/actor/d_a_npc_zant.h
index d2d1949bda..f9cd1c5b9b 100644
--- a/include/d/actor/d_a_npc_zant.h
+++ b/include/d/actor/d_a_npc_zant.h
@@ -11,7 +11,7 @@ class daNpc_Zant_Param_c {
 public:
     virtual ~daNpc_Zant_Param_c() {}
 
-    static const daNpc_Zant_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Zant_HIOParam m;
 };
 
 #if DEBUG
@@ -83,10 +83,9 @@ public:
                                 daNpcT_evtData_c const* param_7, char DUSK_CONST* DUSK_CONST* param_8) :
                                 daNpcT_c(param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8) {}
     
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_ZANT_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_zelR.h b/include/d/actor/d_a_npc_zelR.h
index ce3314c694..bfe7d963a0 100644
--- a/include/d/actor/d_a_npc_zelR.h
+++ b/include/d/actor/d_a_npc_zelR.h
@@ -20,7 +20,7 @@ class daNpc_ZelR_Param_c {
 public:
     virtual ~daNpc_ZelR_Param_c() {};
 
-    static const daNpc_ZelR_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_ZelR_HIOParam m;
 };
 
 #if DEBUG
@@ -93,10 +93,9 @@ public:
     BOOL checkChangeJoint(int param_1) { return param_1 == 3; };
     BOOL checkRemoveJoint(int param_1) { return param_1 == 13; };
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static EventFn mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA EventFn mCutList[1];
 
-private:
     /* 0xE40 */ NPC_ZELR_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_zelRo.h b/include/d/actor/d_a_npc_zelRo.h
index 40e0b3e391..a57235bff9 100644
--- a/include/d/actor/d_a_npc_zelRo.h
+++ b/include/d/actor/d_a_npc_zelRo.h
@@ -20,7 +20,7 @@ class daNpc_ZelRo_Param_c {
 public:
     virtual ~daNpc_ZelRo_Param_c() {}
 
-    static daNpc_ZelRo_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_ZelRo_HIOParam const m;
 };
 
 #if DEBUG
@@ -147,10 +147,9 @@ public:
     BOOL checkChangeJoint(int i_joint) { return i_joint == JNT_HEAD; }
     BOOL checkRemoveJoint(int i_joint) { return i_joint == JNT_MOUTH; }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_ZELRO_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 mType;
diff --git a/include/d/actor/d_a_npc_zelda.h b/include/d/actor/d_a_npc_zelda.h
index 5a2d70b658..e4be31296e 100644
--- a/include/d/actor/d_a_npc_zelda.h
+++ b/include/d/actor/d_a_npc_zelda.h
@@ -14,7 +14,7 @@ class daNpc_Zelda_Param_c {
 public:
     virtual ~daNpc_Zelda_Param_c() {}
 
-    static const daNpc_Zelda_HIOParam m;
+    static DUSK_GAME_DATA const daNpc_Zelda_HIOParam m;
 };
 
 #if DEBUG
@@ -100,10 +100,9 @@ public:
     int checkChangeJoint(int param_0) { return param_0 == 4; }
     int checkRemoveJoint(int param_0) { return param_0 == 17; }
 
-    static const char* mCutNameList;
-    static cutFunc DUSK_CONST mCutList[1];
+    static DUSK_GAME_DATA const char* mCutNameList;
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[1];
 
-private:
     /* 0xE40 */ NPC_ZELDA_HIO_CLASS* mpHIO;
     /* 0xE44 */ dCcD_Cyl mCyl;
     /* 0xF80 */ u8 field_0xf80;
diff --git a/include/d/actor/d_a_npc_zra.h b/include/d/actor/d_a_npc_zra.h
index 31ea1431b7..825076e192 100644
--- a/include/d/actor/d_a_npc_zra.h
+++ b/include/d/actor/d_a_npc_zra.h
@@ -32,7 +32,7 @@ class daNpc_zrA_Param_c {
 public:
     virtual ~daNpc_zrA_Param_c() {}
 
-    static daNpc_zrA_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_zrA_HIOParam const m;
 };
 
 #if DEBUG
@@ -370,6 +370,9 @@ public:
     u32 getAngleNoFromParam() { return (u8)(fopAcM_GetParam(this) >> 8); }
     void setBlastFlag(u8 i_flag) { mBlastFlag = i_flag; }
     MtxP getHeadMtx() { return mAnm_p->getModel()->getAnmMtx(4); }
+#if TARGET_PC
+    friend void daNpc_zrA_interp_callback(void* pUserWork);
+#endif
 
     /* 0x0B48 */ Z2Creature mCreatureSound;
     /* 0x0BD8 */ J3DModel* mpObjectModel[3];
@@ -443,8 +446,8 @@ public:
     /* 0x15C0 */ u8 field_0x15c0;
     /* 0x15C1 */ bool mBlastFlag;
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[11];
-    static EventFn DUSK_CONST mEvtCutList[11];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[11];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtCutList[11];
 };
 
 STATIC_ASSERT(sizeof(daNpc_zrA_c) == 0x15C4);
diff --git a/include/d/actor/d_a_npc_zrc.h b/include/d/actor/d_a_npc_zrc.h
index 184a4e31c0..e9992ae157 100644
--- a/include/d/actor/d_a_npc_zrc.h
+++ b/include/d/actor/d_a_npc_zrc.h
@@ -16,7 +16,7 @@ class daNpc_zrC_Param_c {
 public:
     virtual ~daNpc_zrC_Param_c() {}
 
-    static daNpc_zrC_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_zrC_HIOParam const m;
 };
 
 #if DEBUG
@@ -93,10 +93,9 @@ public:
     BOOL ECut_earringGet(int);
     void adjustShapeAngle() {}
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
-    static EventFn DUSK_CONST mEvtCutList[2];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[2];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtCutList[2];
 
-private:
     /* 0xB48 */ Z2Creature mCreatureSound;
     /* 0xBD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0xBDC */ daNpcF_Lookat_c mLookat;
diff --git a/include/d/actor/d_a_npc_zrz.h b/include/d/actor/d_a_npc_zrz.h
index a9a294b97f..a02ebb8227 100644
--- a/include/d/actor/d_a_npc_zrz.h
+++ b/include/d/actor/d_a_npc_zrz.h
@@ -20,7 +20,7 @@ class daNpc_zrZ_Param_c {
 public:
     virtual ~daNpc_zrZ_Param_c() {}
 
-    static daNpc_zrZ_HIOParam const m;
+    static DUSK_GAME_DATA daNpc_zrZ_HIOParam const m;
 };
 
 STATIC_ASSERT(sizeof(daNpc_zrZ_HIOParam) == 0x84);
@@ -114,7 +114,6 @@ public:
     void himoCalc();
     void adjustShapeAngle() {}
 
-private:
     /* 0x0B48 */ Z2Creature mCreatureSound;
     /* 0x0BD8 */ daNpcF_MatAnm_c* mpMatAnm;
     /* 0x0BDC */ mDoExt_invisibleModel mInvisibleModel;
@@ -160,8 +159,8 @@ private:
     /* 0x14C0 */ BOOL mMusicSet;
     /* 0x14C4 */ bool mSealReleased;
 
-    static char DUSK_CONST* DUSK_CONST mEvtCutNameList[8];
-    static EventFn DUSK_CONST mEvtCutList[8];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mEvtCutNameList[8];
+    static DUSK_GAME_DATA EventFn DUSK_CONST mEvtCutList[8];
 
     enum Animation {
         /* 0x0 */ ANM_NONE,
diff --git a/include/d/actor/d_a_obj_Lv5Key.h b/include/d/actor/d_a_obj_Lv5Key.h
index 6e0251b151..11e2bd3019 100644
--- a/include/d/actor/d_a_obj_Lv5Key.h
+++ b/include/d/actor/d_a_obj_Lv5Key.h
@@ -65,7 +65,6 @@ public:
 
     cXyz& getLocalOffset() { return mLocalOffset; }
 
-private:
     /* 0x568 */ u8 field_0x568[0x56C - 0x568];
     /* 0x56C */ Z2SoundObjSimple mSound;
     /* 0x58C */ u8 field_0x58C[0x590 - 0x58C];
diff --git a/include/d/actor/d_a_obj_Turara.h b/include/d/actor/d_a_obj_Turara.h
index d8a45097d9..16f27d8550 100644
--- a/include/d/actor/d_a_obj_Turara.h
+++ b/include/d/actor/d_a_obj_Turara.h
@@ -53,10 +53,9 @@ public:
     int getItemTbleNum() { return shape_angle.x >> 8 & 0xff; }
     int getState() { return shape_angle.x; }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5b8 */ request_of_phase_process_class mPhaseReq;
     /* 0x5c0 */ J3DModel* mpModel[2];
     /* 0x5c8 */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_TvCdlst.h b/include/d/actor/d_a_obj_TvCdlst.h
index 7d94a35676..5329727f6a 100644
--- a/include/d/actor/d_a_obj_TvCdlst.h
+++ b/include/d/actor/d_a_obj_TvCdlst.h
@@ -26,14 +26,13 @@ public:
     int Draw();
     int Delete();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
     u8 getLightType() { return fopAcM_GetParamBit(this,8,8); }
     u8 getOnSw() { return fopAcM_GetParamBit(this,0,8); }
     u8 getOffSw() { return fopAcM_GetParamBit(this,0x10,8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_Y_taihou.h b/include/d/actor/d_a_obj_Y_taihou.h
index 0e96cf62ed..002b85d853 100644
--- a/include/d/actor/d_a_obj_Y_taihou.h
+++ b/include/d/actor/d_a_obj_Y_taihou.h
@@ -37,7 +37,6 @@ public:
     s32 getIronBallId() { return mIronBallId; }
     void startBomb() { mStartBomb = 0xffff; }
 
-private:
     /* 0x5b8 */ Mtx mMtx;
     /* 0x5e8 */ J3DModel* mpModel;
     /* 0x5ec */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_amiShutter.h b/include/d/actor/d_a_obj_amiShutter.h
index b0e881c4c0..9fabc75220 100644
--- a/include/d/actor/d_a_obj_amiShutter.h
+++ b/include/d/actor/d_a_obj_amiShutter.h
@@ -62,7 +62,6 @@ public:
 
     bool isShutterOpen() { return mOpen; }
 
-private:
     /* 0x5b8 */ request_of_phase_process_class mPhaseReq;
     /* 0x5c0 */ J3DModel* mpModel;
     /* 0x5c4 */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_ari.h b/include/d/actor/d_a_obj_ari.h
index a771b054f1..03b80016bd 100644
--- a/include/d/actor/d_a_obj_ari.h
+++ b/include/d/actor/d_a_obj_ari.h
@@ -40,7 +40,6 @@ public:
     bool CreateChk();
     cPhs_Step create();
 
-private:
     /* 0x590 */ dBgS_GndChk mGndChk;
     /* 0x5E4 */ u8 field_0x5e4[4];
     /* 0x5E8 */ u8 mAction;
diff --git a/include/d/actor/d_a_obj_automata.h b/include/d/actor/d_a_obj_automata.h
index 3468ccc3e8..17e470af99 100644
--- a/include/d/actor/d_a_obj_automata.h
+++ b/include/d/actor/d_a_obj_automata.h
@@ -15,7 +15,7 @@ class daObj_AutoMata_Param_c {
 public:
     virtual ~daObj_AutoMata_Param_c() {}
 
-    static daObj_AutoMata_HIOParam const m;
+    static DUSK_GAME_DATA daObj_AutoMata_HIOParam const m;
 };
 
 #if DEBUG
@@ -44,7 +44,7 @@ public:
  *
  */
 class daObj_AutoMata_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_AUTOMATA_HIO_CLASS* mpHIO;
     /* 0x56C */ mDoExt_McaMorfSO* mpMorf;
     /* 0x570 */ Z2Creature mCreature;
diff --git a/include/d/actor/d_a_obj_avalanche.h b/include/d/actor/d_a_obj_avalanche.h
index 89de60d2e8..ef72babdef 100644
--- a/include/d/actor/d_a_obj_avalanche.h
+++ b/include/d/actor/d_a_obj_avalanche.h
@@ -46,7 +46,6 @@ public:
     u8 getEvId() { return fopAcM_GetParamBit(this, 8, 8); }
     void setAction(u8 action) { mAction = action; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ mDoExt_bckAnm* mBckAnm;
diff --git a/include/d/actor/d_a_obj_barDesk.h b/include/d/actor/d_a_obj_barDesk.h
index 427e18ebdb..fc4c1cf4df 100644
--- a/include/d/actor/d_a_obj_barDesk.h
+++ b/include/d/actor/d_a_obj_barDesk.h
@@ -36,8 +36,8 @@ public:
     /* 0x5EC */ dCcD_Cyl mColCyl;
     /* 0x728 */ u8 field_0x728[8];
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daBarDesk_c) == 0x730);
diff --git a/include/d/actor/d_a_obj_batta.h b/include/d/actor/d_a_obj_batta.h
index fca663390b..a1eaefc45e 100644
--- a/include/d/actor/d_a_obj_batta.h
+++ b/include/d/actor/d_a_obj_batta.h
@@ -43,7 +43,6 @@ public:
         return mActionFunc == i_func;
     }
 
-private:
     /* 0x590 */ Z2Creature mCreature;
     /* 0x620 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x624 */ mDoExt_brkAnm* mBrk;
diff --git a/include/d/actor/d_a_obj_bbox.h b/include/d/actor/d_a_obj_bbox.h
index 7ee461b557..1f7c2eef60 100644
--- a/include/d/actor/d_a_obj_bbox.h
+++ b/include/d/actor/d_a_obj_bbox.h
@@ -26,7 +26,6 @@ public:
 
     u32 getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_bed.h b/include/d/actor/d_a_obj_bed.h
index 883dd64f73..c6d76f0005 100644
--- a/include/d/actor/d_a_obj_bed.h
+++ b/include/d/actor/d_a_obj_bed.h
@@ -19,7 +19,7 @@ class daObj_Bed_Param_c {
 public:
     virtual ~daObj_Bed_Param_c() {}
 
-    static daObj_Bed_HIOParam const m;
+    static DUSK_GAME_DATA daObj_Bed_HIOParam const m;
 };
 
 #if DEBUG
diff --git a/include/d/actor/d_a_obj_bemos.h b/include/d/actor/d_a_obj_bemos.h
index 713794c3b1..3d0c10790d 100644
--- a/include/d/actor/d_a_obj_bemos.h
+++ b/include/d/actor/d_a_obj_bemos.h
@@ -50,12 +50,12 @@ public:
         void wall_pos(fopAc_ac_c const*, daObjBm_c::BgcSrc_c const*, int, s16, f32);
         bool chk_wall_pre(fopAc_ac_c const*, daObjBm_c::BgcSrc_c const*, int, s16);
 
-        static const daObjBm_c::BgcSrc_c M_lin5[];
-        static const daObjBm_c::BgcSrc_c M_lin20[];
+        static DUSK_GAME_DATA const daObjBm_c::BgcSrc_c M_lin5[];
+        static DUSK_GAME_DATA const daObjBm_c::BgcSrc_c M_lin20[];
 
-        static dBgS_ObjGndChk M_gnd_work[23];
-        static dBgS_WtrChk M_wrt_work;
-        static dBgS_ObjLinChk M_wall_work[23];
+        static DUSK_GAME_DATA dBgS_ObjGndChk M_gnd_work[23];
+        static DUSK_GAME_DATA dBgS_WtrChk M_wrt_work;
+        static DUSK_GAME_DATA dBgS_ObjLinChk M_wall_work[23];
 
         /* 0x000 */ f32 field_0x0[23];
         /* 0x05C */ int field_0x5c;
@@ -130,8 +130,7 @@ public:
 #endif
     int Delete();
 
-    static s16 const M_dir_base[4];
-    // private:
+    static DUSK_GAME_DATA s16 const M_dir_base[4];
     /* 0x05A0 */ request_of_phase_process_class mPhase;
     /* 0x05A8 */ J3DModel* mpModel;
     /* 0x05AC */ mDoExt_brkAnm* mSerchBrk;
diff --git a/include/d/actor/d_a_obj_bhashi.h b/include/d/actor/d_a_obj_bhashi.h
index 7600d73f67..7ce2cd1c23 100644
--- a/include/d/actor/d_a_obj_bhashi.h
+++ b/include/d/actor/d_a_obj_bhashi.h
@@ -50,7 +50,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x05A0 */ u8 field_0x5A0[0x05A4 - 0x05A0];
     /* 0x05A4 */ int mMode;
     /* 0x05A8 */ s16 field_0x5a8;
diff --git a/include/d/actor/d_a_obj_bkdoor.h b/include/d/actor/d_a_obj_bkdoor.h
index 69d3191028..793d86f09c 100644
--- a/include/d/actor/d_a_obj_bkdoor.h
+++ b/include/d/actor/d_a_obj_bkdoor.h
@@ -26,7 +26,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ csXyz mRotation;
diff --git a/include/d/actor/d_a_obj_bky_rock.h b/include/d/actor/d_a_obj_bky_rock.h
index 99f23557e4..1214a610c9 100644
--- a/include/d/actor/d_a_obj_bky_rock.h
+++ b/include/d/actor/d_a_obj_bky_rock.h
@@ -60,10 +60,9 @@ public:
     u8 getSwBit1() { return fopAcM_GetParamBit(this, 12, 8); }
     s8 getNameNo() { return fopAcM_GetParamBit(this, 0, 4); }
 
-    static dCcD_SrcCyl const s_CcDCyl;
-    static exeProc s_exeProc[3];
+    static DUSK_GAME_DATA dCcD_SrcCyl const s_CcDCyl;
+    static DUSK_GAME_DATA exeProc s_exeProc[3];
     
-private:
     /* 0x568 */ int mVibrationTimer;
     /* 0x578 */ u8 mMode;
     /* 0x579 */ bool field_0x579;
diff --git a/include/d/actor/d_a_obj_bmWindow.h b/include/d/actor/d_a_obj_bmWindow.h
index 85b5ab8f86..a3d71fa9c2 100644
--- a/include/d/actor/d_a_obj_bmWindow.h
+++ b/include/d/actor/d_a_obj_bmWindow.h
@@ -39,7 +39,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ u8 mMode;
@@ -66,8 +65,8 @@ private:
     /* 0xEDE */ u8 field_0xede;
 
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daBmWindow_c) == 0xEE0);
diff --git a/include/d/actor/d_a_obj_bmshutter.h b/include/d/actor/d_a_obj_bmshutter.h
index c114421fe8..6ca4c05fe9 100644
--- a/include/d/actor/d_a_obj_bmshutter.h
+++ b/include/d/actor/d_a_obj_bmshutter.h
@@ -46,7 +46,6 @@ public:
     void setAction(u8 action) { mAction = action; }
     void setMoveMode(u8 mode) { mMoveMode = mode; }
 
-private:
     /* 0x5a0 */ request_of_phase_process_class mPhase;
     /* 0x5a8 */ J3DModel* mModel;
     /* 0x5ac */ s16 mEventIdx;
diff --git a/include/d/actor/d_a_obj_bombf.h b/include/d/actor/d_a_obj_bombf.h
index 1d175caa94..661450e397 100644
--- a/include/d/actor/d_a_obj_bombf.h
+++ b/include/d/actor/d_a_obj_bombf.h
@@ -21,7 +21,6 @@ public:
     int execute();
     int draw();
 
-private:
     /* 0x568 */ request_of_phase_process_class field_0x568;
     /* 0x570 */ J3DModel* field_0x570;
     /* 0x574 */ u32 field_0x574;
diff --git a/include/d/actor/d_a_obj_bosswarp.h b/include/d/actor/d_a_obj_bosswarp.h
index 9b62f1a0f6..4f6c6e4282 100644
--- a/include/d/actor/d_a_obj_bosswarp.h
+++ b/include/d/actor/d_a_obj_bosswarp.h
@@ -60,7 +60,6 @@ public:
     bool isFirst() { return fopAcM_GetParamBit(this, 0x1b, 1); }
     void setAction(u8 action) { mAction = action; }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ mDoExt_btkAnm* mpBtkAnm[2];
diff --git a/include/d/actor/d_a_obj_boumato.h b/include/d/actor/d_a_obj_boumato.h
index 3a988d9b4b..6a0266e548 100644
--- a/include/d/actor/d_a_obj_boumato.h
+++ b/include/d/actor/d_a_obj_boumato.h
@@ -21,7 +21,7 @@ class daObj_BouMato_Param_c {
 public:
     virtual ~daObj_BouMato_Param_c() {}
 
-    static daObj_BouMato_HIOParam const m;
+    static DUSK_GAME_DATA daObj_BouMato_HIOParam const m;
 };
 
 #if DEBUG
@@ -50,7 +50,7 @@ public:
  *
  */
 class daObj_BouMato_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_BOUMATO_HIO_CLASS* mpHIO;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_obj_bsGate.h b/include/d/actor/d_a_obj_bsGate.h
index b40c5dcf6d..0c9730d63d 100644
--- a/include/d/actor/d_a_obj_bsGate.h
+++ b/include/d/actor/d_a_obj_bsGate.h
@@ -35,7 +35,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_bubblePilar.h b/include/d/actor/d_a_obj_bubblePilar.h
index b9abdd1fdd..e19cbbae2f 100644
--- a/include/d/actor/d_a_obj_bubblePilar.h
+++ b/include/d/actor/d_a_obj_bubblePilar.h
@@ -36,10 +36,9 @@ public:
     u8 getArg0() { return fopAcM_GetParamBit(this, 8, 4); }
     u8 getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModels[2];
     /* 0x5B0 */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_burnbox.h b/include/d/actor/d_a_obj_burnbox.h
index f87678dccc..dc4634ea85 100644
--- a/include/d/actor/d_a_obj_burnbox.h
+++ b/include/d/actor/d_a_obj_burnbox.h
@@ -28,7 +28,6 @@ public:
 
     u8 getType() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpBoxModel;
     /* 0x5AC */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_carry.h b/include/d/actor/d_a_obj_carry.h
index 621b8efabb..54c8c73043 100644
--- a/include/d/actor/d_a_obj_carry.h
+++ b/include/d/actor/d_a_obj_carry.h
@@ -304,11 +304,11 @@ public:
         make_prm(o_params, o_paramsEx, 6, i_itemNo, i_itemBit, i_itemType, param_5);
     }
 
-    static const daObjCarry_dt_t mData[];
-    static cXyz mPos[5];
-    static u8 mSttsFlag[5];
-    static s8 mRoomNo[5];
-    static bool mSaveFlag;
+    static DUSK_GAME_DATA const daObjCarry_dt_t mData[];
+    static DUSK_GAME_DATA cXyz mPos[5];
+    static DUSK_GAME_DATA u8 mSttsFlag[5];
+    static DUSK_GAME_DATA s8 mRoomNo[5];
+    static DUSK_GAME_DATA bool mSaveFlag;
 
 public:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
@@ -407,7 +407,6 @@ public:
     /* 0xE26 */ u8 field_0xe26;
     /* 0xE27 */ u8 field_0xe27;
 
-private:
     u16 getType_private() { return field_0xd18 >> 1 & 0x1f; }
 };
 
diff --git a/include/d/actor/d_a_obj_catdoor.h b/include/d/actor/d_a_obj_catdoor.h
index dd7141d920..c352c25806 100644
--- a/include/d/actor/d_a_obj_catdoor.h
+++ b/include/d/actor/d_a_obj_catdoor.h
@@ -80,7 +80,6 @@ public:
         Z2GetAudioMgr()->seStart(Z2SE_OBJ_GZ_NE_DOOR_OP, &current.pos, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ daObjCatDoor_Door_c mDoor1;
     /* 0x660 */ daObjCatDoor_Door_c mDoor2;
@@ -88,7 +87,7 @@ private:
     /* 0x790 */ s16 mRotSpeed;
 
 public:
-    static const daObjCatDoor_Attr_c M_attr;
+    static DUSK_GAME_DATA const daObjCatDoor_Attr_c M_attr;
 };
 
 #endif /* D_A_OBJ_CATDOOR_H */
diff --git a/include/d/actor/d_a_obj_cblock.h b/include/d/actor/d_a_obj_cblock.h
index 04881776ec..75454ebb5d 100644
--- a/include/d/actor/d_a_obj_cblock.h
+++ b/include/d/actor/d_a_obj_cblock.h
@@ -49,7 +49,6 @@ public:
     u8 getSwNo() { return fopAcM_GetParamBit(this, 16, 8); }
     u8 getPathID() { return fopAcM_GetParamBit(this, 24, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class phase;
     /* 0x5A8 */ J3DModel* model1;
     /* 0x5AC */ J3DModel* model2;
diff --git a/include/d/actor/d_a_obj_cboard.h b/include/d/actor/d_a_obj_cboard.h
index 52a5f753e4..9bcdb51ed5 100644
--- a/include/d/actor/d_a_obj_cboard.h
+++ b/include/d/actor/d_a_obj_cboard.h
@@ -28,7 +28,6 @@ public:
     u8 getArg0() { return fopAcM_GetParamBit(this, 4, 4); }
     u8 getSwNo() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ Mtx field_0x5a8;
 };
diff --git a/include/d/actor/d_a_obj_cdoor.h b/include/d/actor/d_a_obj_cdoor.h
index ee06fd790c..60d54539e9 100644
--- a/include/d/actor/d_a_obj_cdoor.h
+++ b/include/d/actor/d_a_obj_cdoor.h
@@ -51,7 +51,6 @@ public:
     int getSwitchNum() { return mSw; }
     void setChainID(u32 i_id) { mChainID = i_id; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ bool mEnd;
diff --git a/include/d/actor/d_a_obj_chandelier.h b/include/d/actor/d_a_obj_chandelier.h
index 4aae0160d8..a0592f4374 100644
--- a/include/d/actor/d_a_obj_chandelier.h
+++ b/include/d/actor/d_a_obj_chandelier.h
@@ -49,7 +49,6 @@ public:
 
     void moveHookOn() { field_0x60a = 1; }
 
-private:
     /* 0x5A8 */ cXyz field_0x5a8;
     /* 0x5B4 */ Mtx mMtx;
     /* 0x5E4 */ u8 field_0x5e4[4];
@@ -67,7 +66,7 @@ private:
     /* 0x60A */ u8 field_0x60a;
     /* 0x60B */ u8 field_0x60b;
 
-    static daObjChandelier_proc s_exeProc[5];
+    static DUSK_GAME_DATA daObjChandelier_proc s_exeProc[5];
 };
 
 STATIC_ASSERT(sizeof(daObjChandelier_c) == 0x60C);
diff --git a/include/d/actor/d_a_obj_chest.h b/include/d/actor/d_a_obj_chest.h
index a5caedae86..e225c4a254 100644
--- a/include/d/actor/d_a_obj_chest.h
+++ b/include/d/actor/d_a_obj_chest.h
@@ -39,7 +39,6 @@ public:
     u8 getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
     u32 getArg0() { return fopAcM_GetParamBit(this, 8, 4); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dBgS_ObjAcch mObjAcch;
diff --git a/include/d/actor/d_a_obj_cho.h b/include/d/actor/d_a_obj_cho.h
index 49dd5332b1..adb3faef58 100644
--- a/include/d/actor/d_a_obj_cho.h
+++ b/include/d/actor/d_a_obj_cho.h
@@ -46,7 +46,6 @@ public:
     cPhs_Step create();
     inline int Draw();
 
-private:
     /* 0x590 */ dBgS_AcchCir mAcchCir;
     /* 0x5D0 */ dBgS_ObjAcch mAcch;
     /* 0x7A8 */ dCcD_Stts mCcStts;
diff --git a/include/d/actor/d_a_obj_cowdoor.h b/include/d/actor/d_a_obj_cowdoor.h
index 1ed34370d8..a084ca0188 100644
--- a/include/d/actor/d_a_obj_cowdoor.h
+++ b/include/d/actor/d_a_obj_cowdoor.h
@@ -22,7 +22,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class field_0x5a0;
     /* 0x5A8 */ J3DModel* field_0x5a8;
 };
diff --git a/include/d/actor/d_a_obj_crope.h b/include/d/actor/d_a_obj_crope.h
index bde25e379c..e0f0220000 100644
--- a/include/d/actor/d_a_obj_crope.h
+++ b/include/d/actor/d_a_obj_crope.h
@@ -52,7 +52,6 @@ public:
         mCoCancelTimer = 30;
     }
 
-private:
     /* 0x0568 */ request_of_phase_process_class mPhase;
     /* 0x0570 */ dCcD_Stts mCcStts;
     /* 0x05AC */ dCcD_Sph mCollider;
diff --git a/include/d/actor/d_a_obj_crvfence.h b/include/d/actor/d_a_obj_crvfence.h
index dd760bb43f..9b6298553f 100644
--- a/include/d/actor/d_a_obj_crvfence.h
+++ b/include/d/actor/d_a_obj_crvfence.h
@@ -34,7 +34,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x05A0 */ int field_0x5a0;
     /* 0x05A4 */ int mAction;
     /* 0x05A8 */ u8 field_0x5a8;
diff --git a/include/d/actor/d_a_obj_crvgate.h b/include/d/actor/d_a_obj_crvgate.h
index 1fb4d1a12b..fed7868085 100644
--- a/include/d/actor/d_a_obj_crvgate.h
+++ b/include/d/actor/d_a_obj_crvgate.h
@@ -50,7 +50,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ s32 mEventID;
     /* 0x5A4 */ bool mFlagGateClosed;
     /* 0x5A5 */ bool field_0x5a5;
diff --git a/include/d/actor/d_a_obj_crvlh_down.h b/include/d/actor/d_a_obj_crvlh_down.h
index ce1c31bfa8..06ad6c89f0 100644
--- a/include/d/actor/d_a_obj_crvlh_down.h
+++ b/include/d/actor/d_a_obj_crvlh_down.h
@@ -28,7 +28,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x5A0 */ fpc_ProcID field_0x5a0;
     /* 0x5A4 */ fpc_ProcID field_0x5a4;
     /* 0x5A8 */ cXyz field_0x5a8;
diff --git a/include/d/actor/d_a_obj_crvlh_up.h b/include/d/actor/d_a_obj_crvlh_up.h
index 7f24ba03a6..950018311a 100644
--- a/include/d/actor/d_a_obj_crvlh_up.h
+++ b/include/d/actor/d_a_obj_crvlh_up.h
@@ -26,7 +26,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x568 */ u8 field_0x568[0x5a4 - 0x5a0];
     /* 0x5A4 */ fpc_ProcID field_0x5a4;
     /* 0x5A8 */ fpc_ProcID field_0x5a8;
diff --git a/include/d/actor/d_a_obj_crvsteel.h b/include/d/actor/d_a_obj_crvsteel.h
index a8d6305495..09ddc5be2a 100644
--- a/include/d/actor/d_a_obj_crvsteel.h
+++ b/include/d/actor/d_a_obj_crvsteel.h
@@ -29,7 +29,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ u32 mSmokeParticle1;
     /* 0x5A4 */ u32 mSmokeParticle2;
     /* 0x5A8 */ s16 mAction;
diff --git a/include/d/actor/d_a_obj_crystal.h b/include/d/actor/d_a_obj_crystal.h
index 0d6fcc1fc6..3c2fbfb110 100644
--- a/include/d/actor/d_a_obj_crystal.h
+++ b/include/d/actor/d_a_obj_crystal.h
@@ -22,7 +22,6 @@ public:
     int draw();
     int _delete();
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel[2];
     /* 0x578 */ JPABaseEmitter* mpEmitter;
diff --git a/include/d/actor/d_a_obj_cwall.h b/include/d/actor/d_a_obj_cwall.h
index 396729be80..66d760a337 100644
--- a/include/d/actor/d_a_obj_cwall.h
+++ b/include/d/actor/d_a_obj_cwall.h
@@ -61,7 +61,6 @@ public:
     u8 getType() { return fopAcM_GetParamBit(this, 4, 4); }
     u8 getSwbit() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mWallModel;
     /* 0x5AC */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_damCps.h b/include/d/actor/d_a_obj_damCps.h
index 1ce75cc663..d92a38184c 100644
--- a/include/d/actor/d_a_obj_damCps.h
+++ b/include/d/actor/d_a_obj_damCps.h
@@ -26,7 +26,6 @@ public:
     int _delete();
     u8 getSwNo();
     
-private:
     /* 0x0570 */ dCcD_Stts mStts;
     /* 0x05AC */ dCcD_Cps mCps;
     /* 0x06F0 */ cM3dGCpsS mCapsule;
diff --git a/include/d/actor/d_a_obj_dan.h b/include/d/actor/d_a_obj_dan.h
index 15caef361a..3e3b62fc9b 100644
--- a/include/d/actor/d_a_obj_dan.h
+++ b/include/d/actor/d_a_obj_dan.h
@@ -39,7 +39,6 @@ public:
     bool CreateChk();
     cPhs_Step create();
 
-private:
     /* 0x590 */ dCcD_Stts mCcStts;
     /* 0x5CC */ dCcD_Sph mCcSph;
     /* 0x704 */ daPy_boomerangMove_c mBoomerangMove;
diff --git a/include/d/actor/d_a_obj_digholl.h b/include/d/actor/d_a_obj_digholl.h
index 33f078a1ea..f985bbe165 100644
--- a/include/d/actor/d_a_obj_digholl.h
+++ b/include/d/actor/d_a_obj_digholl.h
@@ -21,7 +21,6 @@ public:
     void onDigStart() { field_0x568 = 1; }
     s16 getSceneNum() const { return field_0x56c; }
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 field_0x569;
     /* 0x56A */ u8 field_0x56a;
diff --git a/include/d/actor/d_a_obj_digplace.h b/include/d/actor/d_a_obj_digplace.h
index 404b35aff4..0b29ff11f6 100644
--- a/include/d/actor/d_a_obj_digplace.h
+++ b/include/d/actor/d_a_obj_digplace.h
@@ -17,7 +17,6 @@ public:
     int create();
     int execute();
 
-private:
     /* 0x568 */ u8 mType;
     /* 0x569 */ u8 mSwitch;
     /* 0x56A */ u8 mDigFlg;
diff --git a/include/d/actor/d_a_obj_digsnow.h b/include/d/actor/d_a_obj_digsnow.h
index 09af66d091..4ef3de5958 100644
--- a/include/d/actor/d_a_obj_digsnow.h
+++ b/include/d/actor/d_a_obj_digsnow.h
@@ -50,7 +50,6 @@ public:
     void startDig() { mMode = ACTION_DIG_e; }
     void endDig() { mMode = ACTION_END_e; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_enemy_create.h b/include/d/actor/d_a_obj_enemy_create.h
index 3b29caddab..64da7b5203 100644
--- a/include/d/actor/d_a_obj_enemy_create.h
+++ b/include/d/actor/d_a_obj_enemy_create.h
@@ -22,7 +22,6 @@ public:
     void NameChk();
     int create();
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 mEnemyNum;
     /* 0x56A */ u8 mActivateSw;
diff --git a/include/d/actor/d_a_obj_fallobj.h b/include/d/actor/d_a_obj_fallobj.h
index 0c4efed3f3..f59a58991a 100644
--- a/include/d/actor/d_a_obj_fallobj.h
+++ b/include/d/actor/d_a_obj_fallobj.h
@@ -50,7 +50,6 @@ public:
         return this->speed.y != 0.0f;
     };
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ Mtx mMtx;
     /* 0x5D8 */ u8 field_0x5d8;
diff --git a/include/d/actor/d_a_obj_fan.h b/include/d/actor/d_a_obj_fan.h
index 1ababac7a6..a4907c01a1 100644
--- a/include/d/actor/d_a_obj_fan.h
+++ b/include/d/actor/d_a_obj_fan.h
@@ -29,7 +29,6 @@ public:
 
     u8 getType() { return fopAcM_GetParamBit(this,0,4); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ dBgW* field_0x5ac;
diff --git a/include/d/actor/d_a_obj_fchain.h b/include/d/actor/d_a_obj_fchain.h
index 7c4ae74faf..e9250fbe24 100644
--- a/include/d/actor/d_a_obj_fchain.h
+++ b/include/d/actor/d_a_obj_fchain.h
@@ -31,11 +31,6 @@ public:
     csXyz* getAngle() { return field_0x8a4; }
     J3DModelData* getModelData() { return mModelData; }
 
-#if TARGET_PC
-    void onInterpCallback();
-#endif
-
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModelData* mModelData;
     /* 0x574 */ daObjFchain_shape_c mShape;
@@ -46,14 +41,6 @@ private:
     /* 0x694 */ cXyz field_0x694[22];
     /* 0x79C */ cXyz field_0x79c[22];
     /* 0x8A4 */ csXyz field_0x8a4[22];
-
-#if TARGET_PC
-    static const int CHAIN_COUNT = 22;
-    cXyz mChainInterpPrev[CHAIN_COUNT];
-    cXyz mChainInterpCurr[CHAIN_COUNT];
-    bool mChainInterpPrevValid;
-    bool mChainInterpCurrValid;
-#endif
 };
 
 STATIC_ASSERT(sizeof(daObjFchain_c) == 0x928);
diff --git a/include/d/actor/d_a_obj_fireWood.h b/include/d/actor/d_a_obj_fireWood.h
index 116af1203c..5ce85234de 100644
--- a/include/d/actor/d_a_obj_fireWood.h
+++ b/include/d/actor/d_a_obj_fireWood.h
@@ -24,10 +24,9 @@ public:
     int Draw();
     int Delete();
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x568 */ u8 field_0x568[0x574 - 0x568];
     /* 0x574 */ dCcD_Stts mCcStts;
     /* 0x5B0 */ dCcD_Cyl mCcCyl;
diff --git a/include/d/actor/d_a_obj_fireWood2.h b/include/d/actor/d_a_obj_fireWood2.h
index 3b288edeeb..209ccf8ffd 100644
--- a/include/d/actor/d_a_obj_fireWood2.h
+++ b/include/d/actor/d_a_obj_fireWood2.h
@@ -25,10 +25,9 @@ public:
     int Draw();
     int Delete();
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x568 */ u8 field_0x568[0x574 - 0x568];
     /* 0x574 */ dCcD_Stts mCcStts;
     /* 0x5B0 */ dCcD_Cyl mCcCyl;
diff --git a/include/d/actor/d_a_obj_firepillar.h b/include/d/actor/d_a_obj_firepillar.h
index 620373422a..8490a1c488 100644
--- a/include/d/actor/d_a_obj_firepillar.h
+++ b/include/d/actor/d_a_obj_firepillar.h
@@ -47,7 +47,6 @@ public:
     int draw();
     int _delete();
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ int field_0x570;
     /* 0x574 */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_firepillar2.h b/include/d/actor/d_a_obj_firepillar2.h
index 359cbf6bb3..579342b8dc 100644
--- a/include/d/actor/d_a_obj_firepillar2.h
+++ b/include/d/actor/d_a_obj_firepillar2.h
@@ -51,7 +51,6 @@ public:
     u8 getArg0() { return fopAcM_GetParamBit(this,8,8); }
     u8 getSwNo() { return fopAcM_GetParamBit(this,0,8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mModel;
     /* 0x574 */ mDoExt_bckAnm* mBck;
diff --git a/include/d/actor/d_a_obj_flag.h b/include/d/actor/d_a_obj_flag.h
index eee36b0842..8ac8662fb9 100644
--- a/include/d/actor/d_a_obj_flag.h
+++ b/include/d/actor/d_a_obj_flag.h
@@ -28,7 +28,7 @@ public:
  *
  */
 class daObjFlag_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ J3DModel* mpModel1;
     /* 0x56c */ J3DModel* mpModel2;
     /* 0x570 */ request_of_phase_process_class mPhase;
@@ -86,7 +86,7 @@ public:
         /* 0x30 */ f32 field_0x30;
     };
 
-    static M_attrs const M_attr;
+    static DUSK_GAME_DATA M_attrs const M_attr;
     M_attrs const& attr() const { return M_attr; }
 };
 
diff --git a/include/d/actor/d_a_obj_flag2.h b/include/d/actor/d_a_obj_flag2.h
index 54b3777ac6..676da2141d 100644
--- a/include/d/actor/d_a_obj_flag2.h
+++ b/include/d/actor/d_a_obj_flag2.h
@@ -81,9 +81,8 @@ public:
 
     const daObjFlag2_Attr_c& attr() const { return M_attr; }
 
-    static daObjFlag2_Attr_c const M_attr;
+    static DUSK_GAME_DATA daObjFlag2_Attr_c const M_attr;
 
-private:
     /* 0x0568 */ J3DModel* mModel;
     /* 0x056C */ request_of_phase_process_class mFlagPhase;
     /* 0x0574 */ request_of_phase_process_class mArcPhase;
diff --git a/include/d/actor/d_a_obj_flag3.h b/include/d/actor/d_a_obj_flag3.h
index c6a94f6538..26bfd5b506 100644
--- a/include/d/actor/d_a_obj_flag3.h
+++ b/include/d/actor/d_a_obj_flag3.h
@@ -93,10 +93,9 @@ public:
     inline int draw();
     inline void initBaseMtx();
 
-    static daObjFlag3_Attr_c const M_attr;
+    static DUSK_GAME_DATA daObjFlag3_Attr_c const M_attr;
     const daObjFlag3_Attr_c& attr() const { return M_attr; }
 
-private:
     /* 0x0568 */ J3DModel* mModel;
     /* 0x056C */ request_of_phase_process_class mFlagPhase;
     /* 0x0574 */ request_of_phase_process_class mArcPhase;
diff --git a/include/d/actor/d_a_obj_gadget.h b/include/d/actor/d_a_obj_gadget.h
index db7f5a53f7..a52f9ab27b 100644
--- a/include/d/actor/d_a_obj_gadget.h
+++ b/include/d/actor/d_a_obj_gadget.h
@@ -17,7 +17,7 @@ class daObj_Gadget_HIO_c;
  *
  */
 class daObj_Gadget_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ daObj_Gadget_HIO_c* field_0x568;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mModel;
@@ -117,7 +117,7 @@ class daObj_Gadget_Param_c {
 public:
     virtual ~daObj_Gadget_Param_c() {}
 
-    static daObj_Gadget_HIOParam const m;
+    static DUSK_GAME_DATA daObj_Gadget_HIOParam const m;
 };
 
 
diff --git a/include/d/actor/d_a_obj_ganonwall.h b/include/d/actor/d_a_obj_ganonwall.h
index 02d0cd1d99..c5e6f7d06a 100644
--- a/include/d/actor/d_a_obj_ganonwall.h
+++ b/include/d/actor/d_a_obj_ganonwall.h
@@ -26,7 +26,6 @@ public:
     u32 getEventBit1() { return fopAcM_GetParamBit(this, 0, 10); }
     u32 getEventBit2() { return fopAcM_GetParamBit(this, 10, 10); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ mDoExt_btkAnm* mpBtkAnm;
diff --git a/include/d/actor/d_a_obj_ganonwall2.h b/include/d/actor/d_a_obj_ganonwall2.h
index a938a32141..0026094a8d 100644
--- a/include/d/actor/d_a_obj_ganonwall2.h
+++ b/include/d/actor/d_a_obj_ganonwall2.h
@@ -25,7 +25,6 @@ public:
 
     u32 getEventBit1() { return fopAcM_GetParamBit(this, 0, 10); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ mDoExt_btkAnm* mpBtkAnm;
diff --git a/include/d/actor/d_a_obj_gb.h b/include/d/actor/d_a_obj_gb.h
index 3f5a354f5e..2bc435b2df 100644
--- a/include/d/actor/d_a_obj_gb.h
+++ b/include/d/actor/d_a_obj_gb.h
@@ -36,5 +36,4 @@ public:
 
 STATIC_ASSERT(sizeof(obj_gb_class) == 0x6bc);
 
-
 #endif /* D_A_OBJ_GB_H */
diff --git a/include/d/actor/d_a_obj_geyser.h b/include/d/actor/d_a_obj_geyser.h
index 54a7f3bcb8..244d3b1fcf 100644
--- a/include/d/actor/d_a_obj_geyser.h
+++ b/include/d/actor/d_a_obj_geyser.h
@@ -62,7 +62,6 @@ public:
     u8 getArg3() { return fopAcM_GetParamBit(this, 24, 8); }
     u8 getSwNo() { return 0xFF; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dCcD_Stts mCcStts;
diff --git a/include/d/actor/d_a_obj_glowSphere.h b/include/d/actor/d_a_obj_glowSphere.h
index f620306408..062a9ce7d5 100644
--- a/include/d/actor/d_a_obj_glowSphere.h
+++ b/include/d/actor/d_a_obj_glowSphere.h
@@ -30,7 +30,6 @@ public:
     bool isSet() { return mIsSet; }
     daGlwSph_c* getpSph() { return mpSph; }
 
-private:
     /* 0x0 */ daGlwSph_c* mpSph;
     /* 0x4 */ s8 mIsSet;
 };
@@ -68,8 +67,8 @@ public:
         _clrLstBuf();
     }
 
-    static u16 mSphSe;
-    static s16 mSeClrTmr;
+    static DUSK_GAME_DATA u16 mSphSe;
+    static DUSK_GAME_DATA s16 mSeClrTmr;
 
     /* 0x0 */ int field_0x0;
     /* 0x4 */ _GlSph_LstInfo_c mListBuf[120];
@@ -135,9 +134,9 @@ public:
         saveGetFlag();
     }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
-    static _GlSph_Mng_c mSphMng;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA _GlSph_Mng_c mSphMng;
 
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_goGate.h b/include/d/actor/d_a_obj_goGate.h
index a0a66c7f32..8ed98a43e6 100644
--- a/include/d/actor/d_a_obj_goGate.h
+++ b/include/d/actor/d_a_obj_goGate.h
@@ -40,7 +40,6 @@ public:
     u32 getLR() { return fopAcM_GetParamBit(this, 8, 8); }
     u32 getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_gomikabe.h b/include/d/actor/d_a_obj_gomikabe.h
index 441fff371f..a0a01c4e20 100644
--- a/include/d/actor/d_a_obj_gomikabe.h
+++ b/include/d/actor/d_a_obj_gomikabe.h
@@ -41,7 +41,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x05A0 */ u8 mSwBit;
     /* 0x05A1 */ u8 mAction;
     /* 0x05A2 */ u8 field_0x5a2;
diff --git a/include/d/actor/d_a_obj_gpTaru.h b/include/d/actor/d_a_obj_gpTaru.h
index 79ed31b3ae..1ab93b2586 100644
--- a/include/d/actor/d_a_obj_gpTaru.h
+++ b/include/d/actor/d_a_obj_gpTaru.h
@@ -43,10 +43,9 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mpModel;
     /* 0x578 */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_gra2.h b/include/d/actor/d_a_obj_gra2.h
index 59fd35343b..4add220bcd 100644
--- a/include/d/actor/d_a_obj_gra2.h
+++ b/include/d/actor/d_a_obj_gra2.h
@@ -234,8 +234,8 @@ public:
     void setCrazyThrowLeft() { field_0xa48 |= (u16)8; }
     void setCrazyThrowRight() { field_0xa48 |= (u16)0x10; }
 
-    static MotionFunc mBaseMotionList[22];
-    static MotionFunc mFaceMotionList[14];
+    static DUSK_GAME_DATA MotionFunc mBaseMotionList[22];
+    static DUSK_GAME_DATA MotionFunc mFaceMotionList[14];
 
     bool isFirstGra() { return isFisrtGra(); }
     bool isFisrtGra() { return field_0x1fe8 == 0; }
@@ -243,7 +243,6 @@ public:
     void setDemoMode(s16 mDemoMode) { mDemoCamMode = mDemoMode; }
     s16 getDemoMode() { return mDemoCamMode; }
 
-private:
     /* 0x0A48 */ u16 field_0xa48;
     /* 0x0A4C */ OBJ_GRA_HIO_CLASS* mpHIO;
     /* 0x0A50 */ Process field_0xa50;
diff --git a/include/d/actor/d_a_obj_graWall.h b/include/d/actor/d_a_obj_graWall.h
index ebcd1cdb58..037767547a 100644
--- a/include/d/actor/d_a_obj_graWall.h
+++ b/include/d/actor/d_a_obj_graWall.h
@@ -20,7 +20,6 @@ public:
     void col_init();
     void col_set();
 
-private:
     /* 0x568 */ dCcD_Stts mStts;
     /* 0x5A4 */ dCcD_Cyl mCyl;
     /* 0x6E0 */ u8 field_0x6e0;
diff --git a/include/d/actor/d_a_obj_gra_rock.h b/include/d/actor/d_a_obj_gra_rock.h
index e3cf568871..21ec800563 100644
--- a/include/d/actor/d_a_obj_gra_rock.h
+++ b/include/d/actor/d_a_obj_gra_rock.h
@@ -31,9 +31,8 @@ public:
     int Draw();
     int Delete();
 
-    static dCcD_SrcCyl const mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcCyl const mCcDCyl;
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhases[5];
     /* 0x5C8 */ J3DModel* mModel;
     /* 0x5CC */ mDoExt_btpAnm mBtp;
diff --git a/include/d/actor/d_a_obj_grave_stone.h b/include/d/actor/d_a_obj_grave_stone.h
index dee38757a3..9155a2f54c 100644
--- a/include/d/actor/d_a_obj_grave_stone.h
+++ b/include/d/actor/d_a_obj_grave_stone.h
@@ -36,7 +36,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     friend class daNpc_zrZ_c;
 
     /* 0x5A0 */ request_of_phase_process_class mPhase;
@@ -49,8 +48,8 @@ private:
     /* 0x978 */ daObj_GrvStn_prtclMngr_c mPrtclMngr[4];
     /* 0xAE8 */ s16 mTimer;
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl const mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl const mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daGraveStone_c) == 0xAEC);
diff --git a/include/d/actor/d_a_obj_groundwater.h b/include/d/actor/d_a_obj_groundwater.h
index 5e9061d89c..1fc0f0ef37 100644
--- a/include/d/actor/d_a_obj_groundwater.h
+++ b/include/d/actor/d_a_obj_groundwater.h
@@ -47,7 +47,6 @@ public:
     u8 getSw() { return fopAcM_GetParamBit(this, 8, 8); }
     u8 getSw2() { return fopAcM_GetParamBit(this, 16, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel1;
     /* 0x5AC */ J3DModel* mModel2;
diff --git a/include/d/actor/d_a_obj_grz_rock.h b/include/d/actor/d_a_obj_grz_rock.h
index cd65d2e906..4c8f382071 100644
--- a/include/d/actor/d_a_obj_grz_rock.h
+++ b/include/d/actor/d_a_obj_grz_rock.h
@@ -28,7 +28,6 @@ public:
 
     void setSmashFlag(u8 i_smashFlag) { mSmashFlag = i_smashFlag; }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase[1];
     /* 0x5A0 */ J3DModel* mpModel;
     /* 0x5AC */ dBgS_ObjAcch mBgc;
diff --git a/include/d/actor/d_a_obj_hakai_brl.h b/include/d/actor/d_a_obj_hakai_brl.h
index 394cab0366..9bd109da7c 100644
--- a/include/d/actor/d_a_obj_hakai_brl.h
+++ b/include/d/actor/d_a_obj_hakai_brl.h
@@ -32,9 +32,8 @@ public:
     }
     void callEmt();
 
-    static dCcD_SrcCyl const s_CcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcCyl const s_CcDCyl;
 
-private:
     /* 0x574 */ J3DModel* mpModel;
     /* 0x578 */ dCcD_Stts mStts;
     /* 0x5B4 */ dCcD_Cyl mCyl;
diff --git a/include/d/actor/d_a_obj_hakai_ftr.h b/include/d/actor/d_a_obj_hakai_ftr.h
index cc94ba6021..ac7f749860 100644
--- a/include/d/actor/d_a_obj_hakai_ftr.h
+++ b/include/d/actor/d_a_obj_hakai_ftr.h
@@ -29,9 +29,8 @@ public:
     bool chkHit();
     void callEmt();
 
-    static dCcD_SrcCyl const s_CcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcCyl const s_CcDCyl;
 
-private:
     /* 0x574 */ Mtx mMtx;
     /* 0x5A4 */ dBgW* field_0x5a4;
     /* 0x5A8 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_hasu2.h b/include/d/actor/d_a_obj_hasu2.h
index 9c36c0d180..203b4ff159 100644
--- a/include/d/actor/d_a_obj_hasu2.h
+++ b/include/d/actor/d_a_obj_hasu2.h
@@ -29,7 +29,6 @@ public:
         virtual ~daObjMHasu_c() {};
 
         void setRideFlag(bool i_ride) { mRideFlag = i_ride; }
-private:
     /* 0x5A8 */ Mtx mMtx;
     /* 0x5D8 */ Mtx mMtx2;
     /* 0x608 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_obj_hbombkoya.h b/include/d/actor/d_a_obj_hbombkoya.h
index 9f9c0a5149..b1d76f819b 100644
--- a/include/d/actor/d_a_obj_hbombkoya.h
+++ b/include/d/actor/d_a_obj_hbombkoya.h
@@ -39,7 +39,6 @@ public:
     int getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
     int getSw2No() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x5A8 */  // dEvLib_callback_c
     /* 0x5B8 */ Mtx mBgMtx;
     /* 0x5E8 */ Mtx mMtx;
diff --git a/include/d/actor/d_a_obj_hfuta.h b/include/d/actor/d_a_obj_hfuta.h
index 77015715d0..4f4ee44eeb 100644
--- a/include/d/actor/d_a_obj_hfuta.h
+++ b/include/d/actor/d_a_obj_hfuta.h
@@ -37,7 +37,6 @@ public:
 
     void setMode(u8 mode) { mMode = mode; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ cXyz mTransM;
diff --git a/include/d/actor/d_a_obj_hsTarget.h b/include/d/actor/d_a_obj_hsTarget.h
index 1e0e775e12..50a497eb8e 100644
--- a/include/d/actor/d_a_obj_hsTarget.h
+++ b/include/d/actor/d_a_obj_hsTarget.h
@@ -23,7 +23,6 @@ public:
 
     u8 getModelType() { return fopAcM_GetParamBit(this, 0, 4); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mIndex;
diff --git a/include/d/actor/d_a_obj_iceleaf.h b/include/d/actor/d_a_obj_iceleaf.h
index da79be5bc5..42ad6237e7 100644
--- a/include/d/actor/d_a_obj_iceleaf.h
+++ b/include/d/actor/d_a_obj_iceleaf.h
@@ -61,7 +61,6 @@ public:
     u8 checkRideStatus() { return fopAcM_GetParamBit(this, 0x10, 8); }
     u8 getSwbit() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_itamato.h b/include/d/actor/d_a_obj_itamato.h
index 0aece512cd..b9080f7db7 100644
--- a/include/d/actor/d_a_obj_itamato.h
+++ b/include/d/actor/d_a_obj_itamato.h
@@ -27,7 +27,7 @@ class daObj_ItaMato_Param_c {
 public:
     virtual ~daObj_ItaMato_Param_c() {}
 
-    static daObj_ItaMato_HIOParam const m;
+    static DUSK_GAME_DATA daObj_ItaMato_HIOParam const m;
 };
 
 #if DEBUG
@@ -46,7 +46,7 @@ public:
 #endif
 
 class daObj_ItaMato_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_ITAMATO_HIO_CLASS* mHIO;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mpModels[2];
diff --git a/include/d/actor/d_a_obj_kabuto.h b/include/d/actor/d_a_obj_kabuto.h
index 9738147885..2b9d6255ee 100644
--- a/include/d/actor/d_a_obj_kabuto.h
+++ b/include/d/actor/d_a_obj_kabuto.h
@@ -47,7 +47,6 @@ public:
     cPhs_Step create();
     inline int Draw();
 
-private:
     /* 0x590 */ dCcD_Stts mCcStts;
     /* 0x5CC */ dCcD_Sph mCcSph;
     /* 0x704 */ daPy_boomerangMove_c mBoomerangMove;
diff --git a/include/d/actor/d_a_obj_kag.h b/include/d/actor/d_a_obj_kag.h
index 58692d7a8c..09c9a088a0 100644
--- a/include/d/actor/d_a_obj_kag.h
+++ b/include/d/actor/d_a_obj_kag.h
@@ -39,7 +39,6 @@ public:
     void kag_setParticle();
     inline int CreateHeap();
     inline int draw();
-private:
     /* 0x590 */ request_of_phase_process_class mPhase;
     /* 0x598 */ Z2Creature mSound;
     /* 0x628 */ mDoExt_McaMorfSO* mpModelMorf;
diff --git a/include/d/actor/d_a_obj_kago.h b/include/d/actor/d_a_obj_kago.h
index c2ea85d8f2..4a6ed74730 100644
--- a/include/d/actor/d_a_obj_kago.h
+++ b/include/d/actor/d_a_obj_kago.h
@@ -24,7 +24,7 @@ class daObj_Kago_Param_c {
 public:
     virtual ~daObj_Kago_Param_c() {}
 
-    static const daObj_Kago_HIOParam m;
+    static DUSK_GAME_DATA const daObj_Kago_HIOParam m;
 };
 
 #if DEBUG
@@ -125,7 +125,6 @@ public:
         field_0xb68 = 0.0f;
     }
     
-private:
     /* 0x568 */ OBJ_KAGO_HIO_CLASS* mpHIO;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* field_0x574;
diff --git a/include/d/actor/d_a_obj_kaisou.h b/include/d/actor/d_a_obj_kaisou.h
index 3398c24884..36d6f568df 100644
--- a/include/d/actor/d_a_obj_kaisou.h
+++ b/include/d/actor/d_a_obj_kaisou.h
@@ -28,7 +28,6 @@ public:
     inline int CreateHeap();
     inline int Draw();
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 field_0x569;
     /* 0x56A */ u8 field_0x56a[0x56e - 0x56a];
diff --git a/include/d/actor/d_a_obj_kamakiri.h b/include/d/actor/d_a_obj_kamakiri.h
index 3b2d56e533..52b648ea48 100644
--- a/include/d/actor/d_a_obj_kamakiri.h
+++ b/include/d/actor/d_a_obj_kamakiri.h
@@ -56,7 +56,6 @@ public:
     u8 CreateChk();
     int create();
 
-private:
     /* 0x590 */ dCcD_Stts mStts;
     /* 0x5CC */ dCcD_Sph mSphere;
     /* 0x704 */ daPy_boomerangMove_c mBoomerangMove;
diff --git a/include/d/actor/d_a_obj_kantera.h b/include/d/actor/d_a_obj_kantera.h
index 0228b51fd5..fbe230ed16 100644
--- a/include/d/actor/d_a_obj_kantera.h
+++ b/include/d/actor/d_a_obj_kantera.h
@@ -33,7 +33,6 @@ public:
 
     void setStatus(u8 i_status) { mStatus = i_status; }
 
-private:
     /* 0x92C */ u32 field_0x92c;
     /* 0x930 */ s32 field_0x930;
     /* 0x934 */ u8 mStatus;
diff --git a/include/d/actor/d_a_obj_katatsumuri.h b/include/d/actor/d_a_obj_katatsumuri.h
index e481d3eb3a..93b9368fb5 100644
--- a/include/d/actor/d_a_obj_katatsumuri.h
+++ b/include/d/actor/d_a_obj_katatsumuri.h
@@ -55,7 +55,6 @@ public:
     bool CreateChk();
     int create();
 
-private:
     /* 0x590 */ dBgS_ObjAcch mAcch;
     /* 0x768 */ dBgS_GndChk mGndChk;
     /* 0x7BC */ u8 field_0x7bc[0x7c0 - 0x7bc];
diff --git a/include/d/actor/d_a_obj_kazeneko.h b/include/d/actor/d_a_obj_kazeneko.h
index 3ac12b40f3..164612ecfc 100644
--- a/include/d/actor/d_a_obj_kazeneko.h
+++ b/include/d/actor/d_a_obj_kazeneko.h
@@ -45,8 +45,7 @@ public:
 
     const KazoNekoAttr& attr() { return M_attr; }
 
-    static KazoNekoAttr const M_attr;
-private:
+    static DUSK_GAME_DATA KazoNekoAttr const M_attr;
     /* 0x568 */ J3DModel* mModel;
     /* 0x56C */ J3DModel* mArmModels[4];
     /* 0x57C */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_kbacket.h b/include/d/actor/d_a_obj_kbacket.h
index f3855fc8ca..214c4dcc7c 100644
--- a/include/d/actor/d_a_obj_kbacket.h
+++ b/include/d/actor/d_a_obj_kbacket.h
@@ -25,7 +25,7 @@ class daObj_KBacket_Param_c {
 public:
     virtual ~daObj_KBacket_Param_c() {}
 
-    static const daObj_KBacket_HIOParam m;
+    static DUSK_GAME_DATA const daObj_KBacket_HIOParam m;
 };
 
 #if DEBUG
diff --git a/include/d/actor/d_a_obj_keyhole.h b/include/d/actor/d_a_obj_keyhole.h
index b8a813776d..fd39641ad8 100644
--- a/include/d/actor/d_a_obj_keyhole.h
+++ b/include/d/actor/d_a_obj_keyhole.h
@@ -66,18 +66,9 @@ public:
     /* 0x2CA7 */ s8 hide_lock;
     /* 0x2CA8 */ cXyz field_0x2ca8;
     /* 0x2CB4 */ u8 field_0x2cb4;
-
-#if TARGET_PC
-    Mtx mChainInterpPrev[6][16];
-    Mtx mChainInterpCurr[6][16];
-    bool mChainInterpPrevValid;
-    bool mChainInterpCurrValid;
-#endif
 };
 
-#if !TARGET_PC
 STATIC_ASSERT(sizeof(obj_keyhole_class) == 0x2CB8);
-#endif
 
 class daObj_Keyhole_HIO_c : public JORReflexible {
 public:
diff --git a/include/d/actor/d_a_obj_kgate.h b/include/d/actor/d_a_obj_kgate.h
index 96798028b2..f7fe72767c 100644
--- a/include/d/actor/d_a_obj_kgate.h
+++ b/include/d/actor/d_a_obj_kgate.h
@@ -46,7 +46,6 @@ public:
     u8 getEventID() { return fopAcM_GetParamBit(this, 0x14, 8); }
     u8 getNameArg() { return fopAcM_GetParamBit(this, 0x10, 4); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpGateModel;
     /* 0x5AC */ J3DModel* mpGateModel2;
diff --git a/include/d/actor/d_a_obj_kiPot.h b/include/d/actor/d_a_obj_kiPot.h
index 01d7cf76c0..248daa2d46 100644
--- a/include/d/actor/d_a_obj_kiPot.h
+++ b/include/d/actor/d_a_obj_kiPot.h
@@ -23,7 +23,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x568 */ u8 field_0x568[0x574 - 0x568];
     /* 0x574 */ u8 mMode;
     /* 0x575 */ u8 field_0x575;
diff --git a/include/d/actor/d_a_obj_kita.h b/include/d/actor/d_a_obj_kita.h
index 1e343c78ce..09eff51298 100644
--- a/include/d/actor/d_a_obj_kita.h
+++ b/include/d/actor/d_a_obj_kita.h
@@ -17,7 +17,6 @@ public:
 
 STATIC_ASSERT(sizeof(kita_s) == 0x60);
 
-
 /**
  * @ingroup actors-objects
  * @class obj_kita_class
diff --git a/include/d/actor/d_a_obj_kjgjs.h b/include/d/actor/d_a_obj_kjgjs.h
index 495750bd89..189c672c7d 100644
--- a/include/d/actor/d_a_obj_kjgjs.h
+++ b/include/d/actor/d_a_obj_kjgjs.h
@@ -25,7 +25,6 @@ public:
 
     u32 getType() { return fopAcM_GetParamBit(this, 0, 4); }
 
-private:
     /* 0x5A8 */ Mtx mMtx[2];
     /* 0x608 */ J3DModel* mpModel;
     /* 0x60C */ s32 field_0x60c;
diff --git a/include/d/actor/d_a_obj_klift00.h b/include/d/actor/d_a_obj_klift00.h
index ab5403d51b..a41c5c7b5c 100644
--- a/include/d/actor/d_a_obj_klift00.h
+++ b/include/d/actor/d_a_obj_klift00.h
@@ -26,14 +26,13 @@ public:
     int Delete();
 
 #if TARGET_PC
-    void onInterpCallback();
+    void onInterpPresentation();
 #endif
 
     enum Param_e {
         LOCK_e = (1 << 6), NO_BASE_DISP = (1 << 7)
     };
 
-private:
     struct ChainPos {
         cXyz mDeltaPosVector;
         cXyz mCurrentPos;
@@ -54,13 +53,6 @@ private:
     /* 0x1020 */ dCcD_Cyl mCylinderCollider;
     /* 0x115C */ s32 mStopSwingingFrames;
 
-#if TARGET_PC
-    cXyz mChainInterpPrev[64];
-    cXyz mChainInterpCurr[64];
-    bool mChainInterpPrevValid;
-    bool mChainInterpCurrValid;
-#endif
-
     // Number of chain models
     u32 getArg0() {
         return fopAcM_GetParamBit(this, 0, 6);
diff --git a/include/d/actor/d_a_obj_knBullet.h b/include/d/actor/d_a_obj_knBullet.h
index e8056fbb25..fa2d5397a2 100644
--- a/include/d/actor/d_a_obj_knBullet.h
+++ b/include/d/actor/d_a_obj_knBullet.h
@@ -26,7 +26,6 @@ public:
     u8 getActionMode() { return mActionMode; }
     void setActionMode(u8 i_action) { mActionMode = i_action; }
 
-private:
     /* 0x568 */ Mtx mMtx;
     /* 0x598 */ dCcD_Stts mCcStts;
     /* 0x5D4 */ dCcD_Sph mCcSph;
diff --git a/include/d/actor/d_a_obj_kshutter.h b/include/d/actor/d_a_obj_kshutter.h
index b217adef2d..a0a2204c0d 100644
--- a/include/d/actor/d_a_obj_kshutter.h
+++ b/include/d/actor/d_a_obj_kshutter.h
@@ -64,7 +64,6 @@ public:
     u8 getType() { return fopAcM_GetParamBit(this, 8, 8); }
     u8 getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
     void setAction(u8 action) { mAction = action; }
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase1;
     /* 0x5A8 */ request_of_phase_process_class mPhase2;
     /* 0x5B0 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_ktOnFire.h b/include/d/actor/d_a_obj_ktOnFire.h
index bd0e23a82d..7d292bf286 100644
--- a/include/d/actor/d_a_obj_ktOnFire.h
+++ b/include/d/actor/d_a_obj_ktOnFire.h
@@ -23,10 +23,9 @@ public:
     int Draw();
     int Delete();
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x568 */ dCcD_Stts mCcStts;
     /* 0x5A4 */ dCcD_Cyl mCcCyl;
     /* 0x6E0 */ u8 mWaitTime;
diff --git a/include/d/actor/d_a_obj_kuwagata.h b/include/d/actor/d_a_obj_kuwagata.h
index 9df3f0bc35..a14b0544bc 100644
--- a/include/d/actor/d_a_obj_kuwagata.h
+++ b/include/d/actor/d_a_obj_kuwagata.h
@@ -47,7 +47,6 @@ public:
     int create();
     inline int Draw();
 
-private:
     /* 0x590 */ dCcD_Stts mStts;
     /* 0x5CC */ dCcD_Sph mSph;
     /* 0x704 */ daPy_boomerangMove_c mBoomerangMove;
diff --git a/include/d/actor/d_a_obj_kwheel00.h b/include/d/actor/d_a_obj_kwheel00.h
index ceaf132fd6..2d58cb32f1 100644
--- a/include/d/actor/d_a_obj_kwheel00.h
+++ b/include/d/actor/d_a_obj_kwheel00.h
@@ -41,7 +41,6 @@ public:
 
     enum Type_e { TYPE_LARGE_GOLD, TYPE_SMALL_PLATINUM };
 
-private:
     enum QuadrantalAngle_e { DEG_INVALID = -1, DEG_0, DEG_90, DEG_180, DEG_270, DEG_MAX};
 
     /* 0x5B8 */ Mtx mNewBgMtx;
diff --git a/include/d/actor/d_a_obj_kwheel01.h b/include/d/actor/d_a_obj_kwheel01.h
index 40bc025db4..9c6fa31075 100644
--- a/include/d/actor/d_a_obj_kwheel01.h
+++ b/include/d/actor/d_a_obj_kwheel01.h
@@ -27,7 +27,6 @@ public:
     int Delete();
     bool eventStart();
 
-private:
     /* 0x5B8 */ Mtx mNewBgMtx;
     /* 0x5E8 */ Mtx mTransformMtx;
     /* 0x618 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_kznkarm.h b/include/d/actor/d_a_obj_kznkarm.h
index 343285f8f8..3838d1f9ff 100644
--- a/include/d/actor/d_a_obj_kznkarm.h
+++ b/include/d/actor/d_a_obj_kznkarm.h
@@ -60,10 +60,9 @@ public:
     inline ~daObjKznkarm_c();
     inline daObjKznkarm_Attr_c* attr() const;
 
-    static daObjKznkarm_Attr_c const M_attr;
-    static actionFunc ActionTable[4][2];
+    static DUSK_GAME_DATA daObjKznkarm_Attr_c const M_attr;
+    static DUSK_GAME_DATA actionFunc ActionTable[4][2];
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ dBgS_AcchCir mAcchCir;
diff --git a/include/d/actor/d_a_obj_ladder.h b/include/d/actor/d_a_obj_ladder.h
index eb48cf0f16..b46bf99603 100644
--- a/include/d/actor/d_a_obj_ladder.h
+++ b/include/d/actor/d_a_obj_ladder.h
@@ -74,9 +74,8 @@ namespace daObjLadder {
             return(Type_e)daObj::PrmAbstract(this,PRM_3, PRM_0);
         }
 
-        static char const M_arcname[5];
-        static Mtx M_tmp_mtx;
-private:
+        static DUSK_GAME_DATA char const M_arcname[5];
+        static DUSK_GAME_DATA Mtx M_tmp_mtx;
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ Type_e mType;
diff --git a/include/d/actor/d_a_obj_laundry.h b/include/d/actor/d_a_obj_laundry.h
index 7d50dfa28e..3dd76c6a39 100644
--- a/include/d/actor/d_a_obj_laundry.h
+++ b/include/d/actor/d_a_obj_laundry.h
@@ -56,8 +56,7 @@ public:
     inline int daObjLdy_Draw();
     inline int daObjLdy_Execute();
 
-private:
-    static const daObjLdy_Attr_c mAttr;
+    static DUSK_GAME_DATA const daObjLdy_Attr_c mAttr;
 
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ mDoExt_btkAnm* mpBtkAnm;
diff --git a/include/d/actor/d_a_obj_laundry_rope.h b/include/d/actor/d_a_obj_laundry_rope.h
index 4dba2250dc..85d76cbe8d 100644
--- a/include/d/actor/d_a_obj_laundry_rope.h
+++ b/include/d/actor/d_a_obj_laundry_rope.h
@@ -55,10 +55,9 @@ public:
     };
     #endif
 
-    static const daObjLndRope_Attr_c mAttr;
+    static DUSK_GAME_DATA const daObjLndRope_Attr_c mAttr;
     static const daObjLndRope_Hio_c M_Hio;
 
-private:
     /* 0x0568 */ mDoExt_3DlineMat1_c mRopeMat;
     /* 0x05a4 */ request_of_phase_process_class mPhase;
     /* 0x05ac */ Mtx mMtx;
diff --git a/include/d/actor/d_a_obj_life_container.h b/include/d/actor/d_a_obj_life_container.h
index 14187d8289..a7b209cb94 100644
--- a/include/d/actor/d_a_obj_life_container.h
+++ b/include/d/actor/d_a_obj_life_container.h
@@ -64,7 +64,6 @@ public:
         current.pos = new_pos;
     }
 
-private:
     /* 0x92C */ fpc_ProcID mItemId;
     /* 0x930 */ int mCounter;
     /* 0x934 */ u8 mStatus;
@@ -88,6 +87,12 @@ private:
     /* 0x99C */ dPa_followEcallBack mEffect2;
     /* 0x9B0 */ Z2SoundObjSimple mSound;
     /* 0x9D0 */ u8 mIsHookCarry;
+#if TARGET_PC
+    u8 mOriginalItemNo;
+    bool mItemOverridden;
+    bool mOverrideHover;
+    bool mGoldenWolfItem;
+#endif
 };
 
 STATIC_ASSERT(sizeof(daObjLife_c) == 0x9d4);
diff --git a/include/d/actor/d_a_obj_lv1Candle00.h b/include/d/actor/d_a_obj_lv1Candle00.h
index 48fca4acb6..c70d484930 100644
--- a/include/d/actor/d_a_obj_lv1Candle00.h
+++ b/include/d/actor/d_a_obj_lv1Candle00.h
@@ -30,7 +30,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ dCcD_Stts mStts;
@@ -46,8 +45,8 @@ private:
     /* 0x730 */ u8 mTgHit;
     /* 0x734 */ Z2SoundObjSimple mSound;
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daLv1Cdl00_c) == 0x754);
diff --git a/include/d/actor/d_a_obj_lv1Candle01.h b/include/d/actor/d_a_obj_lv1Candle01.h
index 66524cc4dc..1f1dbe4ee4 100644
--- a/include/d/actor/d_a_obj_lv1Candle01.h
+++ b/include/d/actor/d_a_obj_lv1Candle01.h
@@ -27,7 +27,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dCcD_Stts mStts;
@@ -42,8 +41,8 @@ private:
     /* 0x768 */ u8 mTgHit;
     /* 0x76C */ Z2SoundObjSimple mSound;
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daLv1Cdl01_c) == 0x78C);
diff --git a/include/d/actor/d_a_obj_lv2Candle.h b/include/d/actor/d_a_obj_lv2Candle.h
index 767480d550..424dd844fd 100644
--- a/include/d/actor/d_a_obj_lv2Candle.h
+++ b/include/d/actor/d_a_obj_lv2Candle.h
@@ -37,7 +37,6 @@ public:
     u8 getSwType() { return fopAcM_GetParamBit(this, 8, 4); }
     u8 getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ dCcD_Stts mStts;
@@ -60,8 +59,8 @@ private:
     /* 0x738 */ u8 mTgHit;
     /* 0x73C */ Z2SoundObjSimple mSound;
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daLv2Candle_c) == 0x75C);
diff --git a/include/d/actor/d_a_obj_lv3Candle.h b/include/d/actor/d_a_obj_lv3Candle.h
index b82ad0b8c4..76edaaac77 100644
--- a/include/d/actor/d_a_obj_lv3Candle.h
+++ b/include/d/actor/d_a_obj_lv3Candle.h
@@ -29,7 +29,6 @@ public:
     int getSwBit() { return fopAcM_GetParamBit(this, 0, 8); }
     int getType() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ u8 mType;
@@ -44,8 +43,8 @@ private:
     /* 0x730 */ u8 mTgHit;
     /* 0x734 */ Z2SoundObjSimple mSound;
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 
 };  // Size: 0x754
 
diff --git a/include/d/actor/d_a_obj_lv3Water.h b/include/d/actor/d_a_obj_lv3Water.h
index de4ff03356..82f5be1661 100644
--- a/include/d/actor/d_a_obj_lv3Water.h
+++ b/include/d/actor/d_a_obj_lv3Water.h
@@ -45,7 +45,6 @@ public:
     int getParamType() { return (shape_angle.x & 0xFF00) >> 8; }
     u8 getType() { return mType; }
 
-private:
     /* 0x5B8 */ request_of_phase_process_class mPhase;
     /* 0x5C0 */ J3DModel* mpModel1;
     /* 0x5C4 */ J3DModel* mpModel2;
diff --git a/include/d/actor/d_a_obj_lv3Water2.h b/include/d/actor/d_a_obj_lv3Water2.h
index be13ef4819..4227e8bcb0 100644
--- a/include/d/actor/d_a_obj_lv3Water2.h
+++ b/include/d/actor/d_a_obj_lv3Water2.h
@@ -29,7 +29,6 @@ public:
     int Delete();
     bool eventStart();
 
-private:
     /* 0x5B8 */ request_of_phase_process_class mPhase;
     /* 0x5C0 */ J3DModel* mpModel;
     /* 0x5C4 */ mDoExt_btkAnm mRefractionAnm; // Applied to water surface
diff --git a/include/d/actor/d_a_obj_lv3saka00.h b/include/d/actor/d_a_obj_lv3saka00.h
index f08f4a5d19..5207e74de8 100644
--- a/include/d/actor/d_a_obj_lv3saka00.h
+++ b/include/d/actor/d_a_obj_lv3saka00.h
@@ -28,7 +28,6 @@ public:
     u8 getSwbit() { return fopAcM_GetParamBit(this, 0, 8) & 0xFF; }
     u8 getType() { return fopAcM_GetParamBit(this, 28, 4) & 0xFF; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ dBgW* mpBgW2;
 };
diff --git a/include/d/actor/d_a_obj_lv3waterEff.h b/include/d/actor/d_a_obj_lv3waterEff.h
index fdf7b204dc..a612168fac 100644
--- a/include/d/actor/d_a_obj_lv3waterEff.h
+++ b/include/d/actor/d_a_obj_lv3waterEff.h
@@ -18,7 +18,6 @@ public:
     int execute();
     int _delete();
 
-private:
     /* 0x568 */ cXyz mSePositions[2];
     /* 0x580 */ JPABaseEmitter* mParticles[4];
     /* 0x590 */ u8 unused_0x590[0x594 - 0x590];
diff --git a/include/d/actor/d_a_obj_lv4CandleDemoTag.h b/include/d/actor/d_a_obj_lv4CandleDemoTag.h
index 58378ecd4e..4ac8618776 100644
--- a/include/d/actor/d_a_obj_lv4CandleDemoTag.h
+++ b/include/d/actor/d_a_obj_lv4CandleDemoTag.h
@@ -43,7 +43,6 @@ public:
     virtual ~dalv4CandleDemoTag_c() {}
     virtual bool eventStart();
 
-private:
     /* 0x584 */ u8 mMode;
     /* 0x585 */ u8 mPathID;
     /* 0x586 */ u8 mSwNG;
diff --git a/include/d/actor/d_a_obj_lv4EdShutter.h b/include/d/actor/d_a_obj_lv4EdShutter.h
index a19de47873..992431c64d 100644
--- a/include/d/actor/d_a_obj_lv4EdShutter.h
+++ b/include/d/actor/d_a_obj_lv4EdShutter.h
@@ -45,7 +45,6 @@ public:
     u8 getZenmetuSw() { return shape_angle.z & 0xFF; }
     u8 getStatus() { return mStatus; }
 
-private:
     /* 0x5B8 */ request_of_phase_process_class mPhase;
     /* 0x5C0 */ J3DModel* mpModel;
     /* 0x5C4 */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_lv4HsTarget.h b/include/d/actor/d_a_obj_lv4HsTarget.h
index fbb1c8862a..c618aec40e 100644
--- a/include/d/actor/d_a_obj_lv4HsTarget.h
+++ b/include/d/actor/d_a_obj_lv4HsTarget.h
@@ -23,7 +23,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
 };
diff --git a/include/d/actor/d_a_obj_lv4PoGate.h b/include/d/actor/d_a_obj_lv4PoGate.h
index 480885fa0a..bd46dd30c4 100644
--- a/include/d/actor/d_a_obj_lv4PoGate.h
+++ b/include/d/actor/d_a_obj_lv4PoGate.h
@@ -52,7 +52,6 @@ public:
 
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_lv4RailWall.h b/include/d/actor/d_a_obj_lv4RailWall.h
index 7cffceedc0..39858be708 100644
--- a/include/d/actor/d_a_obj_lv4RailWall.h
+++ b/include/d/actor/d_a_obj_lv4RailWall.h
@@ -50,7 +50,6 @@ public:
 
     u8 getSwbit() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5B0 */ request_of_phase_process_class mPhase;
     /* 0x5B8 */ J3DModel* mpModel;
     /* 0x5BC */ dBgS_ObjAcch field_0x5bc;
diff --git a/include/d/actor/d_a_obj_lv4SlideWall.h b/include/d/actor/d_a_obj_lv4SlideWall.h
index fcafa19dfc..1e08e68206 100644
--- a/include/d/actor/d_a_obj_lv4SlideWall.h
+++ b/include/d/actor/d_a_obj_lv4SlideWall.h
@@ -32,7 +32,6 @@ public:
 
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_lv4chandelier.h b/include/d/actor/d_a_obj_lv4chandelier.h
index d0e7c53515..2b965d5831 100644
--- a/include/d/actor/d_a_obj_lv4chandelier.h
+++ b/include/d/actor/d_a_obj_lv4chandelier.h
@@ -43,7 +43,6 @@ public:
     int getAddChain2() { return fopAcM_GetParamBit(this, 12, 4); }
     int getSw() { return fopAcM_GetParamBit(this, 16, 8); }
 
-private:
     /* 0x05A8 */ Mtx field_0x5a8;
     /* 0x05D8 */ Mtx field_0x5d8;
     /* 0x0608 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_obj_lv4floor.h b/include/d/actor/d_a_obj_lv4floor.h
index 7b6681419d..704ccece93 100644
--- a/include/d/actor/d_a_obj_lv4floor.h
+++ b/include/d/actor/d_a_obj_lv4floor.h
@@ -38,7 +38,6 @@ public:
 
     u8 getSwbit() { return fopAcM_GetParamBit(this, 0, 8) & 0xFF; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ f32 mMoveYPos;
diff --git a/include/d/actor/d_a_obj_lv4gear.h b/include/d/actor/d_a_obj_lv4gear.h
index 5e649c0722..9c3d4920c1 100644
--- a/include/d/actor/d_a_obj_lv4gear.h
+++ b/include/d/actor/d_a_obj_lv4gear.h
@@ -31,7 +31,6 @@ public:
     u8 getType() { return fopAcM_GetParamBit(this, 8, 4); }
     u8 checkSE() { return fopAcM_GetParamBit(this, 12, 4); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ s16 mTarget;
diff --git a/include/d/actor/d_a_obj_lv4prelvtr.h b/include/d/actor/d_a_obj_lv4prelvtr.h
index 2fd50068ac..9e4846671c 100644
--- a/include/d/actor/d_a_obj_lv4prelvtr.h
+++ b/include/d/actor/d_a_obj_lv4prelvtr.h
@@ -26,7 +26,6 @@ public:
 
     int getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A8 */ Mtx mMtx1;
     /* 0x5D8 */ Mtx mMtx2;
     /* 0x608 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_lv4sand.h b/include/d/actor/d_a_obj_lv4sand.h
index 0ff6420e27..1b6272440b 100644
--- a/include/d/actor/d_a_obj_lv4sand.h
+++ b/include/d/actor/d_a_obj_lv4sand.h
@@ -46,7 +46,6 @@ public:
 
     u8 getSwbit() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5B0 */ request_of_phase_process_class mPhase;
     /* 0x5B8 */ J3DModel* mpModel;
     /* 0x5BC */ mDoExt_btkAnm* mpBtk;
diff --git a/include/d/actor/d_a_obj_lv5FloorBoard.h b/include/d/actor/d_a_obj_lv5FloorBoard.h
index f4f5c50582..e8ae0d18b2 100644
--- a/include/d/actor/d_a_obj_lv5FloorBoard.h
+++ b/include/d/actor/d_a_obj_lv5FloorBoard.h
@@ -35,10 +35,9 @@ public:
 
     int getSwBit1() { return fopAcM_GetParamBit(this, 0, 8); }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5A0 */ dCcD_Stts mCcStts;
     /* 0x5DC */ dCcD_Cyl mCcCyl;
     /* 0x718 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_lv5IceWall.h b/include/d/actor/d_a_obj_lv5IceWall.h
index 737aaf9318..e04d413249 100644
--- a/include/d/actor/d_a_obj_lv5IceWall.h
+++ b/include/d/actor/d_a_obj_lv5IceWall.h
@@ -39,10 +39,9 @@ public:
     int getScaleY() { return fopAcM_GetParamBit(this, 0x15, 5); }
     int getScaleZ() { return fopAcM_GetParamBit(this, 0x1A, 5); }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5A0 */ dCcD_Stts mCcStts;
     /* 0x5DC */ dCcD_Cyl mCcCyl[2];
     /* 0x854 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_lv5SwIce.h b/include/d/actor/d_a_obj_lv5SwIce.h
index 7c61e04d3b..9e990e3da7 100644
--- a/include/d/actor/d_a_obj_lv5SwIce.h
+++ b/include/d/actor/d_a_obj_lv5SwIce.h
@@ -35,10 +35,9 @@ public:
 
     int getSwBit1() { return fopAcM_GetParamBit(this, 0, 8); }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5A0 */ dCcD_Stts mCcStts;
     /* 0x5DC */ dCcD_Cyl mCcCyl;
     /* 0x718 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_lv5ychndlr.h b/include/d/actor/d_a_obj_lv5ychndlr.h
index 8db78c0afa..dc3a8f1ce2 100644
--- a/include/d/actor/d_a_obj_lv5ychndlr.h
+++ b/include/d/actor/d_a_obj_lv5ychndlr.h
@@ -26,7 +26,6 @@ public:
     virtual int Delete();
     virtual ~daObjYchndlr_c() {}
 
-private:
     /* 0x5A8 */ Mtx field_0x5a8;
     /* 0x5D8 */ Mtx field_0x5d8;
     /* 0x608 */ J3DModel* mpChandlierModel;
diff --git a/include/d/actor/d_a_obj_lv6ChangeGate.h b/include/d/actor/d_a_obj_lv6ChangeGate.h
index b918037950..48f532da3f 100644
--- a/include/d/actor/d_a_obj_lv6ChangeGate.h
+++ b/include/d/actor/d_a_obj_lv6ChangeGate.h
@@ -45,8 +45,8 @@ public:
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
     int getSw2() { return shape_angle.x & 0xFF; }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
     /* 0x05B8 */ request_of_phase_process_class mPhase;
     /* 0x05C0 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_lv6FurikoTrap.h b/include/d/actor/d_a_obj_lv6FurikoTrap.h
index b09952df78..5257bc540a 100644
--- a/include/d/actor/d_a_obj_lv6FurikoTrap.h
+++ b/include/d/actor/d_a_obj_lv6FurikoTrap.h
@@ -25,10 +25,9 @@ public:
     int Draw();
     int Delete();
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 
-private:
     /* 0x5A0  */ request_of_phase_process_class mPhase;
     /* 0x5A8  */ J3DModel* mModel;
     /* 0x5AC  */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_lv6Lblock.h b/include/d/actor/d_a_obj_lv6Lblock.h
index 0dbe6a330a..80080c702b 100644
--- a/include/d/actor/d_a_obj_lv6Lblock.h
+++ b/include/d/actor/d_a_obj_lv6Lblock.h
@@ -34,7 +34,6 @@ public:
     int getUpMax() { return fopAcM_GetParamBit(this, 8, 4); }
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_lv6SwGate.h b/include/d/actor/d_a_obj_lv6SwGate.h
index 964c073c1d..e2844e06ee 100644
--- a/include/d/actor/d_a_obj_lv6SwGate.h
+++ b/include/d/actor/d_a_obj_lv6SwGate.h
@@ -36,9 +36,8 @@ public:
     int getSwState() { return fopAcM_GetParamBit(this, 12, 4); }
     int getSw2() { return fopAcM_GetParamBit(this, 16, 8); }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
-private:
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
     /* 0x5A0  */ dCcD_Stts mCcStts;
     /* 0x5DC  */ dCcD_Cyl mCcDCyls[12];
     /* 0x14AC */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_lv6SzGate.h b/include/d/actor/d_a_obj_lv6SzGate.h
index 80601341ec..db3ec0ccce 100644
--- a/include/d/actor/d_a_obj_lv6SzGate.h
+++ b/include/d/actor/d_a_obj_lv6SzGate.h
@@ -45,7 +45,6 @@ public:
     u32 getWaitTime() { return fopAcM_GetParamBit(this, 8, 8); }
     u32 getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* field_0x5a8;
     /* 0x5AC */ J3DModel* field_0x5ac;
diff --git a/include/d/actor/d_a_obj_lv6Tenbin.h b/include/d/actor/d_a_obj_lv6Tenbin.h
index 6cdd8e3538..429ecb58be 100644
--- a/include/d/actor/d_a_obj_lv6Tenbin.h
+++ b/include/d/actor/d_a_obj_lv6Tenbin.h
@@ -27,7 +27,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel1;
     /* 0x5AC */ J3DModel* mModel2;
diff --git a/include/d/actor/d_a_obj_lv6TogeRoll.h b/include/d/actor/d_a_obj_lv6TogeRoll.h
index 6e6357d552..4fc557b8b4 100644
--- a/include/d/actor/d_a_obj_lv6TogeRoll.h
+++ b/include/d/actor/d_a_obj_lv6TogeRoll.h
@@ -60,13 +60,12 @@ public:
     u32 getPathID() { return fopAcM_GetParamBit(this, 0, 8); }
     u32 getSpeed() { return fopAcM_GetParamBit(this, 8, 4); }
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcGObjInf const mCcDObjInfo2;
-    static f32 const mSpeed[];
-    static dCcD_SrcSph mCcDSph;
-    static dCcD_SrcCps mCcDCps;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo2;
+    static DUSK_GAME_DATA f32 const mSpeed[];
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcCps mCcDCps;
 
-private:
     /* 0x05A0 */ request_of_phase_process_class mPhase;
     /* 0x05A8 */ J3DModel* mpModel;
     /* 0x05AC */ u8 mPathID;
diff --git a/include/d/actor/d_a_obj_lv6TogeTrap.h b/include/d/actor/d_a_obj_lv6TogeTrap.h
index 29e68aad24..e0f0a2102d 100644
--- a/include/d/actor/d_a_obj_lv6TogeTrap.h
+++ b/include/d/actor/d_a_obj_lv6TogeTrap.h
@@ -62,11 +62,11 @@ public:
     int getModelType() { return fopAcM_GetParamBit(this, 20, 4); }
     int getHankei2() { return fopAcM_GetParamBit(this, 24, 8); }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static const dCcD_SrcGObjInf mCcDObjInfo2;
-    static const f32 mSpeed[16];
-    static dCcD_SrcSph mCcDSph;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo2;
+    static DUSK_GAME_DATA const f32 mSpeed[16];
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_lv6elevta.h b/include/d/actor/d_a_obj_lv6elevta.h
index b98ff06f58..192c568552 100644
--- a/include/d/actor/d_a_obj_lv6elevta.h
+++ b/include/d/actor/d_a_obj_lv6elevta.h
@@ -33,7 +33,6 @@ public:
     int getSw2No() { return fopAcM_GetParamBit(this, 8, 8); };
     int getEvent() { return fopAcM_GetParamBit(this, 0x10, 8); };
 
-private:
     /* 0x5B8 */ Mtx mMtx1;
     /* 0x5E8 */ Mtx mMtx2;
     /* 0x618 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_obj_lv7bridge.h b/include/d/actor/d_a_obj_lv7bridge.h
index 938b87e08f..f53b24e708 100644
--- a/include/d/actor/d_a_obj_lv7bridge.h
+++ b/include/d/actor/d_a_obj_lv7bridge.h
@@ -45,7 +45,6 @@ public:
     void setDestroyAnmA() { field_0xa94 = 0; }
     void setDestroyAnmB() { field_0xa94 = 1; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_lv8KekkaiTrap.h b/include/d/actor/d_a_obj_lv8KekkaiTrap.h
index aa68df0114..423e59a500 100644
--- a/include/d/actor/d_a_obj_lv8KekkaiTrap.h
+++ b/include/d/actor/d_a_obj_lv8KekkaiTrap.h
@@ -32,7 +32,6 @@ public:
     int getType() { return fopAcM_GetParamBit(this, 0, 4); }
     int getSwBit() { return fopAcM_GetParamBit(this, 4, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mIsSwitch;
diff --git a/include/d/actor/d_a_obj_lv8Lift.h b/include/d/actor/d_a_obj_lv8Lift.h
index c327f4cf3c..4f243d0906 100644
--- a/include/d/actor/d_a_obj_lv8Lift.h
+++ b/include/d/actor/d_a_obj_lv8Lift.h
@@ -59,16 +59,15 @@ public:
     int Draw();
     int Delete();
 #if TARGET_PC
-    friend void daL8Lift_interp_callback(bool isSimFrame, void* pUserWork);
+    friend void daL8Lift_interp_callback(void* pUserWork);
 #endif
 
     u8 getPthID() { return fopAcM_GetParamBit(this, 0, 8); }
     u8 getMoveSpeed() { return fopAcM_GetParamBit(this, 8, 4); }
     int getSw() { return fopAcM_GetParamBit(this, 12, 8); }
 
-    static f32 const mSpeed[16];
+    static DUSK_GAME_DATA f32 const mSpeed[16];
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ mDoExt_btkAnm mBtk;
diff --git a/include/d/actor/d_a_obj_lv8OptiLift.h b/include/d/actor/d_a_obj_lv8OptiLift.h
index 5a437079c7..cd33551685 100644
--- a/include/d/actor/d_a_obj_lv8OptiLift.h
+++ b/include/d/actor/d_a_obj_lv8OptiLift.h
@@ -62,7 +62,7 @@ public:
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
     int getArg1() { return fopAcM_GetParamBit(this, 0x14, 4); }
 
-    static f32 const mSpeed[];
+    static DUSK_GAME_DATA f32 const mSpeed[];
 
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_lv9SwShutter.h b/include/d/actor/d_a_obj_lv9SwShutter.h
index 06607f5c1c..44e0eef556 100644
--- a/include/d/actor/d_a_obj_lv9SwShutter.h
+++ b/include/d/actor/d_a_obj_lv9SwShutter.h
@@ -31,7 +31,6 @@ public:
 
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_magLift.h b/include/d/actor/d_a_obj_magLift.h
index e9b4e8bcf3..7c15edb05e 100644
--- a/include/d/actor/d_a_obj_magLift.h
+++ b/include/d/actor/d_a_obj_magLift.h
@@ -47,9 +47,8 @@ public:
 
     int getMoveSpeed() { return fopAcM_GetParamBit(this, 0x8, 4); }
 
-    static f32 const mSpeed[16];
+    static DUSK_GAME_DATA f32 const mSpeed[16];
 
-private:
     /* 0x5a0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5a8 */ J3DModel* mpModel;
     /* 0x5ac */ u8 field_0x5ac [0x5ae - 0x5ac];
diff --git a/include/d/actor/d_a_obj_magLiftRot.h b/include/d/actor/d_a_obj_magLiftRot.h
index 647fcee80a..04621f7ddc 100644
--- a/include/d/actor/d_a_obj_magLiftRot.h
+++ b/include/d/actor/d_a_obj_magLiftRot.h
@@ -29,7 +29,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ mDoExt_btkAnm mBtk;
diff --git a/include/d/actor/d_a_obj_master_sword.h b/include/d/actor/d_a_obj_master_sword.h
index e99b8832d7..e462e61481 100644
--- a/include/d/actor/d_a_obj_master_sword.h
+++ b/include/d/actor/d_a_obj_master_sword.h
@@ -48,10 +48,9 @@ public:
     u8 getEventID() { return (fopAcM_GetParam(this) >> 0x10) & 0xFF; }
     u16 getFlagNo() { return fopAcM_GetParam(this) & 0xFFFF; }
 
-    static daObjMasterSword_Attr_c const mAttr;
-    static actionFunc ActionTable[];
+    static DUSK_GAME_DATA daObjMasterSword_Attr_c const mAttr;
+    static DUSK_GAME_DATA actionFunc ActionTable[];
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ mDoExt_btkAnm mBtk;
diff --git a/include/d/actor/d_a_obj_metalbox.h b/include/d/actor/d_a_obj_metalbox.h
index b7f2fb10cd..10c6462547 100644
--- a/include/d/actor/d_a_obj_metalbox.h
+++ b/include/d/actor/d_a_obj_metalbox.h
@@ -15,7 +15,7 @@
  *
  */
 class daObjMBox_c : public dBgS_MoveBgActor {
-private:
+public:
     /* 0x5a0 */ request_of_phase_process_class mPhase;
     /* 0x5a8 */ J3DModel* mpModel;
     /* 0x5ac */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_mgate.h b/include/d/actor/d_a_obj_mgate.h
index 5b86c8aa17..9dc0d63114 100644
--- a/include/d/actor/d_a_obj_mgate.h
+++ b/include/d/actor/d_a_obj_mgate.h
@@ -39,7 +39,6 @@ public:
     bool checkLock() { return fopAcM_GetParamBit(this, 5, 1); }
     u8 checkOpen() { return fopAcM_GetParamBit(this, 8, 4); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ request_of_phase_process_class mKeyPhase;
     /* 0x5B0 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_mhole.h b/include/d/actor/d_a_obj_mhole.h
index aa692338d2..c9818708fd 100644
--- a/include/d/actor/d_a_obj_mhole.h
+++ b/include/d/actor/d_a_obj_mhole.h
@@ -36,7 +36,6 @@ public:
     u8 getKind() { return fopAcM_GetParamBit(this, 12, 4); }
     u8 getSwbit() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ mDoExt_brkAnm* mpBrkAnm;
diff --git a/include/d/actor/d_a_obj_mie.h b/include/d/actor/d_a_obj_mie.h
index 0f1df429be..faa413e204 100644
--- a/include/d/actor/d_a_obj_mie.h
+++ b/include/d/actor/d_a_obj_mie.h
@@ -24,7 +24,7 @@ class daObj_Mie_Param_c {
 public:
     virtual ~daObj_Mie_Param_c() {}
 
-    static const daObj_Mie_HIOParam m;
+    static DUSK_GAME_DATA const daObj_Mie_HIOParam m;
 };
 
 #if DEBUG
@@ -54,7 +54,7 @@ public:
  *
  */
 class daObj_Mie_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_MIE_HIO_CLASS* mpHIO;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_obj_mirror_6pole.h b/include/d/actor/d_a_obj_mirror_6pole.h
index 702b1cb66b..1a53d23399 100644
--- a/include/d/actor/d_a_obj_mirror_6pole.h
+++ b/include/d/actor/d_a_obj_mirror_6pole.h
@@ -54,9 +54,8 @@ public:
     inline void callInit();
     inline void callExecute();
 
-    static const actionFunc ActionTable[][2];
+    static DUSK_GAME_DATA const actionFunc ActionTable[][2];
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ mDoExt_bckAnm* mpBck;
     /* 0x570 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_mirror_chain.h b/include/d/actor/d_a_obj_mirror_chain.h
index 106272f116..e04ab228d5 100644
--- a/include/d/actor/d_a_obj_mirror_chain.h
+++ b/include/d/actor/d_a_obj_mirror_chain.h
@@ -47,7 +47,6 @@ public:
     u8 getSwitchNo() { return (fopAcM_GetParam(this) >> 8) & 0xff; }
     void setAnmSpeed(f32 speed) { mpBckAnm->setPlaySpeed(speed); }
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ J3DModel* mpPortalModel;
     /* 0x570 */ mDoExt_bckAnm* mpBckAnm;
diff --git a/include/d/actor/d_a_obj_mirror_sand.h b/include/d/actor/d_a_obj_mirror_sand.h
index db27ccfaeb..ea7a8a6f30 100644
--- a/include/d/actor/d_a_obj_mirror_sand.h
+++ b/include/d/actor/d_a_obj_mirror_sand.h
@@ -37,7 +37,6 @@ public:
                dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[354]);
     }
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ mDoExt_bckAnm* mpBck;
     /* 0x570 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_mirror_screw.h b/include/d/actor/d_a_obj_mirror_screw.h
index feeb6bf294..7cdf294f9b 100644
--- a/include/d/actor/d_a_obj_mirror_screw.h
+++ b/include/d/actor/d_a_obj_mirror_screw.h
@@ -65,7 +65,6 @@ public:
         (this->*mpActionFunc[1])();
     }
 
-private:
     /* 0x5A0 */ J3DModel* mpModel;
     /* 0x5A4 */ request_of_phase_process_class mPhaseReq;
     /* 0x5AC */ daObjMirrorScrew_actionFunc* mpActionFunc;
@@ -80,8 +79,8 @@ private:
     /* 0x5D0 */ u8 field_0x5d0[8];
     /* 0x5D8 */ cBgS_PolyInfo field_0x5d8;
 
-    static attr const M_attr;
-    static daObjMirrorScrew_actionFunc ActionTable[2][2];
+    static DUSK_GAME_DATA attr const M_attr;
+    static DUSK_GAME_DATA daObjMirrorScrew_actionFunc ActionTable[2][2];
 };
 
 STATIC_ASSERT(sizeof(daObjMirrorScrew_c) == 0x5E8);
diff --git a/include/d/actor/d_a_obj_movebox.h b/include/d/actor/d_a_obj_movebox.h
index 0e8bf4e87a..4007a46ecc 100644
--- a/include/d/actor/d_a_obj_movebox.h
+++ b/include/d/actor/d_a_obj_movebox.h
@@ -122,12 +122,12 @@ struct Bgc_c {
     bool chk_wall_touch(daObjMovebox::Act_c const*, daObjMovebox::BgcSrc_c const*, s16);
     bool chk_wall_touch2(daObjMovebox::Act_c const*, daObjMovebox::BgcSrc_c const*, int, s16);
 
-    static const daObjMovebox::BgcSrc_c M_lin5[];
-    static const daObjMovebox::BgcSrc_c M_lin20[];
+    static DUSK_GAME_DATA const daObjMovebox::BgcSrc_c M_lin5[];
+    static DUSK_GAME_DATA const daObjMovebox::BgcSrc_c M_lin20[];
 
-    static dBgS_ObjGndChk M_gnd_work[23];
-    static dBgS_WtrChk M_wrt_work;
-    static dBgS_ObjLinChk M_wall_work[23];
+    static DUSK_GAME_DATA dBgS_ObjGndChk M_gnd_work[23];
+    static DUSK_GAME_DATA dBgS_WtrChk M_wrt_work;
+    static DUSK_GAME_DATA dBgS_ObjLinChk M_wall_work[23];
 
     /* 0x000 */ f32 field_0x0[23];
     /* 0x05C */ int field_0x5c;
@@ -213,11 +213,11 @@ struct Act_c : public dBgS_MoveBgActor {
 
     int getType() { return prm_get_type(); }
 
-    static const s16 M_dir_base[4];
-    static const char* const M_arcname[8];
-    static const dCcD_SrcCyl M_cyl_src;
+    static DUSK_GAME_DATA const s16 M_dir_base[4];
+    static DUSK_GAME_DATA const char* const M_arcname[8];
+    static DUSK_GAME_DATA const dCcD_SrcCyl M_cyl_src;
 
-    static const daObjMovebox::Attr_c M_attr[8];
+    static DUSK_GAME_DATA const daObjMovebox::Attr_c M_attr[8];
 
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_nagaisu.h b/include/d/actor/d_a_obj_nagaisu.h
index 107691d338..2d1e97dd17 100644
--- a/include/d/actor/d_a_obj_nagaisu.h
+++ b/include/d/actor/d_a_obj_nagaisu.h
@@ -29,7 +29,7 @@ public:
         mPos.z = i_pos.z;
     }
 
-    static const dCcD_SrcCyl s_CcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcCyl s_CcDCyl;
 
     /* 0x004 */ dMdl_obj_c mMdlObj;
     /* 0x038 */ Vec mPos;
@@ -59,7 +59,7 @@ public:
     void init();
     void setIsu();
 
-    static const int REMOVE_ISU_IDX[];
+    static DUSK_GAME_DATA const int REMOVE_ISU_IDX[];
 
     /* 0x574 */ J3DModel* mpModel;
     /* 0x578 */ dCcD_Stts mCcStts;
diff --git a/include/d/actor/d_a_obj_nameplate.h b/include/d/actor/d_a_obj_nameplate.h
index 97b313099c..7d5140838a 100644
--- a/include/d/actor/d_a_obj_nameplate.h
+++ b/include/d/actor/d_a_obj_nameplate.h
@@ -40,10 +40,10 @@ public:
         /* 0x1F */ u8 field_0x1F;
     };
 
-    static M_attrs const M_attr;
+    static DUSK_GAME_DATA M_attrs const M_attr;
     static M_attrs const& attr() { return M_attr; }
 
-    static char DUSK_CONST* DUSK_CONST l_arcName;
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST l_arcName;
 
     ~daObjNameplate_c() { dComIfG_resDelete(&this->mPhase, l_arcName); }
 
@@ -51,7 +51,6 @@ public:
     inline int draw();
     inline int createHeap();
 
-private:
     /* 0x568 */ J3DModel* model;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ Mtx mMtx;
diff --git a/include/d/actor/d_a_obj_nan.h b/include/d/actor/d_a_obj_nan.h
index 708d75199e..f1c9881764 100644
--- a/include/d/actor/d_a_obj_nan.h
+++ b/include/d/actor/d_a_obj_nan.h
@@ -42,7 +42,6 @@ public:
     inline int CreateHeap();
     inline int draw();
 
-private:
     /* 0x590 */ request_of_phase_process_class mPhase;
     /* 0x598 */ Z2Creature mCreatureSound;
     /* 0x628 */ mDoExt_McaMorfSO* mMorf;
diff --git a/include/d/actor/d_a_obj_nougu.h b/include/d/actor/d_a_obj_nougu.h
index 3e8e004e36..b8ea5aff06 100644
--- a/include/d/actor/d_a_obj_nougu.h
+++ b/include/d/actor/d_a_obj_nougu.h
@@ -16,7 +16,7 @@ class daObj_Nougu_Param_c {
 public:
     virtual ~daObj_Nougu_Param_c() {}
 
-    static const daObj_Nougu_HIOParam m;
+    static DUSK_GAME_DATA const daObj_Nougu_HIOParam m;
 };
 
 #if DEBUG
@@ -73,7 +73,7 @@ public:
 
     int getType() { return 0; }
 
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 };
 
 STATIC_ASSERT(sizeof(daObj_Nougu_c) == 0xe30);
diff --git a/include/d/actor/d_a_obj_octhashi.h b/include/d/actor/d_a_obj_octhashi.h
index 4b5ef5459a..9bb21ce9a4 100644
--- a/include/d/actor/d_a_obj_octhashi.h
+++ b/include/d/actor/d_a_obj_octhashi.h
@@ -33,7 +33,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5a0 */ cXyz field_0x5a0[8];
     /* 0x600 */ cXyz field_0x600[8];
     /* 0x660 */ csXyz field_0x660[8];
@@ -53,7 +52,6 @@ private:
 public:
     /* 0x6e8 */ s16 field_0x6e8;
     /* 0x6ec */ Z2Creature mSound;
-private:
     /* 0x077c */ u8 field_0x77c[4];
     /* 0x0780 */ J3DModel* mpModel[8];
     /* 0x07a0 */ u8 field_0x7a0[0x7a4 - 0x7a0];
diff --git a/include/d/actor/d_a_obj_oiltubo.h b/include/d/actor/d_a_obj_oiltubo.h
index fa1dc47fd9..58aeba161d 100644
--- a/include/d/actor/d_a_obj_oiltubo.h
+++ b/include/d/actor/d_a_obj_oiltubo.h
@@ -33,10 +33,9 @@ public:
     BOOL chkEvent();
     int wait(void*);
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl DUSK_CONST mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl DUSK_CONST mCcDCyl;
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ J3DModel* mpBModel;
diff --git a/include/d/actor/d_a_obj_onsen.h b/include/d/actor/d_a_obj_onsen.h
index 64af56f1d5..43ba02bc25 100644
--- a/include/d/actor/d_a_obj_onsen.h
+++ b/include/d/actor/d_a_obj_onsen.h
@@ -25,7 +25,6 @@ public:
 
     u32 getType() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel[2];
     /* 0x5B0 */ mDoExt_btkAnm* mpBtk;
diff --git a/include/d/actor/d_a_obj_onsenTaru.h b/include/d/actor/d_a_obj_onsenTaru.h
index c7e992bb11..98c6d40aee 100644
--- a/include/d/actor/d_a_obj_onsenTaru.h
+++ b/include/d/actor/d_a_obj_onsenTaru.h
@@ -52,8 +52,8 @@ public:
     bool getTempStat() { return mTempStat; }
     void startTimer() { mStartTimer = true; }
     
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_ornament_cloth.h b/include/d/actor/d_a_obj_ornament_cloth.h
index e0ea54b63d..69f509ebb3 100644
--- a/include/d/actor/d_a_obj_ornament_cloth.h
+++ b/include/d/actor/d_a_obj_ornament_cloth.h
@@ -61,7 +61,7 @@ public:
 
     const daObjOnCloth_Attr_c& attr() const { return M_attr; }
 
-    static daObjOnCloth_Attr_c const M_attr;
+    static DUSK_GAME_DATA daObjOnCloth_Attr_c const M_attr;
 
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ mDoExt_btkAnm* mBtkAnm;
diff --git a/include/d/actor/d_a_obj_pdtile.h b/include/d/actor/d_a_obj_pdtile.h
index 1dcb327acc..05e04063aa 100644
--- a/include/d/actor/d_a_obj_pdtile.h
+++ b/include/d/actor/d_a_obj_pdtile.h
@@ -35,7 +35,6 @@ public:
 
     u8 getType() { return fopAcM_GetParamBit(this, 0, 4); }
 
-private:
     /* 0x5A8 */ Mtx mBgMtx;
     /* 0x5D8 */ Mtx field_0x5d8;
     /* 0x608 */ J3DModel* mModel;
diff --git a/include/d/actor/d_a_obj_pdwall.h b/include/d/actor/d_a_obj_pdwall.h
index 45e8213f39..698ac6a6bb 100644
--- a/include/d/actor/d_a_obj_pdwall.h
+++ b/include/d/actor/d_a_obj_pdwall.h
@@ -26,7 +26,6 @@ public:
 
     int getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A8 */ Mtx field_0x5a8;
     /* 0x5D8 */ J3DModel* mpModels[10];
     /* 0x600 */ Mtx field_0x600[10];
diff --git a/include/d/actor/d_a_obj_picture.h b/include/d/actor/d_a_obj_picture.h
index 3460b60077..af175f93e9 100644
--- a/include/d/actor/d_a_obj_picture.h
+++ b/include/d/actor/d_a_obj_picture.h
@@ -39,13 +39,12 @@ public:
 #if DEBUG
     const
 #endif
-    static dCcD_SrcCps s_CcDCps;
+    static DUSK_GAME_DATA dCcD_SrcCps s_CcDCps;
 #if DEBUG
     const
 #endif
-    static dCcD_SrcCyl s_CcDCyl_pic_at;
+    static DUSK_GAME_DATA dCcD_SrcCyl s_CcDCyl_pic_at;
 
-private:
     /* 0x574 */ dCcD_Stts field_0x574;
     /* 0x5B0 */ dCcD_Stts field_0x5b0;
     /* 0x5EC */ dCcD_Stts field_0x5ec;
diff --git a/include/d/actor/d_a_obj_pleaf.h b/include/d/actor/d_a_obj_pleaf.h
index 3571bb4026..12f14a2bad 100644
--- a/include/d/actor/d_a_obj_pleaf.h
+++ b/include/d/actor/d_a_obj_pleaf.h
@@ -15,7 +15,7 @@ class daObj_Pleaf_Param_c {
 public:
     virtual ~daObj_Pleaf_Param_c() {}
 
-    static daObj_Pleaf_HIOParam const m;
+    static DUSK_GAME_DATA daObj_Pleaf_HIOParam const m;
 };
 
 #if DEBUG
@@ -44,7 +44,7 @@ public:
  *
  */
 class daObj_Pleaf_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_PLEAF_HIO_CLASS* mpHIO;
     /* 0x56C */ request_of_phase_process_class mPhaseReq;
     /* 0x574 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_poCandle.h b/include/d/actor/d_a_obj_poCandle.h
index defcdb7858..c76356d2df 100644
--- a/include/d/actor/d_a_obj_poCandle.h
+++ b/include/d/actor/d_a_obj_poCandle.h
@@ -48,7 +48,6 @@ public:
     u8 getIDNum() { return mIDNum; }
     void setFireFlag(u8 flag) { mFireFlag = flag; }
 
-private:
     /* 0x5B8 */ request_of_phase_process_class mPhase;
     /* 0x5C0 */ J3DModel* mpModel;
     /* 0x5C4 */ cXyz mFirePos;
diff --git a/include/d/actor/d_a_obj_poFire.h b/include/d/actor/d_a_obj_poFire.h
index b8c9198b7c..10a91cbf34 100644
--- a/include/d/actor/d_a_obj_poFire.h
+++ b/include/d/actor/d_a_obj_poFire.h
@@ -68,7 +68,6 @@ public:
     u8 getMoveEnd() { return mMoveEnd; }
     u32 getID() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x584 */ request_of_phase_process_class mPhase;
     /* 0x58C */ int mStaffID;
     /* 0x590 */ s16 unk590;
diff --git a/include/d/actor/d_a_obj_poTbox.h b/include/d/actor/d_a_obj_poTbox.h
index 714f7338d3..44b18117e6 100644
--- a/include/d/actor/d_a_obj_poTbox.h
+++ b/include/d/actor/d_a_obj_poTbox.h
@@ -33,7 +33,6 @@ public:
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
     int getStat() { return fopAcM_GetParamBit(this, 8, 4); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpBoxModel;
     /* 0x5AC */ J3DModel* mpAnimModel;
diff --git a/include/d/actor/d_a_obj_prop.h b/include/d/actor/d_a_obj_prop.h
index d61025630b..157f8dde6b 100644
--- a/include/d/actor/d_a_obj_prop.h
+++ b/include/d/actor/d_a_obj_prop.h
@@ -26,7 +26,6 @@ public:
     u32 getNameArg_0() { return fopAcM_GetParamBit(this, 0, 4); }
     u32 getArg_0() { return fopAcM_GetParamBit(this, 4, 4); }
 
-private:
     /* 0x574 */ J3DModel* mpModel;
     /* 0x578 */ u8 mArg;
 };
diff --git a/include/d/actor/d_a_obj_pumpkin.h b/include/d/actor/d_a_obj_pumpkin.h
index b1b36bfa1f..74ba8f3026 100644
--- a/include/d/actor/d_a_obj_pumpkin.h
+++ b/include/d/actor/d_a_obj_pumpkin.h
@@ -28,7 +28,7 @@ class daObj_Pumpkin_Param_c {
 public:
     virtual ~daObj_Pumpkin_Param_c() {}
 
-    static const daObj_Pumpkin_HIOParam m;
+    static DUSK_GAME_DATA const daObj_Pumpkin_HIOParam m;
 };
 
 #if DEBUG
@@ -56,7 +56,7 @@ public:
  *
  */
 class daObj_Pumpkin_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_PUMPKIN_HIO_CLASS* mpHIO;
     /* 0x56C */ request_of_phase_process_class mPhaseReq;
     /* 0x574 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_rcircle.h b/include/d/actor/d_a_obj_rcircle.h
index 43811a0702..5ef1324f2c 100644
--- a/include/d/actor/d_a_obj_rcircle.h
+++ b/include/d/actor/d_a_obj_rcircle.h
@@ -25,7 +25,6 @@ public:
 
     int getSwBit() { return fopAcM_GetParamBit(this, 0, 8) & 0xFF; }
 
-private:
     /* 0x574 */ mDoExt_brkAnm mBrk;
     /* 0x58C */ mDoExt_btkAnm mBtk;
     /* 0x5A4 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_rfHole.h b/include/d/actor/d_a_obj_rfHole.h
index d053d6800c..00a873229c 100644
--- a/include/d/actor/d_a_obj_rfHole.h
+++ b/include/d/actor/d_a_obj_rfHole.h
@@ -42,7 +42,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_rope_bridge.h b/include/d/actor/d_a_obj_rope_bridge.h
index 90532c9ba7..8eababd778 100644
--- a/include/d/actor/d_a_obj_rope_bridge.h
+++ b/include/d/actor/d_a_obj_rope_bridge.h
@@ -44,7 +44,6 @@ public:
     u8 getSwbit2() { return fopAcM_GetParamBit(this, 24, 8); }
     u8 getType() { return fopAcM_GetParamBit(this, 16, 2); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ request_of_phase_process_class mRopePhase;
     /* 0x5B0 */ J3DModel* mpBrgModel;
diff --git a/include/d/actor/d_a_obj_rotTrap.h b/include/d/actor/d_a_obj_rotTrap.h
index 4b7b669afc..069bfe285c 100644
--- a/include/d/actor/d_a_obj_rotTrap.h
+++ b/include/d/actor/d_a_obj_rotTrap.h
@@ -34,10 +34,9 @@ public:
 
     int getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x05A0 */ request_of_phase_process_class mPhase;
     /* 0x05A8 */ J3DModel* mpModel;
     /* 0x05AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_roten.h b/include/d/actor/d_a_obj_roten.h
index 9b4b17a19d..ea78731b77 100644
--- a/include/d/actor/d_a_obj_roten.h
+++ b/include/d/actor/d_a_obj_roten.h
@@ -25,7 +25,6 @@ public:
     char DUSK_CONST* getResName();
     virtual ~daObj_Roten_c();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ JPABaseEmitter* mEmitters[2];
diff --git a/include/d/actor/d_a_obj_rstair.h b/include/d/actor/d_a_obj_rstair.h
index 053692ba9e..6c31ff4648 100644
--- a/include/d/actor/d_a_obj_rstair.h
+++ b/include/d/actor/d_a_obj_rstair.h
@@ -58,7 +58,6 @@ public:
     u8 getEventID() { return fopAcM_GetParamBit(this, 0, 8); }
     void setAction(u8 action) { mAction = action; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ J3DModel* mWaterModels[2];
diff --git a/include/d/actor/d_a_obj_saidan.h b/include/d/actor/d_a_obj_saidan.h
index ef38588f00..f421cf55ad 100644
--- a/include/d/actor/d_a_obj_saidan.h
+++ b/include/d/actor/d_a_obj_saidan.h
@@ -35,7 +35,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_sakuita.h b/include/d/actor/d_a_obj_sakuita.h
index 29b101586d..621084a592 100644
--- a/include/d/actor/d_a_obj_sakuita.h
+++ b/include/d/actor/d_a_obj_sakuita.h
@@ -43,9 +43,8 @@ public:
 
     const daObjSakuita_Attr_c& attr() const { return M_attr; }
 
-    static daObjSakuita_Attr_c const M_attr;
+    static DUSK_GAME_DATA daObjSakuita_Attr_c const M_attr;
 
-private:
     /* 0x568 */ J3DModel* mModel;
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ Mtx mMtx;
diff --git a/include/d/actor/d_a_obj_sakuita_rope.h b/include/d/actor/d_a_obj_sakuita_rope.h
index 9567b7f25f..37df115ea9 100644
--- a/include/d/actor/d_a_obj_sakuita_rope.h
+++ b/include/d/actor/d_a_obj_sakuita_rope.h
@@ -80,9 +80,8 @@ public:
         return field_0x62c * (pos->z - getRopeStartPos()->z);
     }
 
-    static daObjItaRope_Attr_c const M_attr;
+    static DUSK_GAME_DATA daObjItaRope_Attr_c const M_attr;
 
-private:
     /* 0x570 */ mDoExt_3DlineMat1_c mLineMat;
     /* 0x5A4 */ request_of_phase_process_class mPhase;
     /* 0x5AC */ Mtx mMtx;
diff --git a/include/d/actor/d_a_obj_scannon.h b/include/d/actor/d_a_obj_scannon.h
index 9aa871bd77..e376f55d40 100644
--- a/include/d/actor/d_a_obj_scannon.h
+++ b/include/d/actor/d_a_obj_scannon.h
@@ -76,14 +76,13 @@ public:
     int getSw1() { return fopAcM_GetParamBit(this, 0, 8); }
     int getSw2() { return fopAcM_GetParamBit(this, 8, 8); }
 
-    static const demoTable_s s_demoTable[];
-    static void (daSCannon_c::*DUSK_CONST s_exeProc[])();
-    static void (daSCannon_c::*DUSK_CONST s_demoExeProc_WarpEnd[][2])();
-    static void (daSCannon_c::*DUSK_CONST s_demoExeProc_FireTks[][2])();
-    static void (daSCannon_c::*DUSK_CONST s_demoExeProc_FireFirst[][2])();
-    static void (daSCannon_c::*DUSK_CONST s_demoExeProc_FireSecond[][2])();
+    static DUSK_GAME_DATA const demoTable_s s_demoTable[];
+    static DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST s_exeProc[])();
+    static DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST s_demoExeProc_WarpEnd[][2])();
+    static DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST s_demoExeProc_FireTks[][2])();
+    static DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST s_demoExeProc_FireFirst[][2])();
+    static DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST s_demoExeProc_FireSecond[][2])();
 
-private:
     /* 0x574 */ request_of_phase_process_class mZevPhase;
     /* 0x57C */ request_of_phase_process_class mPtlPhase;
     /* 0x584 */ mDoExt_bckAnm mBck;
diff --git a/include/d/actor/d_a_obj_scannon_crs.h b/include/d/actor/d_a_obj_scannon_crs.h
index e390c60128..12369f58fd 100644
--- a/include/d/actor/d_a_obj_scannon_crs.h
+++ b/include/d/actor/d_a_obj_scannon_crs.h
@@ -49,9 +49,8 @@ public:
     int getWarpId() { return fopAcM_GetParamBit(this, 8, 8); }
     u16 getMsgId() { return home.angle.x; }
 
-    static void (daSCannonCrs_c::*s_exeProc[])(daMidna_c*);
+    static DUSK_GAME_DATA void (daSCannonCrs_c::*s_exeProc[])(daMidna_c*);
 
-private:
     /* 0x574 */ cXyz mPortalWaitPos;
     /* 0x580 */ dMsgFlow_c mMsgFlow;
     /* 0x5CC */ mDoExt_bckAnm mBck;
diff --git a/include/d/actor/d_a_obj_scannon_ten.h b/include/d/actor/d_a_obj_scannon_ten.h
index 503a1e0522..ce6c840cfe 100644
--- a/include/d/actor/d_a_obj_scannon_ten.h
+++ b/include/d/actor/d_a_obj_scannon_ten.h
@@ -57,10 +57,9 @@ public:
     void exeEmtLine();
     void delEmtAll();
 
-    static const ExeProc s_exeProc[];
-    static const ExeProc s_demoExeProc[][2];
+    static DUSK_GAME_DATA const ExeProc s_exeProc[];
+    static DUSK_GAME_DATA const ExeProc s_demoExeProc[][2];
 
-private:
     /* 0x574 */ J3DModel* mpModel;
     /* 0x578 */ mDoExt_bckAnm mBck;
     /* 0x594 */ dBgW* mpBgW;
diff --git a/include/d/actor/d_a_obj_sekidoor.h b/include/d/actor/d_a_obj_sekidoor.h
index ae4ff9acd4..8f2791a673 100644
--- a/include/d/actor/d_a_obj_sekidoor.h
+++ b/include/d/actor/d_a_obj_sekidoor.h
@@ -14,7 +14,7 @@ class daObj_SekiDoor_Param_c {
 public:
     virtual ~daObj_SekiDoor_Param_c() {};
 
-    static daObj_SekiDoor_HIOParam const m;
+    static DUSK_GAME_DATA daObj_SekiDoor_HIOParam const m;
 };
 
 #if DEBUG
@@ -59,7 +59,6 @@ public:
     void open() { mOpening = true; }
     bool chkDestroy() { return (mDestroyed == true); }
 
-private:
     /* 0x5A0 */ OBJ_SEKIDOOR_HIO_CLASS* mpHIO;
     /* 0x5A4 */ request_of_phase_process_class mPhaseReq;
     /* 0x5AC */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_sekizo.h b/include/d/actor/d_a_obj_sekizo.h
index 54fa84f5df..2011417a96 100644
--- a/include/d/actor/d_a_obj_sekizo.h
+++ b/include/d/actor/d_a_obj_sekizo.h
@@ -10,7 +10,7 @@ struct daObj_Sekizo_HIOParam {
 class daObj_Sekizo_Param_c {
 public:
     virtual ~daObj_Sekizo_Param_c() {}
-    static daObj_Sekizo_HIOParam const m;
+    static DUSK_GAME_DATA daObj_Sekizo_HIOParam const m;
 };
 
 #if DEBUG
@@ -50,7 +50,6 @@ public:
     void initBaseMtx();
     void setBaseMtx();
 
-private:
     /* 0x5A0 */ OBJ_SEKIZO_HIO_CLASS* mpHIO;
     /* 0x5A4 */ request_of_phase_process_class mPhaseReq;
     /* 0x5AC */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_sekizoa.h b/include/d/actor/d_a_obj_sekizoa.h
index ce924915e1..b5c6abd9c3 100644
--- a/include/d/actor/d_a_obj_sekizoa.h
+++ b/include/d/actor/d_a_obj_sekizoa.h
@@ -57,7 +57,7 @@ class daObj_Sekizoa_Param_c {
 public:
     virtual ~daObj_Sekizoa_Param_c() {}
 
-    static daObj_Sekizoa_HIOParam const m;
+    static DUSK_GAME_DATA daObj_Sekizoa_HIOParam const m;
 };
 
 #if DEBUG
@@ -268,8 +268,8 @@ public:
                               -300.0f, 0);
     }
 
-    static char DUSK_CONST* DUSK_CONST mCutNameList[9];
-    static cutFunc DUSK_CONST mCutList[9];
+    static DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST mCutNameList[9];
+    static DUSK_GAME_DATA cutFunc DUSK_CONST mCutList[9];
 
     /* 0x0E40 */ mDoExt_McaMorfSO* mpMcaMorf;
     /* 0x0E44 */ mDoExt_invisibleModel mInvModel;
diff --git a/include/d/actor/d_a_obj_shield.h b/include/d/actor/d_a_obj_shield.h
index 11b4a2668d..248c26be5b 100644
--- a/include/d/actor/d_a_obj_shield.h
+++ b/include/d/actor/d_a_obj_shield.h
@@ -59,7 +59,6 @@ public:
     void setStatus(u8 status) { mStatus = status; }
     void setAction(u8 action) { mAction = action; }
 
-private:
     /* 0x92C */ fpc_ProcID mItemId;
     /* 0x930 */ int mRotAngleCoeff;
     /* 0x934 */ u8 mStatus;
diff --git a/include/d/actor/d_a_obj_sm_door.h b/include/d/actor/d_a_obj_sm_door.h
index bec15a0ae8..bd6553c0d2 100644
--- a/include/d/actor/d_a_obj_sm_door.h
+++ b/include/d/actor/d_a_obj_sm_door.h
@@ -31,7 +31,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ bool mUseAlphaModel;
     /* 0x5A1 */ u8 field_0x5a1[0x5AC - 0x5A1];
     /* 0x5AC */ s16 mMode;
@@ -54,5 +53,4 @@ private:
 
 STATIC_ASSERT(sizeof(daObjSM_DOOR_c) == 0x858);
 
-
 #endif /* D_A_OBJ_SM_DOOR_H */
diff --git a/include/d/actor/d_a_obj_smallkey.h b/include/d/actor/d_a_obj_smallkey.h
index 2becc9bae2..7bf38de4af 100644
--- a/include/d/actor/d_a_obj_smallkey.h
+++ b/include/d/actor/d_a_obj_smallkey.h
@@ -14,7 +14,7 @@
  *
  */
 class daKey_c : public daItemBase_c {
-private:
+public:
     void seStartTwinkle_private(u32);
 
 public:
diff --git a/include/d/actor/d_a_obj_smgdoor.h b/include/d/actor/d_a_obj_smgdoor.h
index aad2800ece..b22734b3e3 100644
--- a/include/d/actor/d_a_obj_smgdoor.h
+++ b/include/d/actor/d_a_obj_smgdoor.h
@@ -53,7 +53,6 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel[2];
     /* 0x5B0 */ s16 field_0x5b0;
diff --git a/include/d/actor/d_a_obj_smoke.h b/include/d/actor/d_a_obj_smoke.h
index 61a3b56a51..abd172afbe 100644
--- a/include/d/actor/d_a_obj_smoke.h
+++ b/include/d/actor/d_a_obj_smoke.h
@@ -24,7 +24,6 @@ public:
     int execute();
     int _delete();
 
-private:
     /* 0x568 */ JPABaseEmitter* mParticle;
 };
 
diff --git a/include/d/actor/d_a_obj_smtile.h b/include/d/actor/d_a_obj_smtile.h
index 1832a7c4b8..c85000e7b8 100644
--- a/include/d/actor/d_a_obj_smtile.h
+++ b/include/d/actor/d_a_obj_smtile.h
@@ -12,7 +12,7 @@ class daObj_SMTile_Param_c {
 public:
     virtual ~daObj_SMTile_Param_c() {}
 
-    static daObj_SMTile_HIOParam const m;
+    static DUSK_GAME_DATA daObj_SMTile_HIOParam const m;
 };
 
 #if DEBUG
@@ -41,7 +41,7 @@ public:
  *
  */
 class daObj_SMTile_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ mDoExt_brkAnm mBrk;
     /* 0x580 */ OBJ_SMTILE_HIO_CLASS* mpHIO;
     /* 0x584 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_smw_stone.h b/include/d/actor/d_a_obj_smw_stone.h
index 02f58284ff..05913cd339 100644
--- a/include/d/actor/d_a_obj_smw_stone.h
+++ b/include/d/actor/d_a_obj_smw_stone.h
@@ -29,7 +29,6 @@ public:
     u8 getSwBit0() { return fopAcM_GetParamBit(this, 0, 8); }
     void deleteStone() { mDelete = true; }
 
-private:
     /* 0x574 */ cBgS_PolyInfo mPolyInfo;
     /* 0x584 */ J3DModel* mpModel;
     /* 0x588 */ dBgW* mpBgW;
diff --git a/include/d/actor/d_a_obj_snowEffTag.h b/include/d/actor/d_a_obj_snowEffTag.h
index 748106cc81..bc995c749c 100644
--- a/include/d/actor/d_a_obj_snowEffTag.h
+++ b/include/d/actor/d_a_obj_snowEffTag.h
@@ -23,7 +23,6 @@ public:
 
     int getArg0() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ bool mPlayedSound;
     /* 0x56C */ f32 mMaxSize;
diff --git a/include/d/actor/d_a_obj_snow_soup.h b/include/d/actor/d_a_obj_snow_soup.h
index 91c23c8f85..3b96cd566f 100644
--- a/include/d/actor/d_a_obj_snow_soup.h
+++ b/include/d/actor/d_a_obj_snow_soup.h
@@ -28,7 +28,6 @@ public:
     void createSmkEmtChange(int);
     void deleteSmkEmtChange(int);
 
-private:
     /* 0x574 */ cXyz mFirewoodPos;
     /* 0x580 */ cXyz mBubblePos;
     /* 0x58C */ JPABaseEmitter* mpSmkEmtCommon[4];
diff --git a/include/d/actor/d_a_obj_spinLift.h b/include/d/actor/d_a_obj_spinLift.h
index 548df3f910..d2f0a50b03 100644
--- a/include/d/actor/d_a_obj_spinLift.h
+++ b/include/d/actor/d_a_obj_spinLift.h
@@ -40,7 +40,6 @@ public:
     u8 getTimer() { return (current.angle.x & 0xff00) >> 8; }
     int getEndSw() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 field_0x5ac;
diff --git a/include/d/actor/d_a_obj_ss_base.h b/include/d/actor/d_a_obj_ss_base.h
index 4d275a43cd..2101dd3237 100644
--- a/include/d/actor/d_a_obj_ss_base.h
+++ b/include/d/actor/d_a_obj_ss_base.h
@@ -18,7 +18,6 @@ public:
     u16 getValueNumber() { return mValueNum; }
     void setValueNumber(u16 valueNum) { mValueNum = valueNum; }
 
-private:
     /* 0x56C */ void* mpParentPtr;
     /* 0x570 */ u16 field_0x570;
     /* 0x572 */ u16 mFlowNodeNum;
diff --git a/include/d/actor/d_a_obj_ss_drink.h b/include/d/actor/d_a_obj_ss_drink.h
index c20992163b..c4c0a1a72b 100644
--- a/include/d/actor/d_a_obj_ss_drink.h
+++ b/include/d/actor/d_a_obj_ss_drink.h
@@ -47,10 +47,9 @@ public:
     virtual ~daObj_SSDrink_c();
     virtual void setSoldOut();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl DUSK_CONST mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl DUSK_CONST mCcDCyl;
 
-private:
     /* 0x578 */ mDoExt_btpAnm* mpBtpAnm;
     /* 0x57C */ mDoExt_brkAnm* mpBrkAnm;
     /* 0x580 */ u8 field_0x580;
diff --git a/include/d/actor/d_a_obj_ss_item.h b/include/d/actor/d_a_obj_ss_item.h
index 2b05046e28..59f8f56407 100644
--- a/include/d/actor/d_a_obj_ss_item.h
+++ b/include/d/actor/d_a_obj_ss_item.h
@@ -46,10 +46,9 @@ public:
     int buy(void* param_0);
     int cancel(void* param_0);
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl DUSK_CONST mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl DUSK_CONST mCcDCyl;
 
-private:
     /* 0x578 */ request_of_phase_process_class mPhase;
     /* 0x580 */ J3DModel* mpModel;
     /* 0x584 */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_stairBlock.h b/include/d/actor/d_a_obj_stairBlock.h
index 63a0c5b178..1b04d0bcc1 100644
--- a/include/d/actor/d_a_obj_stairBlock.h
+++ b/include/d/actor/d_a_obj_stairBlock.h
@@ -23,10 +23,9 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 
-private:
     /* 0x056C */ request_of_phase_process_class mPhaseReq;
     /* 0x0574 */ J3DModel* mpModel[10];
     /* 0x059C */ mDoExt_bckAnm mBckAnm[10];
diff --git a/include/d/actor/d_a_obj_stick.h b/include/d/actor/d_a_obj_stick.h
index fe43aabd15..ce72273254 100644
--- a/include/d/actor/d_a_obj_stick.h
+++ b/include/d/actor/d_a_obj_stick.h
@@ -16,7 +16,7 @@ class daObj_Stick_Param_c {
 public:
     virtual ~daObj_Stick_Param_c() {}
 
-    static const daObj_Stick_HIOParam m;
+    static DUSK_GAME_DATA const daObj_Stick_HIOParam m;
 };
 
 #if DEBUG
@@ -45,7 +45,7 @@ public:
  *
  */
 class daObj_Stick_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ OBJ_STICK_HIO_CLASS* mpHIO;
     /* 0x56c */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mpModel;
@@ -73,7 +73,7 @@ public:
 
     u32 getType() { return 0; }
 
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 };
 
 STATIC_ASSERT(sizeof(daObj_Stick_c) == 0x950);
diff --git a/include/d/actor/d_a_obj_stone.h b/include/d/actor/d_a_obj_stone.h
index b5f4da8c39..dfeb11f539 100644
--- a/include/d/actor/d_a_obj_stone.h
+++ b/include/d/actor/d_a_obj_stone.h
@@ -56,7 +56,6 @@ public:
     int draw();
     int _delete();
 
-private:
     /* 0x0568 */ request_of_phase_process_class mPhase;
     /* 0x0570 */ J3DModel* mpModel;
     /* 0x0574 */ dBgS_ObjAcch mChkObj;
diff --git a/include/d/actor/d_a_obj_stoneMark.h b/include/d/actor/d_a_obj_stoneMark.h
index fbe56ce31d..04540fd9c7 100644
--- a/include/d/actor/d_a_obj_stoneMark.h
+++ b/include/d/actor/d_a_obj_stoneMark.h
@@ -23,7 +23,6 @@ public:
     int draw();
     int _delete();
 
-private:
     /* 0x0568 */ request_of_phase_process_class mpPhase;
     /* 0x0570 */ TGXTexObj mTexObj;
     /* 0x0590 */ dBgS_ObjAcch mObjAcch;
diff --git a/include/d/actor/d_a_obj_stopper.h b/include/d/actor/d_a_obj_stopper.h
index 9a100c754b..62eda0ae39 100644
--- a/include/d/actor/d_a_obj_stopper.h
+++ b/include/d/actor/d_a_obj_stopper.h
@@ -59,7 +59,6 @@ public:
     u8 getSwNo() { return fopAcM_GetParamBit(this, 0, 8); }
     u8 getSwNo2() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x5A0 */ u8 field_0x5a0[8];  // unused
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_stopper2.h b/include/d/actor/d_a_obj_stopper2.h
index 7ec86cb818..ccae3af298 100644
--- a/include/d/actor/d_a_obj_stopper2.h
+++ b/include/d/actor/d_a_obj_stopper2.h
@@ -35,7 +35,6 @@ public:
     u32 getSwbit() { return fopAcM_GetParamBit(this, 0, 8); }
     void setAction(u8 i_action) { mAction = i_action; }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ f32 mOffsetY;
diff --git a/include/d/actor/d_a_obj_suisya.h b/include/d/actor/d_a_obj_suisya.h
index c92146f5af..59067d84a4 100644
--- a/include/d/actor/d_a_obj_suisya.h
+++ b/include/d/actor/d_a_obj_suisya.h
@@ -20,7 +20,6 @@ public:
     int CreateHeap();
     int create();
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ u32 mShadowKey;
diff --git a/include/d/actor/d_a_obj_swBallA.h b/include/d/actor/d_a_obj_swBallA.h
index 1785565a4e..910c031050 100644
--- a/include/d/actor/d_a_obj_swBallA.h
+++ b/include/d/actor/d_a_obj_swBallA.h
@@ -41,7 +41,6 @@ public:
     void onFlag(u8 idx, u8 val) { field_0x5af[idx] |= val; }
     u8 checkFlag(u8 idx, u8 val) { return field_0x5af[idx] & val; }
 
-private:
     /* 0x57C */ request_of_phase_process_class field_0x57c;
     /* 0x584 */ J3DModel* mModel;
     /* 0x588 */ mDoExt_btkAnm* field_0x588;
diff --git a/include/d/actor/d_a_obj_swBallB.h b/include/d/actor/d_a_obj_swBallB.h
index 31a7971232..31a8f4210e 100644
--- a/include/d/actor/d_a_obj_swBallB.h
+++ b/include/d/actor/d_a_obj_swBallB.h
@@ -44,7 +44,6 @@ public:
     void setLightOn() { field_0x5ac = 1; }
     void setLightOff() { field_0x5ad = 1; }
 
-private:
     /* 0x57C */ request_of_phase_process_class field_0x57c;
     /* 0x584 */ J3DModel* mModel;
     /* 0x588 */ mDoExt_btkAnm* field_0x588;
diff --git a/include/d/actor/d_a_obj_swLight.h b/include/d/actor/d_a_obj_swLight.h
index 1a9fc50cca..9d84030e96 100644
--- a/include/d/actor/d_a_obj_swLight.h
+++ b/include/d/actor/d_a_obj_swLight.h
@@ -47,7 +47,6 @@ public:
     u8 getOnTime() { return fopAcM_GetParamBit(this, 16, 8); }
     u8 getEvent() { return (u8)field_0xb22; }
 
-private:
     /* 0x5B0 */ request_of_phase_process_class mPhase;
     /* 0x5B8 */ J3DModel* mpModel;
     /* 0x6F4 */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_swchain.h b/include/d/actor/d_a_obj_swchain.h
index 270fb8f5ab..8bd68b4478 100644
--- a/include/d/actor/d_a_obj_swchain.h
+++ b/include/d/actor/d_a_obj_swchain.h
@@ -80,7 +80,6 @@ public:
         return FALSE;
     }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ J3DModelData* mChainModelData;
diff --git a/include/d/actor/d_a_obj_swhang.h b/include/d/actor/d_a_obj_swhang.h
index 097da890b3..37ddbb3ea2 100644
--- a/include/d/actor/d_a_obj_swhang.h
+++ b/include/d/actor/d_a_obj_swhang.h
@@ -78,7 +78,6 @@ public:
     u16 checkFlag(u16 flag) { return mFlags & flag; }
     s16 getAngleY() { return shape_angle.y; }
 
-private:
     /* 0x5B0 */ request_of_phase_process_class mPhase;
     /* 0x5B8 */ J3DModel* mpModel;
     /* 0x5BC */ dCcD_Stts mCcStts;
diff --git a/include/d/actor/d_a_obj_sword.h b/include/d/actor/d_a_obj_sword.h
index 163175ddec..63bc7d576a 100644
--- a/include/d/actor/d_a_obj_sword.h
+++ b/include/d/actor/d_a_obj_sword.h
@@ -31,7 +31,6 @@ public:
     u8 getSwbit() { return fopAcM_GetParamBit(this, 8, 8); }
     void setStatus(u8 status) { mStatus = status; }
 
-private:
     /* 0x92c */ u32 field_0x92c;
     /* 0x930 */ fpc_ProcID mProcID;
     /* 0x934 */ u8 mStatus;
diff --git a/include/d/actor/d_a_obj_swpush.h b/include/d/actor/d_a_obj_swpush.h
index 5c73d2b310..77b7557d69 100644
--- a/include/d/actor/d_a_obj_swpush.h
+++ b/include/d/actor/d_a_obj_swpush.h
@@ -142,12 +142,12 @@ namespace daObjSwpush {
         int Mthd_Execute();
         int Mthd_Draw();
 
-        static s16 const M_bmd[3];
-        static s16 const M_dzb[3];
-        static u32 const M_heap_size[3];
-        static Hio_c::Attr_c const M_attr[5];
-        static u8 const M_op_vtx[4];
-        static DUSK_CONST char* M_arcname[3];
+        static DUSK_GAME_DATA s16 const M_bmd[3];
+        static DUSK_GAME_DATA s16 const M_dzb[3];
+        static DUSK_GAME_DATA u32 const M_heap_size[3];
+        static DUSK_GAME_DATA Hio_c::Attr_c const M_attr[5];
+        static DUSK_GAME_DATA u8 const M_op_vtx[4];
+        static DUSK_GAME_DATA DUSK_CONST char* M_arcname[3];
 
         /* 0x568 */ request_of_phase_process_class mPhase;
         /* 0x570 */ dBgWSv* mpBgW;
diff --git a/include/d/actor/d_a_obj_swpush2.h b/include/d/actor/d_a_obj_swpush2.h
index a99800e4c4..751c35abf6 100644
--- a/include/d/actor/d_a_obj_swpush2.h
+++ b/include/d/actor/d_a_obj_swpush2.h
@@ -128,8 +128,8 @@ namespace daObjSwpush2 {
         void off_switch() const { fopAcM_offSwitch(this, prm_get_swSave()); }
         void rev_switch() const { fopAcM_revSwitch(this, prm_get_swSave()); }
 
-        static const char M_arcname[];
-        static const Attr_c M_attr[4];
+        static DUSK_GAME_DATA const char M_arcname[];
+        static DUSK_GAME_DATA const Attr_c M_attr[4];
 
         #if DEBUG
         static Hio_c M_hio;
diff --git a/include/d/actor/d_a_obj_syRock.h b/include/d/actor/d_a_obj_syRock.h
index 0af85cbaa6..3fa10456f8 100644
--- a/include/d/actor/d_a_obj_syRock.h
+++ b/include/d/actor/d_a_obj_syRock.h
@@ -43,10 +43,9 @@ public:
     int Draw();
     int Delete();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5B8 */ request_of_phase_process_class mPhase;
     /* 0x5C0 */ J3DModel* mpModels[2];
     /* 0x5C8 */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_szbridge.h b/include/d/actor/d_a_obj_szbridge.h
index eff6a17a9c..8702506280 100644
--- a/include/d/actor/d_a_obj_szbridge.h
+++ b/include/d/actor/d_a_obj_szbridge.h
@@ -25,7 +25,6 @@ public:
     int Delete();
     virtual ~daObjSZbridge_c() {}
 
-private:
     /* 0x5A8 */ Mtx mBgMtx;
     /* 0x5D8 */ Mtx field_0x5d8;
     /* 0x608 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_taFence.h b/include/d/actor/d_a_obj_taFence.h
index 5d18cf5cc0..6ab2e31f0a 100644
--- a/include/d/actor/d_a_obj_taFence.h
+++ b/include/d/actor/d_a_obj_taFence.h
@@ -32,8 +32,8 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-    static const dCcD_SrcGObjInf mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA const dCcD_SrcGObjInf mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
     /* 0x05A0 */ request_of_phase_process_class mPhase;
     /* 0x05A8 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_obj_table.h b/include/d/actor/d_a_obj_table.h
index cea036783c..44de1d1a47 100644
--- a/include/d/actor/d_a_obj_table.h
+++ b/include/d/actor/d_a_obj_table.h
@@ -27,7 +27,6 @@ public:
 
     s16 getMessageNo() { return fopAcM_GetParam(this) & 0xFFFF; }
 
-private:
     /* 0x5A0 */ J3DModel* mpModel;
     /* 0x5A4 */ request_of_phase_process_class mPhaseReq;
     /* 0x5AC */ dMsgFlow_c mMsgFlow;
diff --git a/include/d/actor/d_a_obj_takaraDai.h b/include/d/actor/d_a_obj_takaraDai.h
index b745683dd6..657e032bcc 100644
--- a/include/d/actor/d_a_obj_takaraDai.h
+++ b/include/d/actor/d_a_obj_takaraDai.h
@@ -26,7 +26,6 @@ public:
 
     u32 getSwBit() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpBaseModel;
     /* 0x5AC */ J3DModel* mpTopModel;
diff --git a/include/d/actor/d_a_obj_tgake.h b/include/d/actor/d_a_obj_tgake.h
index 1871794df9..6862ad4979 100644
--- a/include/d/actor/d_a_obj_tgake.h
+++ b/include/d/actor/d_a_obj_tgake.h
@@ -28,7 +28,6 @@ public:
     u16 getEventBit2() { return fopAcM_GetParamBit(this, 10, 10); }
     u8 getType() { return fopAcM_GetParamBit(this, 0x14, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u16 mEventBit1;
diff --git a/include/d/actor/d_a_obj_thashi.h b/include/d/actor/d_a_obj_thashi.h
index 3796ee0629..1934b57c56 100644
--- a/include/d/actor/d_a_obj_thashi.h
+++ b/include/d/actor/d_a_obj_thashi.h
@@ -25,8 +25,6 @@ public:
     int Draw();
     int Delete();
 
-// private:
-
     /* 0x5A0  */ dBgW* unk5A0;
     /* 0x5A4  */ u32 unk5A4;
     /* 0x5A8  */ u32 unk5A8;
diff --git a/include/d/actor/d_a_obj_timeFire.h b/include/d/actor/d_a_obj_timeFire.h
index 62fb3460d9..0b7a5ab5ec 100644
--- a/include/d/actor/d_a_obj_timeFire.h
+++ b/include/d/actor/d_a_obj_timeFire.h
@@ -28,7 +28,6 @@ public:
     u8 getEndTime() { return fopAcM_GetParamBit(this, 16, 8); }
     u8 getScale() { return fopAcM_GetParamBit(this, 24, 8); }
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 field_0x569;
     /* 0x56A */ u8 mStartTime;
diff --git a/include/d/actor/d_a_obj_timer.h b/include/d/actor/d_a_obj_timer.h
index 120a23b3a9..5778bf5ca1 100644
--- a/include/d/actor/d_a_obj_timer.h
+++ b/include/d/actor/d_a_obj_timer.h
@@ -54,7 +54,6 @@ class Act_c : public fopAc_ac_c {
             return daObj::PrmAbstract(this, PRM_2, PRM_24);
         }
         
-    private:
         /* 0x568 */ int field_0x568;
         /* 0x56C */ int field_0x56c;
         /* 0x570 */ u8 field_0x570;
diff --git a/include/d/actor/d_a_obj_tks.h b/include/d/actor/d_a_obj_tks.h
index 9d98f8cd0b..2180e99494 100644
--- a/include/d/actor/d_a_obj_tks.h
+++ b/include/d/actor/d_a_obj_tks.h
@@ -17,7 +17,7 @@ class daObjTks_Param_c {
 public:
     virtual ~daObjTks_Param_c() {}
 
-    static const daObjTks_HIOParam m;
+    static DUSK_GAME_DATA const daObjTks_HIOParam m;
 };
 
 #if DEBUG
diff --git a/include/d/actor/d_a_obj_tmoon.h b/include/d/actor/d_a_obj_tmoon.h
index 4bf3c3620c..2992316782 100644
--- a/include/d/actor/d_a_obj_tmoon.h
+++ b/include/d/actor/d_a_obj_tmoon.h
@@ -25,7 +25,6 @@ public:
     u32 getEventBit1() { return fopAcM_GetParamBit(this, 0, 10); }
     u32 getEventBit2() { return fopAcM_GetParamBit(this, 10, 10); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ u16 field_0x574;
diff --git a/include/d/actor/d_a_obj_toaru_maki.h b/include/d/actor/d_a_obj_toaru_maki.h
index 4f7e8d2645..d980f9410f 100644
--- a/include/d/actor/d_a_obj_toaru_maki.h
+++ b/include/d/actor/d_a_obj_toaru_maki.h
@@ -25,7 +25,6 @@ public:
 
     u32 getNameArg_0() { return fopAcM_GetParamBit(this, 0, 4); }
 
-private:
     /* 0x574 */ J3DModel* mpModel;
     /* 0x578 */ dBgW* mpBgW;
     /* 0x57C */ Mtx mMtx;
diff --git a/include/d/actor/d_a_obj_togeTrap.h b/include/d/actor/d_a_obj_togeTrap.h
index 161c958ce0..a67451ea0a 100644
--- a/include/d/actor/d_a_obj_togeTrap.h
+++ b/include/d/actor/d_a_obj_togeTrap.h
@@ -44,10 +44,9 @@ public:
 
     u8 getSwBit() { return fopAcM_GetParamBit(this, 0, 8); }
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
-private:
     /* 0x5A0 */ dCcD_Stts mStts;
     /* 0x5DC */ dCcD_Cyl mCyls[4];
     /* 0xACC */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_obj_tombo.h b/include/d/actor/d_a_obj_tombo.h
index 5dfdcb6451..288d35611e 100644
--- a/include/d/actor/d_a_obj_tombo.h
+++ b/include/d/actor/d_a_obj_tombo.h
@@ -48,7 +48,6 @@ public:
 
     inline int Draw();
 
-private:
     /* 0x590 */ dCcD_Stts mStts;
     /* 0x5CC */ dCcD_Sph mSph;
     /* 0x704 */ daPy_boomerangMove_c mBoomerangMove;
diff --git a/include/d/actor/d_a_obj_tornado.h b/include/d/actor/d_a_obj_tornado.h
index 30e8e2c1e3..c3330d73f9 100644
--- a/include/d/actor/d_a_obj_tornado.h
+++ b/include/d/actor/d_a_obj_tornado.h
@@ -30,7 +30,6 @@ public:
     u8 getTimer() { return fopAcM_GetParamBit(this, 0, 8); }
     u8 getSwbit() { return fopAcM_GetParamBit(this, 0x18, 8); }
 
-private:
     /* 0x568 */ dCcD_Stts mStts;
     /* 0x5A4 */ dCcD_Cps mCps;
     /* 0x6E8 */ cM3dGCpsS mWindCps;
diff --git a/include/d/actor/d_a_obj_twGate.h b/include/d/actor/d_a_obj_twGate.h
index 683a7f18fb..0a00c2b834 100644
--- a/include/d/actor/d_a_obj_twGate.h
+++ b/include/d/actor/d_a_obj_twGate.h
@@ -23,7 +23,6 @@ public:
 
     int getGateType() { return fopAcM_GetParamBit(this, 4, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel;
     /* 0x5AC */ mDoExt_btkAnm mBtk;
diff --git a/include/d/actor/d_a_obj_vground.h b/include/d/actor/d_a_obj_vground.h
index fed893aef1..bd9e266ebf 100644
--- a/include/d/actor/d_a_obj_vground.h
+++ b/include/d/actor/d_a_obj_vground.h
@@ -24,7 +24,6 @@ public:
 
     u32 getSwbit() { return (u8) fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ mDoExt_btkAnm* mpBtk;
diff --git a/include/d/actor/d_a_obj_volcball.h b/include/d/actor/d_a_obj_volcball.h
index ddd299a26e..cb1e895e8f 100644
--- a/include/d/actor/d_a_obj_volcball.h
+++ b/include/d/actor/d_a_obj_volcball.h
@@ -113,7 +113,6 @@ public:
 
     void setAction(u8 i_action) { mMode = i_action; }
 
-private:
     /* 0x057C */ request_of_phase_process_class mPhase;
     /* 0x0584 */ dBgS_AcchCir mAcchCir;
     /* 0x05C4 */ dCcD_Stts mCcStts;
diff --git a/include/d/actor/d_a_obj_volcbom.h b/include/d/actor/d_a_obj_volcbom.h
index 17f9db911d..60401dca2d 100644
--- a/include/d/actor/d_a_obj_volcbom.h
+++ b/include/d/actor/d_a_obj_volcbom.h
@@ -84,7 +84,6 @@ public:
     u8 getArg0() { return fopAcM_GetParamBit(this, 16, 8); }
     u16 getMsgID() { return mMsgID; }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mModel1;
     /* 0x5AC */ mDoExt_btkAnm* mBtk1;
diff --git a/include/d/actor/d_a_obj_waterGate.h b/include/d/actor/d_a_obj_waterGate.h
index 66a076be78..ae81773aec 100644
--- a/include/d/actor/d_a_obj_waterGate.h
+++ b/include/d/actor/d_a_obj_waterGate.h
@@ -33,7 +33,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhase;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_waterPillar.h b/include/d/actor/d_a_obj_waterPillar.h
index 6bcad283da..987abc3923 100644
--- a/include/d/actor/d_a_obj_waterPillar.h
+++ b/include/d/actor/d_a_obj_waterPillar.h
@@ -55,10 +55,10 @@ public:
     int draw();
     int _delete();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcGObjInf const mCcDObjCoInfo;
-    static dCcD_SrcCps mCcDCps;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjCoInfo;
+    static DUSK_GAME_DATA dCcD_SrcCps mCcDCps;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 
     void onRockFlag() {
         mCarryingStalactite = true;
@@ -76,7 +76,6 @@ public:
         mStartStalactiteShake = false;
     }
 
-private:
     /* 0x584 */ request_of_phase_process_class mPhase;
     /* 0x58C */ J3DModel* mpModel;
     /* 0x590 */ mDoExt_btkAnm mVTexScrollAnm;
diff --git a/include/d/actor/d_a_obj_waterfall.h b/include/d/actor/d_a_obj_waterfall.h
index e7c143910d..7a69938455 100644
--- a/include/d/actor/d_a_obj_waterfall.h
+++ b/include/d/actor/d_a_obj_waterfall.h
@@ -24,7 +24,6 @@ public:
     void push_player();
     int draw();
     int _delete();
-private:
     /* 0x568 */ request_of_phase_process_class mPhase;
     /* 0x570 */ u8 pad[4];
     /* 0x574 */ dCcD_Stts mCylColliderStts;
diff --git a/include/d/actor/d_a_obj_wchain.h b/include/d/actor/d_a_obj_wchain.h
index b9f791d058..d9377d327a 100644
--- a/include/d/actor/d_a_obj_wchain.h
+++ b/include/d/actor/d_a_obj_wchain.h
@@ -57,7 +57,6 @@ public:
         mDown = true;
     }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpHandleModel;
     /* 0x574 */ J3DModelData* mpChainModelData;
diff --git a/include/d/actor/d_a_obj_wdStick.h b/include/d/actor/d_a_obj_wdStick.h
index c82b115b84..e68f5a4a8e 100644
--- a/include/d/actor/d_a_obj_wdStick.h
+++ b/include/d/actor/d_a_obj_wdStick.h
@@ -50,10 +50,9 @@ public:
     virtual int Draw();
     virtual int Delete();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 
-private:
     /* 0x56C */ request_of_phase_process_class mPhase;
     /* 0x574 */ J3DModel* mModel;
     /* 0x578 */ u8 mMode;
diff --git a/include/d/actor/d_a_obj_well_cover.h b/include/d/actor/d_a_obj_well_cover.h
index b25ad59abe..f4fb2250d0 100644
--- a/include/d/actor/d_a_obj_well_cover.h
+++ b/include/d/actor/d_a_obj_well_cover.h
@@ -29,7 +29,6 @@ public:
 
     u8 getSwNo() { return fopAcM_GetParam(this); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ u8 field_0x5AC[0x5B0 - 0x5AC];
diff --git a/include/d/actor/d_a_obj_wind_stone.h b/include/d/actor/d_a_obj_wind_stone.h
index f5e52dfc94..107cecc92c 100644
--- a/include/d/actor/d_a_obj_wind_stone.h
+++ b/include/d/actor/d_a_obj_wind_stone.h
@@ -36,7 +36,6 @@ public:
     u32 getSwBit2() { return fopAcM_GetParamBit(this, 8, 8); }
     u32 getDelEveFlgId() { return fopAcM_GetParamBit(this, 0x10, 0x10); }
 
-private:
     /* 0x574 */ cBgS_PolyInfo mPolyInfo;
     /* 0x584 */ J3DModel* mpModel;
     /* 0x588 */ dBgW* mpBgW;
diff --git a/include/d/actor/d_a_obj_window.h b/include/d/actor/d_a_obj_window.h
index 83b62740a4..8d1b0412d7 100644
--- a/include/d/actor/d_a_obj_window.h
+++ b/include/d/actor/d_a_obj_window.h
@@ -27,7 +27,6 @@ public:
     u8 getType() { return fopAcM_GetParamBit(this, 0, 8); }
     u8 getLightInf() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
     /* 0x5A8 */ J3DModel* mpModel;
     /* 0x5AC */ mDoExt_bckAnm* mpBckAnm;
diff --git a/include/d/actor/d_a_obj_wood_pendulum.h b/include/d/actor/d_a_obj_wood_pendulum.h
index 1a1ee024b3..9ee5126ad8 100644
--- a/include/d/actor/d_a_obj_wood_pendulum.h
+++ b/include/d/actor/d_a_obj_wood_pendulum.h
@@ -26,7 +26,6 @@ public:
     u32 getArg0() { return fopAcM_GetParamBit(this, 0, 8); }
     u32 getArg1() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ dCcD_Stts mStts;
diff --git a/include/d/actor/d_a_obj_wood_statue.h b/include/d/actor/d_a_obj_wood_statue.h
index c0214679db..3ddd94bc62 100644
--- a/include/d/actor/d_a_obj_wood_statue.h
+++ b/include/d/actor/d_a_obj_wood_statue.h
@@ -52,7 +52,6 @@ public:
     void setStatus(u8 status) { mStatus = status; }
     u8 getSwbit2() { return fopAcM_GetParamBit(this, 8, 8); }
 
-private:
     /* 0x92C */ fpc_ProcID mItemId;
     /* 0x930 */ int field_0x930;
     /* 0x934 */ int mStaffIdx;
diff --git a/include/d/actor/d_a_obj_wsword.h b/include/d/actor/d_a_obj_wsword.h
index aa611af336..2860313c19 100644
--- a/include/d/actor/d_a_obj_wsword.h
+++ b/include/d/actor/d_a_obj_wsword.h
@@ -25,7 +25,6 @@ public:
     int draw();
     int _delete();
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ J3DModel* mpModel;
     /* 0x574 */ dBgS_ObjAcch mAcch;
diff --git a/include/d/actor/d_a_obj_yel_bag.h b/include/d/actor/d_a_obj_yel_bag.h
index 69b428da49..9c3f452a11 100644
--- a/include/d/actor/d_a_obj_yel_bag.h
+++ b/include/d/actor/d_a_obj_yel_bag.h
@@ -24,7 +24,7 @@ class daObj_YBag_Param_c {
 public:
     virtual ~daObj_YBag_Param_c() {}
 
-    static daObj_YBag_HIOParam const m;
+    static DUSK_GAME_DATA daObj_YBag_HIOParam const m;
 };
 
 #if DEBUG
@@ -53,7 +53,7 @@ public:
  *
  */
 class daObj_YBag_c : public fopAc_ac_c {
-private:
+public:
     /* 0x568 */ request_of_phase_process_class mPhases[3];
     /* 0x580 */ J3DModel* mModel;
     /* 0x584 */ OBJ_YBAG_HIO_CLASS* mpHIO;
@@ -109,8 +109,8 @@ public:
     void setWaterPrtcl();
     void setHamonPrtcl();
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daObj_YBag_c) == 0xa3c);
diff --git a/include/d/actor/d_a_obj_yobikusa.h b/include/d/actor/d_a_obj_yobikusa.h
index 9c1ee2a746..ed1019c7ad 100644
--- a/include/d/actor/d_a_obj_yobikusa.h
+++ b/include/d/actor/d_a_obj_yobikusa.h
@@ -76,8 +76,8 @@ public:
     inline cPhs_Step create();
     inline ~daObjYobikusa_c();
 
-    static attributes const M_attr;
-    static actionFuncEntry ActionTable[3];
+    static DUSK_GAME_DATA attributes const M_attr;
+    static DUSK_GAME_DATA actionFuncEntry ActionTable[3];
 
     const attributes* attr() const { return &M_attr; }
     int getType() { return argument & 0x7F; }
@@ -87,7 +87,6 @@ public:
         return var_r31 > 0;
     }
 
-private:
     /* 0x568 */ J3DModel* mpActiveModel;
     /* 0x56C */ J3DModel* mpModelTypeA;
     /* 0x570 */ J3DModel* mpModelTypeB;
diff --git a/include/d/actor/d_a_obj_zrTurara.h b/include/d/actor/d_a_obj_zrTurara.h
index 9f48464cf9..c52a21f2cc 100644
--- a/include/d/actor/d_a_obj_zrTurara.h
+++ b/include/d/actor/d_a_obj_zrTurara.h
@@ -29,7 +29,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x5A0 */ dCcD_Stts mCcStatus;
     /* 0x5DC */ dCcD_Cyl mCcCyl;
     /* 0x718 */ request_of_phase_process_class mPhaseReq;
@@ -50,8 +49,8 @@ public:
     int getSwBit2() { return fopAcM_GetParamBit(this, 8, 8); }
     int getScale() { return fopAcM_GetParamBit(this, 0x10, 8); }
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcCyl mCcDCyl;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcCyl mCcDCyl;
 };
 
 STATIC_ASSERT(sizeof(daZrTurara_c) == 0x76C);
diff --git a/include/d/actor/d_a_obj_zrTuraraRock.h b/include/d/actor/d_a_obj_zrTuraraRock.h
index 4590cff2cf..922948ee9c 100644
--- a/include/d/actor/d_a_obj_zrTuraraRock.h
+++ b/include/d/actor/d_a_obj_zrTuraraRock.h
@@ -30,7 +30,6 @@ public:
     int Draw();
     int Delete();
 
-private:
     /* 0x568 */ dCcD_Stts mCcStatus;
     /* 0x5A4 */ dCcD_Sph mCcSph;
     /* 0x6DC */ request_of_phase_process_class mPhaseReq;
@@ -45,8 +44,8 @@ private:
 public:
     u8 getScale() { return fopAcM_GetParamBit(this, 0, 8); }
 
-    static dCcD_SrcGObjInf const mCcDObjInfo;
-    static dCcD_SrcSph mCcDSph;
+    static DUSK_GAME_DATA dCcD_SrcGObjInf const mCcDObjInfo;
+    static DUSK_GAME_DATA dCcD_SrcSph mCcDSph;
 };
 
 STATIC_ASSERT(sizeof(daZrTuraRc_c) == 0x938);
diff --git a/include/d/actor/d_a_obj_zra_rock.h b/include/d/actor/d_a_obj_zra_rock.h
index 586fc176c5..925c49a5ee 100644
--- a/include/d/actor/d_a_obj_zra_rock.h
+++ b/include/d/actor/d_a_obj_zra_rock.h
@@ -28,7 +28,6 @@ public:
 
     void setDemoStart() { mDemoStart = 1; }
 
-private:
     friend class daNpc_zrZ_c;
 
     /* 0x5A0 */ request_of_phase_process_class mPhaseReq;
diff --git a/include/d/actor/d_a_passer_mng.h b/include/d/actor/d_a_passer_mng.h
index 230432336c..a3aa50db35 100644
--- a/include/d/actor/d_a_passer_mng.h
+++ b/include/d/actor/d_a_passer_mng.h
@@ -257,9 +257,8 @@ public:
         int field_0x04[0];
     };
 
-    static const Group* mGroupTbl[4];
+    static DUSK_GAME_DATA const Group* mGroupTbl[4];
 
-private:
     /* 0x568 */ fpc_ProcID* childProcIds;
     /* 0x56C */ dPath* mPath;
     /* 0x570 */ int startTime;
diff --git a/include/d/actor/d_a_peru.h b/include/d/actor/d_a_peru.h
index 9ea1ce80c1..8a997b7a85 100644
--- a/include/d/actor/d_a_peru.h
+++ b/include/d/actor/d_a_peru.h
@@ -59,7 +59,7 @@ class daPeru_Param_c {
 public:
     virtual ~daPeru_Param_c() {}
 
-    static daPeru_HIOParam const m;
+    static DUSK_GAME_DATA daPeru_HIOParam const m;
 };
 
 #if DEBUG
@@ -186,10 +186,9 @@ public:
     void setCnt(int cnt) { field_0xe6a = cnt; }
     int getCnt() { return field_0xe6a; }
 
-    static const char* mCutNameList[3];
-    static cutAppearFunc mCutList[3];
+    static DUSK_GAME_DATA const char* mCutNameList[3];
+    static DUSK_GAME_DATA cutAppearFunc mCutList[3];
 
-private:
     /* 0x0E40 */ daNpcT_ActorMngr_c mActors[3];
     /* 0x0E58 */ int field_0xe58;
     /* 0x0E5C */ actionFunc mActionFunc;
diff --git a/include/d/actor/d_a_player.h b/include/d/actor/d_a_player.h
index 1dfbec8783..ff8a165ef8 100644
--- a/include/d/actor/d_a_player.h
+++ b/include/d/actor/d_a_player.h
@@ -25,7 +25,6 @@ public:
         mNowSetFlg = 0;
     }
 
-private:
     /* 0x14 */ u16 mEndFlg;
     /* 0x16 */ u16 mNowSetFlg;
 };
@@ -67,10 +66,9 @@ public:
     static void offEventKeepFlg() { m_eventKeepFlg = 0; }
     static void onEventKeepFlg() { m_eventKeepFlg = 1; }
 
-    static s16 m_dropAngleY;
-    static s16 m_eventKeepFlg;
+    static DUSK_GAME_DATA s16 m_dropAngleY;
+    static DUSK_GAME_DATA s16 m_eventKeepFlg;
 
-private:
     /* 0x0 */ u8 field_0x0;
     /* 0x2 */ s16 field_0x2;
     /* 0x4 */ f32 m_offsetY;
@@ -91,6 +89,14 @@ private:
 #define PLAYER_CREATE_ANM_HEAP(heap, type, name) (heap).createHeap(type)
 #endif
 
+#if TARGET_PC
+inline u32 daPy_getAnmResourceSize(u16 i_resId, u32 i_minSize) {
+    JKRArchive* archive = dComIfGp_getAnmArchive();
+    u32 size = archive->getFileSize(archive->findIdxResource(i_resId));
+    return size > i_minSize ? size : i_minSize;
+}
+#endif
+
 class daPy_anmHeap_c {
 public:
     enum daAlinkHEAP_TYPE {
@@ -107,6 +113,9 @@ public:
     void* mallocBuffer();
 #if TARGET_PC
     void createHeap(daAlinkHEAP_TYPE i_heapType, const char* name);
+    void reserveBuffer(u16 i_resId);
+    void* allocTempBuffer(u16 i_resId, u32* io_size);
+    void freeTempBuffers();
 #else
     void createHeap(daAlinkHEAP_TYPE i_heapType);
 #endif
@@ -136,6 +145,10 @@ public:
     /* 0x08 */ u32 mBufferSize;
     /* 0x0C */ u8* mBuffer;
     /* 0x10 */ JKRSolidHeap* mAnimeHeap;
+#if TARGET_PC
+    u8* mOwnedBuffer = NULL;
+    void** mTempBuffers = NULL;
+#endif
 };  // Size = 0x14
 
 class daPy_actorKeep_c {
@@ -151,7 +164,6 @@ public:
     fopAc_ac_c* getActor() const { return mActor; }
     fopAc_ac_c* getActorConst() const { return mActor; }
 
-private:
     /* 0x0 */ fpc_ProcID mID;
     /* 0x4 */ fopAc_ac_c* mActor;
 };  // Size: 0x8
@@ -296,7 +308,6 @@ public:
     void resetDemoType() { setDemoType(0); }
     void setStartDemoType() { setDemoType(DEMO_TYPE_START_e); }
 
-private:
     /* 0x00 */ u16 mDemoType;
     /* 0x02 */ s16 mDemoMoveAngle;
     /* 0x04 */ s16 mTimer;
@@ -311,9 +322,11 @@ private:
 class daMidna_c;
 class daSpinner_c;
 class daPy_py_c;
+#if !TARGET_PC
 inline daPy_py_c* dComIfGp_getLinkPlayer();
 inline BOOL dComIfGs_isEventBit(const u16);
 inline u32 dComIfGs_getLastSceneMode();
+#endif
 
 class daPy_py_c : public fopAc_ac_c {
 public:
@@ -1213,7 +1226,7 @@ public:
         onEndResetFlg0(ERFLG0_FISHING_RELEASE);
     }
 
-    static daMidna_c* m_midnaActor;
+    static DUSK_GAME_DATA daMidna_c* m_midnaActor;
 
     void setGiantPuzzle() { mMode = SMODE_WOLF_PUZZLE; }
     void setGiantPuzzleEnd() { mMode = 0; }
diff --git a/include/d/actor/d_a_ppolamp.h b/include/d/actor/d_a_ppolamp.h
index f1e1a9f26d..d55754d97b 100644
--- a/include/d/actor/d_a_ppolamp.h
+++ b/include/d/actor/d_a_ppolamp.h
@@ -25,7 +25,6 @@ public:
     void moveSwing();
     void initParam();
 
-private:
     /* 0x574 */ J3DModel* mModel1;
     /* 0x578 */ J3DModel* mModel2;
     /* 0x57C */ mDoExt_bckAnm mBck;
diff --git a/include/d/actor/d_a_spinner.h b/include/d/actor/d_a_spinner.h
index 1dac4594a3..0ef81f3947 100644
--- a/include/d/actor/d_a_spinner.h
+++ b/include/d/actor/d_a_spinner.h
@@ -99,7 +99,6 @@ public:
 
     void forceDelete() { mDeleteFlg = true; }
 
-private:
     /* 0x568 */ J3DModel* mpModel;
     /* 0x56C */ mDoExt_bckAnm mBck;
     /* 0x588 */ J3DAnmTransform* mpSpoutBck;
diff --git a/include/d/actor/d_a_suspend.h b/include/d/actor/d_a_suspend.h
index 32cdf76864..9475aae38e 100644
--- a/include/d/actor/d_a_suspend.h
+++ b/include/d/actor/d_a_suspend.h
@@ -69,9 +69,9 @@ public:
     u8 getSw() { return fopAcM_GetParam(this) & 0xFF; }
     u8 getRoom() { return fopAcM_GetParam(this) >> 10; }
 
-    static data_c mData[0x20];
-    static room_c mRoom[0x40];
-    static s16 mSetTop;
+    static DUSK_GAME_DATA data_c mData[0x20];
+    static DUSK_GAME_DATA room_c mRoom[0x40];
+    static DUSK_GAME_DATA s16 mSetTop;
 };
 
 #endif /* D_A_SUSPEND_H */
diff --git a/include/d/actor/d_a_swBall.h b/include/d/actor/d_a_swBall.h
index 74bfa90593..df4877e04b 100644
--- a/include/d/actor/d_a_swBall.h
+++ b/include/d/actor/d_a_swBall.h
@@ -30,7 +30,6 @@ public:
     u8 getType() { return fopAcM_GetParamBit(this, 24, 4); }
     bool checkPullLBall() { return fopAcM_GetParamBit(this, 28, 2) == 0; }
 
-private:
     /* 0x568 */ fpc_ProcID mBallIDs[8];
     /* 0x588 */ u8 mTimer;
     /* 0x589 */ u8 mAction;
diff --git a/include/d/actor/d_a_swLBall.h b/include/d/actor/d_a_swLBall.h
index 0a633fcb5b..c3d132a40f 100644
--- a/include/d/actor/d_a_swLBall.h
+++ b/include/d/actor/d_a_swLBall.h
@@ -42,7 +42,6 @@ public:
         return fopAcM_GetParamBit(this,28,2) == 0;
     }
 
-private:
     /* 0x568 */ fpc_ProcID mProcIds[2];
     /* 0x570 */ u8 mRunTimer;
     /* 0x571 */ u8 mAction;
diff --git a/include/d/actor/d_a_swTime.h b/include/d/actor/d_a_swTime.h
index b3b96fa104..f61d5a5e7f 100644
--- a/include/d/actor/d_a_swTime.h
+++ b/include/d/actor/d_a_swTime.h
@@ -30,7 +30,6 @@ public:
     int execute();
     int _delete();
 
-private:
     /* 0x568 */ u8 mTime;
     /* 0x569 */ u8 mSwbit;
     /* 0x56A */ u8 mSwbit2;
diff --git a/include/d/actor/d_a_tag_CstaSw.h b/include/d/actor/d_a_tag_CstaSw.h
index b40a9d178e..e73fd18662 100644
--- a/include/d/actor/d_a_tag_CstaSw.h
+++ b/include/d/actor/d_a_tag_CstaSw.h
@@ -16,7 +16,6 @@ public:
 
     u32 getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x568 */ u8 mSwitch;
     /* 0x569 */ u8 unused[0x570 - 0x569];
 
diff --git a/include/d/actor/d_a_tag_TWgate.h b/include/d/actor/d_a_tag_TWgate.h
index e5952da286..683d01449b 100644
--- a/include/d/actor/d_a_tag_TWgate.h
+++ b/include/d/actor/d_a_tag_TWgate.h
@@ -112,13 +112,12 @@ public:
 
     inline void setAction(Mode_e i_action);
 
-    static daTagTWGate_Attr_c const mAttr;
+    static DUSK_GAME_DATA daTagTWGate_Attr_c const mAttr;
 #if DEBUG
     static daTagTWGate_Hio_c mHio;
 #endif
-    static const actionFunc ActionTable[][2];
+    static DUSK_GAME_DATA const actionFunc ActionTable[][2];
 
-private:
     /* 0x568 */ mDoExt_McaMorfSO* mpMorf;
     /* 0x56C */ request_of_phase_process_class mPhaseZevArc;
     /* 0x574 */ request_of_phase_process_class mPhaseMdRes;
diff --git a/include/d/actor/d_a_tag_bottle_item.h b/include/d/actor/d_a_tag_bottle_item.h
index cd122c8cad..3cc2a274d4 100644
--- a/include/d/actor/d_a_tag_bottle_item.h
+++ b/include/d/actor/d_a_tag_bottle_item.h
@@ -8,7 +8,7 @@ class daTag_BottleItem_c;
 typedef int (daTag_BottleItem_c::*ProcessFunc)(void*);
 
 class daTag_BottleItem_c : public fopAc_ac_c {
-private:
+public:
     /* 0x0568 */ ProcessFunc mProcessFunc;
     /* 0x056C */ u16 mEventType;
     /* 0x0576 */ u8 mBottleItemType;
diff --git a/include/d/actor/d_a_tag_chkpoint.h b/include/d/actor/d_a_tag_chkpoint.h
index 4871ec3946..51fa95e17d 100644
--- a/include/d/actor/d_a_tag_chkpoint.h
+++ b/include/d/actor/d_a_tag_chkpoint.h
@@ -45,7 +45,6 @@ public:
         return cPhs_COMPLEATE_e;
     }
 
-private:
     /* 0x568 */ u8 field_0x568[8];
     /* 0x570 */ cXyz mVtxA;
     /* 0x57C */ cXyz mVtxB;
diff --git a/include/d/actor/d_a_tag_evt.h b/include/d/actor/d_a_tag_evt.h
index fda3192704..6d9b85221b 100644
--- a/include/d/actor/d_a_tag_evt.h
+++ b/include/d/actor/d_a_tag_evt.h
@@ -17,7 +17,7 @@ public:
     int doEvtCutTalk(int);
     int doEvtCutNext(int);
 
-    static DUSK_CONST char* mEvtCutList[3];
+    static DUSK_GAME_DATA DUSK_CONST char* mEvtCutList[3];
 
     /* 0x568 */ char field_0x568[8];
     /* 0x570 */ u16 field_0x570;
diff --git a/include/d/actor/d_a_tag_evtarea.h b/include/d/actor/d_a_tag_evtarea.h
index 4bf0ec404e..f83e034aa1 100644
--- a/include/d/actor/d_a_tag_evtarea.h
+++ b/include/d/actor/d_a_tag_evtarea.h
@@ -45,7 +45,6 @@ public:
 
     void noEffect() { field_0x56c = 1; }
 
-private:
     /* 0x568 vtable */
     /* 0x56C */ u8 field_0x56c;
 };
diff --git a/include/d/actor/d_a_tag_evtmsg.h b/include/d/actor/d_a_tag_evtmsg.h
index 33a8d41f49..a1011ee8e4 100644
--- a/include/d/actor/d_a_tag_evtmsg.h
+++ b/include/d/actor/d_a_tag_evtmsg.h
@@ -32,8 +32,8 @@ public:
 
     virtual ~daTag_EvtMsg_c();
 
-    static DUSK_CONST char* mEvtCutNameList[];
-    static EvtCutFunc mEvtCutList[];
+    static DUSK_GAME_DATA DUSK_CONST char* mEvtCutNameList[];
+    static DUSK_GAME_DATA EvtCutFunc mEvtCutList[];
 };
 
 #endif /* D_A_TAG_EVTMSG_H */
diff --git a/include/d/actor/d_a_tag_hstop.h b/include/d/actor/d_a_tag_hstop.h
index 6a5ae38beb..97b0a68f7b 100644
--- a/include/d/actor/d_a_tag_hstop.h
+++ b/include/d/actor/d_a_tag_hstop.h
@@ -22,8 +22,8 @@ public:
         }
     }
 
-    static daTagHstop_c* m_top;
-    static dMsgFlow_c m_msgFlow;
+    static DUSK_GAME_DATA daTagHstop_c* m_top;
+    static DUSK_GAME_DATA dMsgFlow_c m_msgFlow;
 
     /* 0x568 */ daTagHstop_c* mNext;
     /* 0x568 */ daTagHstop_c* mPrev;
diff --git a/include/d/actor/d_a_tag_lantern.h b/include/d/actor/d_a_tag_lantern.h
index c0e0c0d152..ed9cbef3e3 100644
--- a/include/d/actor/d_a_tag_lantern.h
+++ b/include/d/actor/d_a_tag_lantern.h
@@ -12,7 +12,7 @@ class daTag_Lantern_Param_c {
 public:
     inline virtual ~daTag_Lantern_Param_c() {}
 
-    static daTag_Lantern_HIOParam const m;
+    static DUSK_GAME_DATA daTag_Lantern_HIOParam const m;
 };
 
 #if DEBUG
diff --git a/include/d/actor/d_a_tag_lv6CstaSw.h b/include/d/actor/d_a_tag_lv6CstaSw.h
index 17b58e4b28..384d9bd6d9 100644
--- a/include/d/actor/d_a_tag_lv6CstaSw.h
+++ b/include/d/actor/d_a_tag_lv6CstaSw.h
@@ -16,7 +16,6 @@ public:
 
     u32 getSw() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x568 */ u8 mSwitch;
     /* 0x569 */ u8 unused[0x570 - 0x569];
 };
diff --git a/include/d/actor/d_a_tag_magne.h b/include/d/actor/d_a_tag_magne.h
index 2b2db66517..bfdc788e37 100644
--- a/include/d/actor/d_a_tag_magne.h
+++ b/include/d/actor/d_a_tag_magne.h
@@ -19,7 +19,7 @@ public:
     u8 getSwNo2() { return fopAcM_GetParamBit(this, 8, 8); }
     u8 getSwNo3() { return fopAcM_GetParamBit(this, 16, 8); }
 
-    static daTagMagne_c* mTagMagne;
+    static DUSK_GAME_DATA daTagMagne_c* mTagMagne;
 
     /* 0x568 */ u8 mSwNo1;
     /* 0x569 */ u8 mSwNo2;
diff --git a/include/d/actor/d_a_tag_mhint.h b/include/d/actor/d_a_tag_mhint.h
index e4c5260079..c573467ae0 100644
--- a/include/d/actor/d_a_tag_mhint.h
+++ b/include/d/actor/d_a_tag_mhint.h
@@ -26,7 +26,6 @@ public:
                            NULL);
     }
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 mSwitch;
     /* 0x56A */ u8 field_0x56a;
diff --git a/include/d/actor/d_a_tag_mist.h b/include/d/actor/d_a_tag_mist.h
index 9579ff62d5..3c4973075a 100644
--- a/include/d/actor/d_a_tag_mist.h
+++ b/include/d/actor/d_a_tag_mist.h
@@ -17,7 +17,7 @@ public:
     static u8 getPlayerNo();
     static void setPlayerNo(u8 i_playerNo) { mPlayerNo = i_playerNo; }
 
-    static u8 mPlayerNo;
+    static DUSK_GAME_DATA u8 mPlayerNo;
 
     /* 0x568 */ u8 unused_0x568[0x570 - 0x568];
     /* 0x570 */ cXyz mVertices[4];
diff --git a/include/d/actor/d_a_tag_mmsg.h b/include/d/actor/d_a_tag_mmsg.h
index 9fdd0b3c66..bcafa0c37d 100644
--- a/include/d/actor/d_a_tag_mmsg.h
+++ b/include/d/actor/d_a_tag_mmsg.h
@@ -14,7 +14,6 @@ public:
     void onUseFlg() { mUseFlg = true; }
     bool checkNoAttention() const { return mAttention == 0xFF; }
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 field_0x569;
     /* 0x56A */ u8 mAttention;
diff --git a/include/d/actor/d_a_tag_msg.h b/include/d/actor/d_a_tag_msg.h
index b1104d6846..b0b65e2795 100644
--- a/include/d/actor/d_a_tag_msg.h
+++ b/include/d/actor/d_a_tag_msg.h
@@ -13,7 +13,7 @@ class daTag_Msg_Param_c {
 public:
     virtual ~daTag_Msg_Param_c() {}
 
-    static const daTag_Msg_HIO_Param_c m;
+    static DUSK_GAME_DATA const daTag_Msg_HIO_Param_c m;
 };
 
 #if DEBUG
@@ -47,7 +47,7 @@ public:
     void getParam();
     BOOL cut_speak(int, BOOL);
 
-    static DUSK_CONST char* mEvtCutTBL[2];
+    static DUSK_GAME_DATA DUSK_CONST char* mEvtCutTBL[2];
 
     /* 0x56C */ char mStaffName[8];
     /* 0x574 */ request_of_phase_process_class mPhase;
diff --git a/include/d/actor/d_a_tag_mstop.h b/include/d/actor/d_a_tag_mstop.h
index dd27dbb005..774af17007 100644
--- a/include/d/actor/d_a_tag_mstop.h
+++ b/include/d/actor/d_a_tag_mstop.h
@@ -17,7 +17,6 @@ public:
     int execute();
     bool checkNoAttention() const { return field_0x56b == 0xFF; }
 
-private:
     /* 0x568 */ u8 field_0x568;
     /* 0x569 */ u8 mSwitch;
     /* 0x56A */ u8 field_0x56a;
diff --git a/include/d/actor/d_a_tag_myna2.h b/include/d/actor/d_a_tag_myna2.h
index 7eecb0c1d7..70605612e3 100644
--- a/include/d/actor/d_a_tag_myna2.h
+++ b/include/d/actor/d_a_tag_myna2.h
@@ -12,7 +12,6 @@ public:
     int getMode() { return fopAcM_GetParam(this) & 0xFF; }
     f32 getExtent() { return scale.x * 100.0f;}
 
-private:
     /* 0x568 */ u32 mSwitchNo;
     /* 0x56C */ u32 mMode;
     /* 0x570 */ s16 mTimer;
diff --git a/include/d/actor/d_a_tag_setBall.h b/include/d/actor/d_a_tag_setBall.h
index 6e75928c6b..0619e2a677 100644
--- a/include/d/actor/d_a_tag_setBall.h
+++ b/include/d/actor/d_a_tag_setBall.h
@@ -16,7 +16,6 @@ public:
 
     s32 getType() { return mType; }
 
-private:
     u8 getType_private() { return fopAcM_GetParamBit(this, 8, 4); }
 
     /* 0x568 */ u8 mType;
diff --git a/include/d/actor/d_a_tag_statue_evt.h b/include/d/actor/d_a_tag_statue_evt.h
index 1bdc0d4f52..59237c09eb 100644
--- a/include/d/actor/d_a_tag_statue_evt.h
+++ b/include/d/actor/d_a_tag_statue_evt.h
@@ -25,7 +25,6 @@ public:
     int draw();
     int _delete();
 
-private:
     /* 0x568 */ request_of_phase_process_class mArcPhase;
     /* 0x570 */ request_of_phase_process_class mEvArcPhase;
     /* 0x578 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_tag_stream.h b/include/d/actor/d_a_tag_stream.h
index 7c3b3eb4ac..f30abfec15 100644
--- a/include/d/actor/d_a_tag_stream.h
+++ b/include/d/actor/d_a_tag_stream.h
@@ -42,7 +42,7 @@ public:
     /* 0x570 */ daTagStream_c* field_0x570;
     /* 0x574 */ daTagStream_c* mNext;
 
-    static daTagStream_c* m_top;
+    static DUSK_GAME_DATA daTagStream_c* m_top;
 };
 
 #endif /* D_A_TAG_STREAM_H */
diff --git a/include/d/actor/d_a_tag_telop.h b/include/d/actor/d_a_tag_telop.h
index 6e28231138..0d6fbeb7a1 100644
--- a/include/d/actor/d_a_tag_telop.h
+++ b/include/d/actor/d_a_tag_telop.h
@@ -13,7 +13,6 @@ public:
 
     u16 getMessageNo() { return home.angle.z; }
 
-private:
     /* 0x568 */ u16 mMessageNo;
     /* 0x56C */ int mMessageStatus;
 };
diff --git a/include/d/actor/d_a_tag_waterfall.h b/include/d/actor/d_a_tag_waterfall.h
index 80ffe7bec2..6076e53042 100644
--- a/include/d/actor/d_a_tag_waterfall.h
+++ b/include/d/actor/d_a_tag_waterfall.h
@@ -22,7 +22,6 @@ public:
     int _delete();
     cPhs_Step create();
 
-private:
     /* 0x568 */ f32 mCylinderRadiusA;
     /* 0x56C */ f32 mCylinderRadiusB;
     /* 0x570 */ f32 mCylinderHeight;
diff --git a/include/d/actor/d_a_tag_yami.h b/include/d/actor/d_a_tag_yami.h
index 8410899186..fc17586688 100644
--- a/include/d/actor/d_a_tag_yami.h
+++ b/include/d/actor/d_a_tag_yami.h
@@ -36,7 +36,6 @@ public:
     void setCoR(f32 i_value) { mCoR = i_value; }
     void setCoH(f32 i_value) { mCoH = i_value; }
 
-private:
     /* 0x568 */ dCcD_Cyl mCyl;
     /* 0x6A4 */ dCcD_Stts mStts;
     /* 0x6E0 */ u8 mCoHitValid;
diff --git a/include/d/actor/d_a_talk.h b/include/d/actor/d_a_talk.h
index 9c86f88610..b7715d88cd 100644
--- a/include/d/actor/d_a_talk.h
+++ b/include/d/actor/d_a_talk.h
@@ -22,7 +22,6 @@ public:
     u16 getStatus();
     u32 messageSet();
 
-private:
     /* 0x568 */ dMsgFlow_c mMsgFlow;
     /* 0x5B4 */ u32 mMessageID;
 };
diff --git a/include/d/actor/d_a_tbox.h b/include/d/actor/d_a_tbox.h
index 2b48a156eb..6b07594577 100644
--- a/include/d/actor/d_a_tbox.h
+++ b/include/d/actor/d_a_tbox.h
@@ -148,7 +148,6 @@ public:
         field_0x9fc = 1;
     }
 
-private:
     /* 0x718 */ u8 field_0x718;
     /* 0x71C */ request_of_phase_process_class mPhase;
     /* 0x724 */ J3DModel* mpModel;
@@ -194,6 +193,9 @@ private:
     /* 0x9FC */ u8 field_0x9fc;
     /* 0x9FD */ u8 field_0x9fd;
     /* 0xA00 */ Mtx mDrawMtx;
+#if TARGET_PC
+    u8 mOriginalItemNo;
+#endif
 };
 
 STATIC_ASSERT(sizeof(daTbox_c) == 0xA30);
diff --git a/include/d/actor/d_a_tbox2.h b/include/d/actor/d_a_tbox2.h
index 3f176ade5e..29df2d8389 100644
--- a/include/d/actor/d_a_tbox2.h
+++ b/include/d/actor/d_a_tbox2.h
@@ -67,7 +67,6 @@ public:
     u8 getModelType() { return fopAcM_GetParamBit(this, 8, 4); }
     u8 getItemNo() { return fopAcM_GetParamBit(this, 0, 8); }
 
-private:
     /* 0x718 */ u8 mReturnRupee;
     /* 0x71C */ request_of_phase_process_class mPhase;
     /* 0x724 */ J3DModel* mpModel;
@@ -83,6 +82,10 @@ private:
     /* 0xAC0 */ u8 field_0xAC0[0xAC4 - 0xAC0];
     /* 0xAC4 */ int mStaffIdx;
     /* 0xAC8 */ dBgW* mBoxBgW;
+#if TARGET_PC
+    bool mParamsInit;
+    u8 mOriginalItemNo;
+#endif
 };
 
 STATIC_ASSERT(sizeof(daTbox2_c) == 0xACC);
diff --git a/include/d/actor/d_a_title.h b/include/d/actor/d_a_title.h
index 465fe689c1..691e2df3e3 100644
--- a/include/d/actor/d_a_title.h
+++ b/include/d/actor/d_a_title.h
@@ -50,7 +50,6 @@ public:
     void KeyWaitPosMove();
     #endif
 
-private:
     /* 0x568 */ request_of_phase_process_class mPhaseReq;
     /* 0x570 */ JKRHeap* mpHeap;
     /* 0x574 */ J3DModel* mpModel;
diff --git a/include/d/actor/d_a_ykgr.h b/include/d/actor/d_a_ykgr.h
index 472ceefc4a..c23f530c67 100644
--- a/include/d/actor/d_a_ykgr.h
+++ b/include/d/actor/d_a_ykgr.h
@@ -57,12 +57,12 @@ public:
     int _execute();
     bool _draw();
 
-    static JPABaseEmitter* m_emitter;
-    static bool m_flag;
-    static bool m_alpha_flag;
-    static u8 m_alpha;
-    static f32 m_aim_rate;
-    static dPath* m_path;
+    static DUSK_GAME_DATA JPABaseEmitter* m_emitter;
+    static DUSK_GAME_DATA bool m_flag;
+    static DUSK_GAME_DATA bool m_alpha_flag;
+    static DUSK_GAME_DATA u8 m_alpha;
+    static DUSK_GAME_DATA f32 m_aim_rate;
+    static DUSK_GAME_DATA dPath* m_path;
 
     /* 0x568 */ u8 field_0x568[0x570 - 0x568];
     /* 0x570 */ Mtx field_0x570;
diff --git a/include/d/actor/d_flower.h b/include/d/actor/d_flower.h
index f63847956a..db8661b92f 100644
--- a/include/d/actor/d_flower.h
+++ b/include/d/actor/d_flower.h
@@ -5,7 +5,7 @@
 #include "SSystem/SComponent/c_xyz.h"
 
 #if TARGET_PC
-#include "dusk/batch.hpp"
+#include "helpers/batch.hpp"
 #endif
 
 class cCcD_Obj;
@@ -74,7 +74,7 @@ public:
         return m_deleteRoom;
     }
 
-    static deleteFunc m_deleteRoom;
+    static DUSK_GAME_DATA deleteFunc m_deleteRoom;
 
     dFlower_anm_c* getAnm(int i_idx) { return &m_anm[i_idx]; }
     dFlower_anm_c* getAnm() { return &m_anm[0]; }
@@ -112,11 +112,11 @@ public:
     TGXTexObj mTexObj_l_J_Ohana00_64TEX;
     TGXTexObj mTexObj_l_J_Ohana01_64128_0419TEX;
 
-    dusk::batch::LeafTemplate mTplHana00;       // l_J_hana00DL
-    dusk::batch::LeafTemplate mTplHana00Cut;    // l_J_hana00_cDL
-    dusk::batch::LeafTemplate mTplHana01;       // l_J_hana01DL
-    dusk::batch::LeafTemplate mTplHana01Cut00;  // l_J_hana01_c_00DL
-    dusk::batch::LeafTemplate mTplHana01Cut;    // l_J_hana01_c_01DL
+    batch::LeafTemplate mTplHana00;       // l_J_hana00DL
+    batch::LeafTemplate mTplHana00Cut;    // l_J_hana00_cDL
+    batch::LeafTemplate mTplHana01;       // l_J_hana01DL
+    batch::LeafTemplate mTplHana01Cut00;  // l_J_hana01_c_00DL
+    batch::LeafTemplate mTplHana01Cut;    // l_J_hana01_c_01DL
 #endif
 };  // Size: 0x12A54
 
diff --git a/include/d/actor/d_grass.h b/include/d/actor/d_grass.h
index b7cc3d7d95..4eee08c0e8 100644
--- a/include/d/actor/d_grass.h
+++ b/include/d/actor/d_grass.h
@@ -5,7 +5,7 @@
 #include "SSystem/SComponent/c_xyz.h"
 
 #if TARGET_PC
-#include "../../../src/dusk/batch.hpp"
+#include <helpers/batch.hpp>
 #endif
 
 class cCcD_Obj;
@@ -84,7 +84,7 @@ public:
         return m_deleteRoom;
     }
 
-    static deleteFunc m_deleteRoom;
+    static DUSK_GAME_DATA deleteFunc m_deleteRoom;
 
     dGrass_anm_c* getAnm() { return m_anm; }
     dGrass_anm_c* getAnm(int i_no) { return &m_anm[i_no]; }
@@ -115,9 +115,9 @@ public:
     TGXTexObj mTexObj_l_M_Hijiki00TEX;
     TGXTexObj mTexObj_l_M_kusa05_RGBATEX;
 
-    dusk::batch::LeafTemplate mTplKusa9q;     // l_M_Kusa_9qDL
-    dusk::batch::LeafTemplate mTplKusa9qCut;  // l_M_Kusa_9q_cDL
-    dusk::batch::LeafTemplate mTplTengusa;    // l_M_TenGusaDL
+    batch::LeafTemplate mTplKusa9q;     // l_M_Kusa_9qDL
+    batch::LeafTemplate mTplKusa9qCut;  // l_M_Kusa_9q_cDL
+    batch::LeafTemplate mTplTengusa;    // l_M_TenGusaDL
 #endif
 };  // Size: 0x1D718
 
diff --git a/include/d/d_a_item_static.h b/include/d/d_a_item_static.h
index 10869c5733..6b8b321b2b 100644
--- a/include/d/d_a_item_static.h
+++ b/include/d/d_a_item_static.h
@@ -114,9 +114,9 @@ public:
 
     bool checkBoomWindTgTimer() { return mBoomWindTgTimer == 0; }
 
-    static procFunc mFuncPtr[];
-    static const dCcD_SrcCyl m_cyl_src;
-    static s32 m_timer_max;
+    static DUSK_GAME_DATA procFunc mFuncPtr[];
+    static DUSK_GAME_DATA const dCcD_SrcCyl m_cyl_src;
+    static DUSK_GAME_DATA s32 m_timer_max;
 
     /* 0x92C */ s16 field_0x92c;
     /* 0x92E */ u16 field_0x92e;
@@ -145,6 +145,10 @@ public:
     /* 0x9BC */ u8 field_0x9bc[4];
     /* 0x9C0 */ u8 field_0x9c0;
     /* 0x9C1 */ u8 field_0x9c1;
+#if TARGET_PC
+    u8 mOriginalItemNo;
+    bool mItemOverridden;
+#endif
 };  // Size: 0x9C4
 
 #endif /* D_A_D_A_ITEM_STATIC_H */
diff --git a/include/d/d_a_itembase_static.h b/include/d/d_a_itembase_static.h
index 36a0f55899..38ecb323eb 100644
--- a/include/d/d_a_itembase_static.h
+++ b/include/d/d_a_itembase_static.h
@@ -1,10 +1,15 @@
 #ifndef D_A_D_A_ITEMBASE_STATIC_H
 #define D_A_D_A_ITEMBASE_STATIC_H
 
+#include "dolphin/types.h"
 
 class fopAc_ac_c;
 
 int CheckFieldItemCreateHeap(fopAc_ac_c* actor);
 int CheckItemCreateHeap(fopAc_ac_c* i_this);
 
+#if TARGET_PC
+const char* dItem_fieldModelArc(u8 itemNo);
+#endif
+
 #endif /* D_A_D_A_ITEMBASE_STATIC_H */
diff --git a/include/d/d_a_shop_item_static.h b/include/d/d_a_shop_item_static.h
index 0091c0b83c..e79973fc65 100644
--- a/include/d/d_a_shop_item_static.h
+++ b/include/d/d_a_shop_item_static.h
@@ -50,6 +50,9 @@ public:
     csXyz* getRotateP();
     cXyz* getPosP();
     const char* getShopArcname();
+#if TARGET_PC
+    const ResourceData& getResourceData() const;
+#endif
     u16 getHeapSize();
     void CreateInit();
     void set_mtx();
@@ -74,8 +77,8 @@ public:
     s16 getAngleY() const { return mAngleY; }
     void setAngleY(s16 angle) { mAngleY = angle;}
 
-    static ResourceData const mData[23];
-    static f32 const m_cullfar_max;
+    static DUSK_GAME_DATA ResourceData const mData[23];
+    static DUSK_GAME_DATA f32 const m_cullfar_max;
 
     enum {
         SHOP_ITEMNO_SOLD,
@@ -104,12 +107,15 @@ public:
         SHOP_ITEMNO_MAX,
     };
 
-private:
     /* 0x92C */ Mtx mMtx;
     /* 0x95C */ int field_0x95c;
     /* 0x960 */ s16 mAngleX;
     /* 0x962 */ s16 mAngleY;
     /* 0x964 */ u8 mShopItemID;
+#if TARGET_PC
+    ResourceData mOverrideData;
+    bool mItemOverridden;
+#endif
 };
 
 int CheckShopItemCreateHeap(fopAc_ac_c* i_this);
diff --git a/include/d/d_attention.h b/include/d/d_attention.h
index 5b8930b5dd..b1c269651f 100644
--- a/include/d/d_attention.h
+++ b/include/d/d_attention.h
@@ -18,7 +18,6 @@ public:
 
     fopAc_ac_c* getZHintTarget() { return convPId(field_0x8); }
 
-private:
     /* 0x0 */ fpc_ProcID mHintActorID;
     /* 0x4 */ int mPriority;
     /* 0x8 */ fpc_ProcID field_0x8;
@@ -34,7 +33,6 @@ public:
     fopAc_ac_c* getCatghTarget() { return convPId(mCatghTargetID); }
     u8 getChangeItem() { return mChangeItem; }
 
-private:
     /* 0x00 */ fpc_ProcID mRequestActorID;
     /* 0x04 */ int field_0x4;
     /* 0x08 */ f32 mDistance;
@@ -120,7 +118,6 @@ public:
 
     fopAc_ac_c* getLookTarget() { return convPId(mLookTargetID); }
 
-private:
     fpc_ProcID mRequestActorID;
     int field_0x4;
     f32 mDistance;
@@ -286,13 +283,13 @@ public:
     void keepLock(int timer) { mAttnBlockTimer = timer; }
     bool Lockon() { return LockonTruth() || chkFlag(0x20000000); }  // only matches with -O2?
 
-    static type_tbl_entry loc_type_tbl[3];
-    static type_tbl_entry act_type_tbl[5];
-    static dist_entry dist_table[234];
-    static int loc_type_num;
-    static int act_type_num;
-    static type_tbl_entry chk_type_tbl[1];
-    static int chk_type_num;
+    static DUSK_GAME_DATA type_tbl_entry loc_type_tbl[3];
+    static DUSK_GAME_DATA type_tbl_entry act_type_tbl[5];
+    static DUSK_GAME_DATA dist_entry dist_table[234];
+    static DUSK_GAME_DATA int loc_type_num;
+    static DUSK_GAME_DATA int act_type_num;
+    static DUSK_GAME_DATA type_tbl_entry chk_type_tbl[1];
+    static DUSK_GAME_DATA int chk_type_num;
 
 public:
     /* 0x000 */ fopAc_ac_c* mpPlayer;
diff --git a/include/d/d_bg_parts.h b/include/d/d_bg_parts.h
index a8dba41165..b77199182f 100644
--- a/include/d/d_bg_parts.h
+++ b/include/d/d_bg_parts.h
@@ -237,8 +237,8 @@ public:
     static void drawShare();
     static void entryShare(packet_c*);
 
-    static JKRSolidHeap* mShareHeap;
-    static share_c* mShare;
+    static DUSK_GAME_DATA JKRSolidHeap* mShareHeap;
+    static DUSK_GAME_DATA share_c* mShare;
 
     /* 0x000 */ void* mPointer;
     /* 0x004 */ char mArcName[8];
diff --git a/include/d/d_bg_plc.h b/include/d/d_bg_plc.h
index da360fd0e4..f5361ff883 100644
--- a/include/d/d_bg_plc.h
+++ b/include/d/d_bg_plc.h
@@ -20,7 +20,6 @@ public:
 
     static const int ZELDA_CODE_SIZE = sizeof(sBgPc);
 
-private:
     /* 0x00 */ sBgPlc* m_base;
 };
 
diff --git a/include/d/d_bg_s_acch.h b/include/d/d_bg_s_acch.h
index 04a388c61b..a1a1517cc4 100644
--- a/include/d/d_bg_s_acch.h
+++ b/include/d/d_bg_s_acch.h
@@ -13,7 +13,7 @@
 class fopAc_ac_c;
 
 class dBgS_AcchCir : public cBgS_PolyInfo {
-private:
+public:
     /* 0x10 */ u32 m_flags;
     /* 0x14 */ cM3dGCir m_cir;
     /* 0x28 */ f32 m_wall_rr;
@@ -197,7 +197,6 @@ public:
     f32 GetCx() const { return pm_pos->x; }
     f32 GetCz() const { return pm_pos->z; }
     
-private:
     /* 0x02C */ u32 m_flags;
     /* 0x030 */ cXyz* pm_pos;
     /* 0x034 */ cXyz* pm_old_pos;
@@ -237,7 +236,6 @@ public:
     /* 0x0DC */ dBgS_GndChk m_gnd;
     /* 0x130 */ dBgS_RoofChk m_roof;
     /* 0x180 */ dBgS_WtrChk m_wtr;
-private:
     /* 0x1D4 */ u8 m_wtr_mode;
 }; // Size: 0x1D8
 
diff --git a/include/d/d_bg_s_grp_pass_chk.h b/include/d/d_bg_s_grp_pass_chk.h
index eea3414b98..6253f67f18 100644
--- a/include/d/d_bg_s_grp_pass_chk.h
+++ b/include/d/d_bg_s_grp_pass_chk.h
@@ -25,7 +25,6 @@ public:
     void OnAll() { mGrp |= FULL_GRP; }
     u32 MaskNormalGrp() { return mGrp & NORMAL_GRP; }
     u32 MaskWaterGrp() { return mGrp & WATER_GRP; }
-private:
     /* 0x4 */ u32 mGrp;
 };
 
diff --git a/include/d/d_bg_s_movebg_actor.h b/include/d/d_bg_s_movebg_actor.h
index be09052ee5..bd9e5351b6 100644
--- a/include/d/d_bg_s_movebg_actor.h
+++ b/include/d/d_bg_s_movebg_actor.h
@@ -35,9 +35,9 @@ public:
     virtual int ToFore();
     virtual int ToBack();
 
-    static const char* m_name;
-    static int m_dzb_id;
-    static MoveBGActor_SetFunc m_set_func;
+    static DUSK_GAME_DATA const char* m_name;
+    static DUSK_GAME_DATA int m_dzb_id;
+    static DUSK_GAME_DATA MoveBGActor_SetFunc m_set_func;
 };
 
 STATIC_ASSERT(sizeof(dBgS_MoveBgActor) == 0x5a0);
diff --git a/include/d/d_bg_s_poly_pass_chk.h b/include/d/d_bg_s_poly_pass_chk.h
index 6f7778189a..759321c6da 100644
--- a/include/d/d_bg_s_poly_pass_chk.h
+++ b/include/d/d_bg_s_poly_pass_chk.h
@@ -42,7 +42,6 @@ public:
     void SetStatue();
     void SetUnderwaterRoof();
 
-private:
     /* 0x4 */ bool mObject;
     /* 0x5 */ bool mCamera;
     /* 0x6 */ bool mLink;
diff --git a/include/d/d_bg_s_roof_chk.h b/include/d/d_bg_s_roof_chk.h
index 387c05fff2..e404eef0c4 100644
--- a/include/d/d_bg_s_roof_chk.h
+++ b/include/d/d_bg_s_roof_chk.h
@@ -17,7 +17,6 @@ public:
     f32 GetNowY() { return mNowY; }
     cXyz* GetPosP() { return &m_pos; }
 
-private:
     /* 0x3C */ cXyz m_pos;
     /* 0x48 */ int field_0x48;
     /* 0x4C */ f32 mNowY;
diff --git a/include/d/d_bg_s_spl_grp_chk.h b/include/d/d_bg_s_spl_grp_chk.h
index 447bbf4d73..46df7df35a 100644
--- a/include/d/d_bg_s_spl_grp_chk.h
+++ b/include/d/d_bg_s_spl_grp_chk.h
@@ -30,7 +30,6 @@ public:
     cXyz& GetPosP() { return m_ground; }
     f32 GetRoof() { return m_roof; }
 
-private:
     /* 0x3C */ cXyz m_ground;
     /* 0x48 */ f32 m_roof;
     /* 0x4C */ f32 m_height;
diff --git a/include/d/d_bg_w.h b/include/d/d_bg_w.h
index 580e22d904..c9692a7c61 100644
--- a/include/d/d_bg_w.h
+++ b/include/d/d_bg_w.h
@@ -6,9 +6,12 @@
 #include "d/d_bg_w_base.h"
 #include <mtx.h>
 #include <types.h>
-#include "dusk/offset_ptr.h"
-#include "dusk/endian.h"
-#include "dusk/endian_ssystem.h"
+
+#if TARGET_PC
+#include "helpers/endian.h"
+#include "helpers/endian_ssystem.h"
+#include "helpers/offset_ptr.h"
+#endif
 
 class cBgS_GrpPassChk;
 class cBgS_PolyPassChk;
@@ -346,7 +349,6 @@ public:
     void SetArrowStickCallback(dBgW_ArrowStickCallback func) { m_arrow_stick_callback = func; }
     void OnMoveFlag() { m_flags |= (u8)1; }
 
-private:
     /* 0xB0 */ dBgW_CrrFunc m_crr_func;
     /* 0xB4 */ dBgW_RideCallback m_ride_callback;
     /* 0xB8 */ dBgW_ArrowStickCallback m_arrow_stick_callback;
diff --git a/include/d/d_bg_w_base.h b/include/d/d_bg_w_base.h
index 6940df06fa..f30604d2d3 100644
--- a/include/d/d_bg_w_base.h
+++ b/include/d/d_bg_w_base.h
@@ -124,7 +124,6 @@ public:
     void OnPushPullOk() { m_pushPull_Ok = true; }
     void OffPushPullOk() { m_pushPull_Ok = false; }
 
-private:
     /* 0x08 */ u8 m_priority;
     /* 0x09 */ u8 m_roomId;
     /* 0x0A */ u8 field_0xa;
diff --git a/include/d/d_bg_w_kcol.h b/include/d/d_bg_w_kcol.h
index 1fc812dd98..b0abe32102 100644
--- a/include/d/d_bg_w_kcol.h
+++ b/include/d/d_bg_w_kcol.h
@@ -6,7 +6,10 @@
 #include "d/d_bg_plc.h"
 #include "d/d_bg_s_sph_chk.h"
 #include "d/d_bg_w_base.h"
-#include "dusk/offset_ptr.h"
+
+#if TARGET_PC
+#include "helpers/offset_ptr.h"
+#endif
 
 class cBgS_GrpPassChk;
 class cBgS_PolyPassChk;
@@ -117,7 +120,6 @@ public:
 
     void getTri1Pos(KC_PrismData* pd, Vec** nrm) const { *nrm = &m_pkc_head->m_pos_data[pd->pos_i]; }
 
-private:
     /* 0x18 */ KC_Header* m_pkc_head;
     /* 0x1C */ dBgPlc m_code;
     /* 0x20 */ cM3dGAab m_bnd;
diff --git a/include/d/d_camera.h b/include/d/d_camera.h
index f98667d988..6c95d1ce51 100644
--- a/include/d/d_camera.h
+++ b/include/d/d_camera.h
@@ -1169,7 +1169,7 @@ public:
         return mCamSetup.Far();
     }
 
-    static engine_fn engine_tbl[];
+    static DUSK_GAME_DATA engine_fn engine_tbl[];
 
     /* 0x000 */ camera_class* field_0x0;
 #if PARTIAL_DEBUG || DEBUG // Ensure struct layout consistent in all TUs.
diff --git a/include/d/d_cc_d.h b/include/d/d_cc_d.h
index 19f0430498..739abdcaa4 100644
--- a/include/d/d_cc_d.h
+++ b/include/d/d_cc_d.h
@@ -179,7 +179,6 @@ public:
     cXyz* GetHitPosP() { return &mHitPos; }
     void ClrHit() { dCcD_GAtTgCoCommonBase::ClrActorInfo(); }
 
-    // private:
     /* 0x1C */ u8 mSe;
     /* 0x1D */ u8 mMtrl;
     /* 0x1E */ u8 mHitMark;
@@ -215,7 +214,6 @@ public:
     u8 GetSe() { return mSe; }
     void ClrHit() { dCcD_GAtTgCoCommonBase::ClrActorInfo(); }
 
-private:
     /* 0x1C */ u8 mSe;
     /* 0x1D */ u8 mMtrl;
     /* 0x1E */ u8 mHitMark;
@@ -258,7 +256,6 @@ public:
     void SetTgSpl(dCcG_Tg_Spl spl) { mTg = spl; }
     void OnNoActor() { field_0x1C |= 1; }
 
-    // private:
     /* 0x04 */ u8 mAt;
     /* 0x05 */ u8 mTg;
     /* 0x06 */ u8 mRoomId;
@@ -424,7 +421,7 @@ public:
     bool ChkTgShieldHit() { return mGObjTg.ChkRPrm(2); }
     bool ChkTgSpinnerReflect() { return mGObjTg.ChkSPrm(0x200); }
     
-    static const Z2SoundID m_hitSeID[24];
+    static DUSK_GAME_DATA const Z2SoundID m_hitSeID[24];
 
 protected:
     /* 0x058 */ dCcD_GObjAt mGObjAt;
diff --git a/include/d/d_cc_mass_s.h b/include/d/d_cc_mass_s.h
index 672adb913a..291cb4552c 100644
--- a/include/d/d_cc_mass_s.h
+++ b/include/d/d_cc_mass_s.h
@@ -6,7 +6,7 @@
 typedef void (*dCcMassS_ObjCallback)(fopAc_ac_c*, cXyz*, u32);
 
 class dCcMassS_Obj {
-private:
+public:
     /* 0x00 */ cCcD_Obj* mpObj;
     /* 0x04 */ u8 mPriority;
     /* 0x08 */ dCcMassS_ObjCallback mpAreaCheckFunc;
@@ -28,7 +28,7 @@ public:
 STATIC_ASSERT(0x20 == sizeof(dCcMassS_Obj));
 
 class dCcMassS_HitInf {
-private:
+public:
     /* 0x00 */ cCcD_Obj* mpArea;
     /* 0x04 */ cCcD_Obj* mpAtObj;
     /* 0x08 */ cCcD_Obj* mpCoObj;
diff --git a/include/d/d_cc_s.h b/include/d/d_cc_s.h
index d156867cce..0ebf4a5265 100644
--- a/include/d/d_cc_s.h
+++ b/include/d/d_cc_s.h
@@ -75,7 +75,7 @@ public:
     BOOL ChkLine(cXyz&, cXyz&, f32, fopAc_ac_c**);
 #endif
 
-    static bool m_mtrl_hit_tbl[64];
+    static DUSK_GAME_DATA bool m_mtrl_hit_tbl[64];
 
     // /* 0x0000 */ cCcS mCCcS;
     /* 0x284C */ dCcMassS_Mng mMass_Mng;
diff --git a/include/d/d_com_inf_actor.h b/include/d/d_com_inf_actor.h
index da5e5fc62f..5ebd30c33c 100644
--- a/include/d/d_com_inf_actor.h
+++ b/include/d/d_com_inf_actor.h
@@ -14,8 +14,8 @@ public:
     /* 0x4 */ bool mPause;
 };
 
-extern dComIfGoat_info_c g_dComIfGoat_gameInfo;
-extern dComIfAc_info_c g_dComIfAc_gameInfo;
+DUSK_GAME_EXTERN dComIfGoat_info_c g_dComIfGoat_gameInfo;
+DUSK_GAME_EXTERN dComIfAc_info_c g_dComIfAc_gameInfo;
 
 inline bool dComIfA_PauseCheck() {
     return g_dComIfAc_gameInfo.mPause;
diff --git a/include/d/d_com_inf_game.h b/include/d/d_com_inf_game.h
index b66c1ee8e8..dcf681162f 100644
--- a/include/d/d_com_inf_game.h
+++ b/include/d/d_com_inf_game.h
@@ -17,7 +17,10 @@
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>
 
-#include "dusk/profiling.hpp"
+#if defined(DUSK_BUILDING_GAME)
+#include <tracy/Tracy.hpp>
+#include "dusk/settings.h"
+#endif
 
 enum dComIfG_ButtonStatus {
     /* 0x00 */ BUTTON_STATUS_NONE,
@@ -246,7 +249,6 @@ public:
     ~dComIfG_resLoader_c();
     int load(char const**, JKRHeap*);
 
-private:
     /* 0x0 */ const char** mResNameTable;
     /* 0x4 */ request_of_phase_process_class mPhase;
     /* 0xC */ u8 mLoadIndex;
@@ -1049,11 +1051,11 @@ public:
 
 STATIC_ASSERT(122384 == sizeof(dComIfG_inf_c));
 
-extern dComIfG_inf_c g_dComIfG_gameInfo;
-extern GXColor g_blackColor;
-extern GXColor g_clearColor;
-extern GXColor g_whiteColor;
-extern GXColor g_saftyWhiteColor;
+DUSK_GAME_EXTERN dComIfG_inf_c g_dComIfG_gameInfo;
+DUSK_GAME_EXTERN GXColor g_blackColor;
+DUSK_GAME_EXTERN GXColor g_clearColor;
+DUSK_GAME_EXTERN GXColor g_whiteColor;
+DUSK_GAME_EXTERN GXColor g_saftyWhiteColor;
 
 int dComLbG_PhaseHandler(request_of_phase_process_class*, request_of_phase_process_fn*,
                          void*);
@@ -1268,6 +1270,938 @@ int dComIfGd_setShadow(u32 param_0, s8 param_1, J3DModel* param_2, cXyz* param_3
                        f32 param_5, f32 param_6, f32 param_7, cBgS_PolyInfo& param_8,
                        dKy_tevstr_c* param_9, s16 param_10, f32 param_11, TGXTexObj* param_12);
 
+#if TARGET_PC
+DUSK_NOINLINE dSv_info_c* dComIfGs_getSaveInfo();
+DUSK_NOINLINE dSv_save_c* dComIfGs_getSaveData();
+DUSK_NOINLINE u16 dComIfGs_getMaxLife();
+DUSK_NOINLINE void dComIfGs_setMaxLife(u8 i_maxLife);
+DUSK_NOINLINE u16 dComIfGs_getLife();
+DUSK_NOINLINE void dComIfGs_setLife(u16 i_life);
+DUSK_NOINLINE u16 dComIfGs_getRupee();
+DUSK_NOINLINE void dComIfGs_setRupee(u16 i_rupees);
+DUSK_NOINLINE u16 dComIfGs_getMaxOil();
+DUSK_NOINLINE void dComIfGs_setMaxOil(u16 i_maxOil);
+DUSK_NOINLINE u16 dComIfGs_getOil();
+DUSK_NOINLINE void dComIfGs_setOil(u16 i_oil);
+DUSK_NOINLINE u8 dComIfGs_getSelectEquipClothes();
+DUSK_NOINLINE u8 dComIfGs_getSelectEquipSword();
+DUSK_NOINLINE u8 dComIfGs_getSelectEquipShield();
+DUSK_NOINLINE u8 dComIfGs_getCollectSmell();
+DUSK_NOINLINE void dComIfGs_setCollectSmell(u8 smell);
+DUSK_NOINLINE u8 dComIfGs_getBButtonItemKey();
+DUSK_NOINLINE void dComIfGs_setBButtonItemKey(u8 i_itemNo);
+DUSK_NOINLINE u8 dComIfGs_getWalletSize();
+DUSK_NOINLINE void dComIfGs_setWalletSize(u8 i_size);
+DUSK_NOINLINE u8 dComIfGs_getMaxMagic();
+DUSK_NOINLINE void dComIfGs_setMaxMagic(u8 i_maxMagic);
+DUSK_NOINLINE u8 dComIfGs_getMagic();
+DUSK_NOINLINE void dComIfGs_setMagic(u8 i_magic);
+DUSK_NOINLINE u8 dComIfGs_getTransformStatus();
+DUSK_NOINLINE void dComIfGs_setTransformStatus(u8 i_status);
+DUSK_NOINLINE u8 dComIfGs_getSelectItemIndex(int i_no);
+DUSK_NOINLINE u16 dComIfGs_getRupeeMax();
+DUSK_NOINLINE void dComIfGs_offGetMagicUseFlag();
+DUSK_NOINLINE s32 dComIfGs_isGetMagicUseFlag();
+DUSK_NOINLINE f32 dComIfGs_getTime();
+DUSK_NOINLINE void dComIfGs_setTime(f32 i_time);
+DUSK_NOINLINE u16 dComIfGs_getDate();
+DUSK_NOINLINE void dComIfGs_setDate(u16 i_date);
+DUSK_NOINLINE void dComIfGs_onDarkClearLV(int i_no);
+DUSK_NOINLINE void dComIfGs_offDarkClearLV(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isDarkClearLV(int i_no);
+DUSK_NOINLINE void dComIfGs_onTransformLV(int i_no);
+DUSK_NOINLINE void dComIfGs_offTransformLV(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isTransformLV(int i_no);
+DUSK_NOINLINE cXyz dComIfGs_getHorseRestartPos();
+DUSK_NOINLINE s16 dComIfGs_getHorseRestartAngleY();
+DUSK_NOINLINE const char* dComIfGs_getHorseRestartStageName();
+DUSK_NOINLINE s8 dComIfGs_getHorseRestartRoomNo();
+DUSK_NOINLINE void dComIfGs_setHorseRestart(
+    const char* i_stageName, cXyz& i_pos, s16 i_angle, s8 i_roomNo);
+DUSK_NOINLINE cXyz dComIfGs_getPlayerFieldLastStayPos();
+DUSK_NOINLINE s16 dComIfGs_getPlayerFieldLastStayAngleY();
+DUSK_NOINLINE char* dComIfGs_getPlayerFieldLastStayName();
+DUSK_NOINLINE u8 dComIfGs_getPlayerFieldLastStayRegionNo();
+DUSK_NOINLINE bool dComIfGs_isPlayerFieldLastStayFieldDataExistFlag();
+DUSK_NOINLINE void dComIfGs_offPlayerFieldLastStayFieldDataExistFlag();
+DUSK_NOINLINE void dComIfGs_onPlayerFieldLastStayFieldDataExistFlag();
+DUSK_NOINLINE BOOL dComIfGs_isRegionBit(int i_region);
+DUSK_NOINLINE void dComIfGs_onRegionBit(int i_region);
+DUSK_NOINLINE void dComIfGs_setPlayerFieldLastStayInfo(
+    const char* i_stage, cXyz& i_pos, s16 i_angle, s8 i_point, u8 i_region);
+DUSK_NOINLINE cXyz dComIfGs_getLastWarpMarkPlayerPos();
+DUSK_NOINLINE s16 dComIfGs_getLastWarpMarkPlayerAngleY();
+DUSK_NOINLINE const char* dComIfGs_getLastWarpMarkStageName();
+DUSK_NOINLINE u8 dComIfGs_getLastWarpMarkRoomNo();
+DUSK_NOINLINE s8 dComIfGs_getLastWarpAcceptStage();
+DUSK_NOINLINE void dComIfGs_setLastWarpAcceptStage(s8 param_0);
+DUSK_NOINLINE void dComIfGs_resetLastWarpAcceptStage();
+DUSK_NOINLINE void dComIfGs_setItem(int i_slotNo, u8 i_itemNo);
+DUSK_NOINLINE u8 dComIfGs_getItem(int i_slotNo, bool i_checkCombo);
+DUSK_NOINLINE void dComIfGs_setLineUpItem();
+DUSK_NOINLINE u8 dComIfGs_getLineUpItem(int i_slotNo);
+DUSK_NOINLINE void dComIfGs_setBottleItemIn(u8 curItem, u8 newItem);
+DUSK_NOINLINE void dComIfGs_setEmptyBottleItemIn(u8 i_itemNo);
+DUSK_NOINLINE void dComIfGs_setEmptyBottle();
+DUSK_NOINLINE void dComIfGs_setEmptyBottle(u8 i_itemNo);
+DUSK_NOINLINE void dComIfGs_setEquipBottleItemIn(u8 i_curItem, u8 i_newItem);
+DUSK_NOINLINE void dComIfGs_setEquipBottleItemEmpty(u8 i_curItem);
+DUSK_NOINLINE u8 dComIfGs_checkBottle(u8 i_itemNo);
+DUSK_NOINLINE u8 dComIfGs_checkInsectBottle();
+DUSK_NOINLINE u8 dComIfGs_checkEmptyBottle();
+DUSK_NOINLINE void dComIfGs_setEmptyBombBagItemIn(u8 i_newBomb, bool i_setNum);
+DUSK_NOINLINE void dComIfGs_setEmptyBombBagItemIn(u8 i_newBomb, u8 i_bombNum, bool i_setNum);
+DUSK_NOINLINE void dComIfGs_setEmptyBombBag();
+DUSK_NOINLINE void dComIfGs_setEmptyBombBag(u8 i_newBomb, u8 i_bombNum);
+DUSK_NOINLINE u8 dComIfGs_checkBombBag(u8 i_itemNo);
+DUSK_NOINLINE void dComIfGs_setWarashibeItem(u8 i_itemNo);
+DUSK_NOINLINE void dComIfGs_setRodTypeLevelUp();
+DUSK_NOINLINE void dComIfGs_setBaitItem(u8 i_item);
+DUSK_NOINLINE void dComIfGs_onItemFirstBit(u8 i_itemNo);
+DUSK_NOINLINE void dComIfGs_offItemFirstBit(u8 i_itemNo);
+DUSK_NOINLINE int dComIfGs_isItemFirstBit(u8 i_no);
+DUSK_NOINLINE u8 dComIfGs_getArrowNum();
+DUSK_NOINLINE void dComIfGs_setArrowNum(u8 i_arrowNum);
+DUSK_NOINLINE u8 dComIfGs_getPachinkoNum();
+DUSK_NOINLINE void dComIfGs_setPachinkoNum(u8 i_num);
+DUSK_NOINLINE u8 dComIfGs_getPachinkoMax();
+DUSK_NOINLINE void dComIfGs_setBombNum(u8 i_num);
+DUSK_NOINLINE void dComIfGs_setBombNum(u8 i_bagIdx, u8 i_bombNum);
+DUSK_NOINLINE u8 dComIfGs_getBombNum(u8 i_bagIdx);
+DUSK_NOINLINE void dComIfGs_setBottleNum(u8 i_bottleIdx, u8 i_bottleNum);
+DUSK_NOINLINE void dComIfGs_addBottleNum(u8 i_bottleIdx, s16 i_num);
+DUSK_NOINLINE u8 dComIfGs_getBottleNum(u8 i_bottleIdx);
+DUSK_NOINLINE u8 dComIfGs_getArrowMax();
+DUSK_NOINLINE void dComIfGs_setArrowMax(u8 i_arrowMax);
+DUSK_NOINLINE void dComIfGs_setBombMax(u8 i_max);
+DUSK_NOINLINE void dComIfGs_setBombMax(u8 i_type, u8 i_max);
+DUSK_NOINLINE u8 dComIfGs_getBombMax();
+DUSK_NOINLINE u8 dComIfGs_getBombMax(u8 i_bombType);
+DUSK_NOINLINE void dComIfGs_setPohSpiritNum(u8 i_num);
+DUSK_NOINLINE u8 dComIfGs_getPohSpiritNum();
+DUSK_NOINLINE void dComIfGs_addPohSpiritNum();
+DUSK_NOINLINE BOOL dComIfGs_isCollectClothes(u8 i_clothesNo);
+DUSK_NOINLINE void dComIfGs_setCollectClothes(u8 i_clothesNo);
+DUSK_NOINLINE void dComIfGs_setCollectSword(u8 i_swordNo);
+DUSK_NOINLINE void dComIfGs_setCollectShield(u8 i_shieldNo);
+DUSK_NOINLINE BOOL dComIfGs_isCollectClothing(u8 i_clothesNo);
+DUSK_NOINLINE void dComIfGs_offCollectClothes(u8 i_clothesNo);
+DUSK_NOINLINE BOOL dComIfGs_isCollectSword(u8 i_swordNo);
+DUSK_NOINLINE void dComIfGs_offCollectSword(u8 i_swordNo);
+DUSK_NOINLINE BOOL dComIfGs_isCollectShield(u8 i_item);
+DUSK_NOINLINE void dComIfGs_offCollectShield(u8 i_shieldNo);
+DUSK_NOINLINE void dComIfGs_onCollectCrystal(u8 i_item);
+DUSK_NOINLINE void dComIfGs_offCollectCrystal(u8 i_item);
+DUSK_NOINLINE bool dComIfGs_isCollectCrystal(u8 i_item);
+DUSK_NOINLINE void dComIfGs_onCollectMirror(u8 i_item);
+DUSK_NOINLINE void dComIfGs_offCollectMirror(u8 i_item);
+DUSK_NOINLINE bool dComIfGs_isCollectMirror(u8 i_item);
+DUSK_NOINLINE void dComIfGs_setLightDropNum(u8 i_level, u8 i_num);
+DUSK_NOINLINE u8 dComIfGs_getLightDropNum(u8 i_nowLevel);
+DUSK_NOINLINE void dComIfGs_onLightDropGetFlag(u8 i_nowLevel);
+DUSK_NOINLINE void dComIfGs_offLightDropGetFlag(u8 i_level);
+DUSK_NOINLINE BOOL dComIfGs_isLightDropGetFlag(u8 i_nowLevel);
+DUSK_NOINLINE void dComIfGs_onLetterGetFlag(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isLetterGetFlag(int i_no);
+DUSK_NOINLINE void dComIfGs_onLetterReadFlag(int i_no);
+DUSK_NOINLINE int dComIfGs_isLetterReadFlag(int i_no);
+DUSK_NOINLINE u8 dComIfGs_getGetNumber(int i_no);
+DUSK_NOINLINE void dComIfGs_setGetNumber(int i_no, u8 i_value);
+DUSK_NOINLINE void dComIfGs_addFishNum(u8 param_0);
+DUSK_NOINLINE u16 dComIfGs_getFishNum(u8 param_0);
+DUSK_NOINLINE u8 dComIfGs_getFishSize(u8 param_0);
+DUSK_NOINLINE void dComIfGs_setFishSize(u8 param_0, u8 param_1);
+DUSK_NOINLINE OSTime dComIfGs_getTotalTime();
+DUSK_NOINLINE void dComIfGs_addDeathCount();
+DUSK_NOINLINE u16 dComIfGs_getDeathCount();
+DUSK_NOINLINE TEXT_SPAN dComIfGs_getPlayerName();
+DUSK_NOINLINE void dComIfGs_setPlayerName(const char* i_name);
+DUSK_NOINLINE TEXT_SPAN dComIfGs_getHorseName();
+DUSK_NOINLINE void dComIfGs_setHorseName(const char* i_name);
+DUSK_NOINLINE u8 dComIfGs_getClearCount();
+
+// Ruby inline names are from TWW debug.
+DUSK_NOINLINE u8 dComIfGs_getOptRuby();
+DUSK_NOINLINE void dComIfGs_setOptRuby(u8 i_ruby);
+DUSK_NOINLINE u8 dComIfGs_getOptAttentionType();
+DUSK_NOINLINE void dComIfGs_setOptAttentionType(u8 i_attentionType);
+DUSK_NOINLINE void dComIfGs_setOptCalibrateDist(u16 i_calibrateDist);
+DUSK_NOINLINE void dComIfGs_setOptCalValue(s8 i_calValue);
+DUSK_NOINLINE u8 dComIfGs_getOptCameraControl();
+DUSK_NOINLINE void dComIfGs_setOptCameraControl(u8 i_cameraControl);
+DUSK_NOINLINE u8 dComIfGs_getOptPointer();
+DUSK_NOINLINE void dComIfGs_setOptPointer(u8 i_pointer);
+DUSK_NOINLINE u8 dComIfGs_checkOptVibration();
+DUSK_NOINLINE u8 dComIfGs_getOptSound();
+DUSK_NOINLINE void dComIfGs_setOptSound(u8 i_mode);
+DUSK_NOINLINE u8 dComIfGs_getOptVibration();
+DUSK_NOINLINE void dComIfGs_setOptVibration(u8 i_status);
+DUSK_NOINLINE u8 dComIfGs_getPalLanguage();
+DUSK_NOINLINE BOOL dComIfGs_isSaveTbox(int i_stageNo, int i_no);
+DUSK_NOINLINE void dComIfGs_onSaveSwitch(int i_stageNo, int i_no);
+DUSK_NOINLINE void dComIfGs_offSaveSwitch(int i_stageNo, int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isSaveSwitch(int i_stageNo, int i_no);
+DUSK_NOINLINE void dComIfGs_onSaveVisitedRoom(int param_0, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_offSaveVisitedRoom(int param_0, int i_roomNo);
+DUSK_NOINLINE BOOL dComIfGs_isSaveVisitedRoom(int param_0, int i_roomNo);
+DUSK_NOINLINE void* dComIfGs_getPEventBit();
+DUSK_NOINLINE void dComIfGs_onEventBit(const u16 i_flag);
+DUSK_NOINLINE void dComIfGs_offEventBit(const u16 i_flag);
+DUSK_NOINLINE BOOL dComIfGs_isEventBit(const u16 i_flag);
+DUSK_NOINLINE void dComIfGs_setEventReg(u16 reg, u8 value);
+DUSK_NOINLINE u8 dComIfGs_getEventReg(u16 reg);
+DUSK_NOINLINE int dComIfGs_getHookGameTime();
+DUSK_NOINLINE void dComIfGs_setHookGameTime(u32 i_time);
+DUSK_NOINLINE u32 dComIfGs_getBalloonScore();
+DUSK_NOINLINE void dComIfGs_setBalloonScore(u32 i_score);
+DUSK_NOINLINE int dComIfGs_getRaceGameTime();
+DUSK_NOINLINE void dComIfGs_setRaceGameTime(int i_time);
+DUSK_NOINLINE u8 dComIfGs_getKeyNum();
+DUSK_NOINLINE void dComIfGs_setKeyNum(u8 i_keyNum);
+DUSK_NOINLINE void dComIfGs_onDungeonItemMap();
+DUSK_NOINLINE void dComIfGs_offDungeonItemMap();
+DUSK_NOINLINE s32 dComIfGs_isDungeonItemMap();
+DUSK_NOINLINE void dComIfGs_onDungeonItemCompass();
+DUSK_NOINLINE void dComIfGs_offDungeonItemCompass();
+DUSK_NOINLINE s32 dComIfGs_isDungeonItemCompass();
+DUSK_NOINLINE void dComIfGs_onDungeonItemBossKey();
+DUSK_NOINLINE void dComIfGs_offDungeonItemBossKey();
+DUSK_NOINLINE s32 dComIfGs_isDungeonItemBossKey();
+DUSK_NOINLINE void dComIfGs_onStageBossEnemy();
+DUSK_NOINLINE void dComIfGs_offStageBossEnemy();
+DUSK_NOINLINE s32 dComIfGs_isStageBossEnemy();
+DUSK_NOINLINE void dComIfGs_onStageLife();
+DUSK_NOINLINE void dComIfGs_offStageLife();
+DUSK_NOINLINE s32 dComIfGs_isStageLife();
+DUSK_NOINLINE void dComIfGs_onStageBossDemo();
+DUSK_NOINLINE void dComIfGs_offStageBossDemo();
+DUSK_NOINLINE s32 dComIfGs_isStageBossDemo();
+DUSK_NOINLINE void dComIfGs_onDungeonItemWarp();
+DUSK_NOINLINE void dComIfGs_offDungeonItemWarp();
+DUSK_NOINLINE s32 dComIfGs_isDungeonItemWarp();
+DUSK_NOINLINE void dComIfGs_onStageMiddleBoss();
+DUSK_NOINLINE void dComIfGs_offStageMiddleBoss();
+DUSK_NOINLINE BOOL dComIfGs_isStageMiddleBoss();
+DUSK_NOINLINE void dComIfGs_onTbox(int i_no);
+DUSK_NOINLINE void dComIfGs_offTbox(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isTbox(int i_no);
+DUSK_NOINLINE void dComIfGs_onSaveSwitch(int i_no);
+DUSK_NOINLINE void dComIfGs_offSaveSwitch(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isSaveSwitch(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isSaveItem(int i_no);
+DUSK_NOINLINE void dComIfGs_onSaveDunSwitch(int i_swNo);
+DUSK_NOINLINE void dComIfGs_offSaveDunSwitch(int i_swNo);
+DUSK_NOINLINE BOOL dComIfGs_isSaveDunSwitch(int i_no);
+DUSK_NOINLINE BOOL dComIfGs_isSaveDunItem(int i_no);
+DUSK_NOINLINE void dComIfGs_resetDan();
+DUSK_NOINLINE void dComIfGs_initDan(s8 i_stageNo);
+DUSK_NOINLINE void dComIfGs_clearRoomSwitch(int i_zoneNo);
+DUSK_NOINLINE void dComIfGs_clearRoomItem(int i_zoneNo);
+DUSK_NOINLINE void dComIfGs_onSvZoneSwitch(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_offSvZoneSwitch(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE BOOL dComIfGs_isSvZoneSwitch(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_onSvOneZoneSwitch(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_offSvOneZoneSwitch(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE BOOL dComIfGs_isSvOneZoneSwitch(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_onSvZoneItem(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_offSvZoneItem(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE BOOL dComIfGs_isSvZoneItem(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_onSvOneZoneItem(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_offSvOneZoneItem(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE BOOL dComIfGs_isSvOneZoneItem(int i_zoneNo, int i_swBit);
+DUSK_NOINLINE void dComIfGs_removeZone(int i_zoneNo);
+DUSK_NOINLINE s8 dComIfGs_getRestartRoomNo();
+DUSK_NOINLINE s16 dComIfGs_getStartPoint();
+DUSK_NOINLINE void dComIfGs_setStartPoint(s16 i_point);
+DUSK_NOINLINE s16 dComIfGs_getRestartRoomAngleY();
+DUSK_NOINLINE const cXyz& dComIfGs_getRestartRoomPos();
+DUSK_NOINLINE u32 dComIfGs_getRestartRoomParam();
+DUSK_NOINLINE void dComIfGs_setRestartRoomParam(u32 i_param);
+DUSK_NOINLINE f32 dComIfGs_getLastSceneSpeedF();
+DUSK_NOINLINE u32 dComIfGs_getLastSceneMode();
+DUSK_NOINLINE s16 dComIfGs_getLastSceneAngleY();
+DUSK_NOINLINE void dComIfGs_setRestartRoom(const cXyz& i_position, s16 i_angle, s8 i_roomNo);
+DUSK_NOINLINE void dComIfGs_onTmpBit(const u16 i_flag);
+DUSK_NOINLINE void dComIfGs_offTmpBit(const u16 i_flag);
+DUSK_NOINLINE BOOL dComIfGs_isTmpBit(const u16 i_flag);
+DUSK_NOINLINE void dComIfGs_setTmpReg(u16 i_reg, u8 i_no);
+DUSK_NOINLINE u8 dComIfGs_getTmpReg(const u16 i_reg);
+DUSK_NOINLINE dSv_turnRestart_c& dComIfGs_getTurnRestart();
+DUSK_NOINLINE const cXyz& dComIfGs_getTurnRestartPos();
+DUSK_NOINLINE u32 dComIfGs_getTurnRestartParam();
+DUSK_NOINLINE s16 dComIfGs_getTurnRestartAngleY();
+DUSK_NOINLINE s8 dComIfGs_getTurnRestartRoomNo();
+DUSK_NOINLINE void dComIfGs_setTurnRestart(
+    const cXyz& i_position, s16 i_angle, s8 param_2, u32 i_param);
+DUSK_NOINLINE u8 dComIfGs_getDataNum();
+DUSK_NOINLINE void dComIfGs_setDataNum(u8 i_num);
+DUSK_NOINLINE u8 dComIfGs_getNewFile();
+DUSK_NOINLINE void dComIfGs_setNewFile(u8 i_fileNo);
+DUSK_NOINLINE u8 dComIfGs_getNoFile();
+DUSK_NOINLINE void dComIfGs_setNoFile(u8 i_file);
+DUSK_NOINLINE s64 dComIfGs_getSaveStartTime();
+DUSK_NOINLINE void dComIfGs_setSaveStartTime(s64 i_time);
+DUSK_NOINLINE s64 dComIfGs_getSaveTotalTime();
+DUSK_NOINLINE void dComIfGs_setSaveTotalTime(s64 i_time);
+DUSK_NOINLINE void dComIfGs_init();
+DUSK_NOINLINE void dComIfGs_getSave(int i_stageNo);
+DUSK_NOINLINE void dComIfGs_putSave(int i_stageNo);
+DUSK_NOINLINE void dComIfGs_initZone();
+DUSK_NOINLINE int dComIfGs_createZone(int roomNo);
+DUSK_NOINLINE void dComIfGs_onSwitch(int i_no, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_offSwitch(int i_no, int i_roomNo);
+DUSK_NOINLINE BOOL dComIfGs_isSwitch(int i_no, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_revSwitch(int i_no, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_onItem(int i_bitNo, int i_roomNo);
+DUSK_NOINLINE bool dComIfGs_isItem(int i_bitNo, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_onActor(int i_bitNo, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_offActor(int i_no, int i_roomNo);
+DUSK_NOINLINE BOOL dComIfGs_isActor(int i_no, int i_roomNo);
+DUSK_NOINLINE void dComIfGs_setMemoryToCard(u8* i_saveData, int i_dataNum);
+DUSK_NOINLINE void dComIfGs_setCardToMemory(u8* card_ptr, int dataNum);
+DUSK_NOINLINE void dComIfGs_setInitDataToCard(u8* i_saveData, int i_dataNum);
+DUSK_NOINLINE u8 dComIfGs_getWolfAbility(int i_idx);
+DUSK_NOINLINE s8 dComIfGs_Grass_hide_Check();
+DUSK_NOINLINE dStage_startStage_c* dComIfGp_getStartStage();
+DUSK_NOINLINE void dComIfGp_setStartStage(dStage_startStage_c* p_startStage);
+DUSK_NOINLINE const char* dComIfGp_getStartStageName();
+DUSK_NOINLINE s16 dComIfGp_getStartStagePoint();
+DUSK_NOINLINE s8 dComIfGp_getStartStageRoomNo();
+DUSK_NOINLINE s8 dComIfGp_getStartStageLayer();
+DUSK_NOINLINE void dComIfGp_setStartStageLayer(s8 layer);
+DUSK_NOINLINE s8 dComIfGp_getStartStageDarkArea();
+DUSK_NOINLINE void dComIfGp_setStartStageDarkArea(s8 darkArea);
+DUSK_NOINLINE dStage_startStage_c* dComIfGp_getNextStartStage();
+DUSK_NOINLINE const char* dComIfGp_getNextStageName();
+DUSK_NOINLINE s16 dComIfGp_getNextStagePoint();
+DUSK_NOINLINE s16 dComIfGp_getNextStageRoomNo();
+DUSK_NOINLINE s16 dComIfGp_getNextStageLayer();
+DUSK_NOINLINE BOOL dComIfGp_isEnableNextStage();
+DUSK_NOINLINE void dComIfGp_offEnableNextStage();
+DUSK_NOINLINE s8 dComIfGp_getNextStageWipe();
+DUSK_NOINLINE u8 dComIfGp_getNextStageWipeSpeed();
+DUSK_NOINLINE dStage_stageDt_c* dComIfGp_getStage();
+DUSK_NOINLINE roomRead_class* dComIfGp_getStageRoom();
+DUSK_NOINLINE stage_palette_info_class* dComIfGp_getStagePaletteInfo();
+DUSK_NOINLINE stage_pselect_info_class* dComIfGp_getStagePselectInfo();
+DUSK_NOINLINE stage_envr_info_class* dComIfGp_getStageEnvrInfo();
+DUSK_NOINLINE stage_vrboxcol_info_class* dComIfGp_getStageVrboxcolInfo();
+DUSK_NOINLINE stage_plight_info_class* dComIfGp_getStagePlightInfo();
+DUSK_NOINLINE int dComIfGp_getStagePaletteNumInfo();
+DUSK_NOINLINE int dComIfGp_getStagePselectNumInfo();
+DUSK_NOINLINE int dComIfGp_getStageEnvrNumInfo();
+DUSK_NOINLINE int dComIfGp_getStageVrboxcolNumInfo();
+DUSK_NOINLINE int dComIfGp_getStagePlightNumInfo();
+DUSK_NOINLINE stage_stag_info_class* dComIfGp_getStageStagInfo();
+DUSK_NOINLINE stage_scls_info_dummy_class* dComIfGp_getStageSclsInfo();
+DUSK_NOINLINE dStage_Multi_c* dComIfGp_getMulti();
+DUSK_NOINLINE void dComIfGp_setOldMulti();
+DUSK_NOINLINE void dComIfGp_resetOldMulti();
+DUSK_NOINLINE s16 dComIfGp_getStageWorldRollAngleX();
+DUSK_NOINLINE s16 dComIfGp_getStageWorldRollDirAngleY();
+DUSK_NOINLINE int dComIfGp_roomControl_getStayNo();
+DUSK_NOINLINE BOOL dComIfGp_roomControl_getTimePass();
+DUSK_NOINLINE void dComIfGp_roomControl_setTimePass(int isPassing);
+DUSK_NOINLINE dKy_tevstr_c* dComIfGp_roomControl_getTevStr(int i_roomNo);
+DUSK_NOINLINE void dComIfGp_roomControl_setStatusFlag(int i_roomNo, u8 flag);
+DUSK_NOINLINE void dComIfGp_roomControl_onStatusFlag(int i_roomNo, u8 flag);
+DUSK_NOINLINE void dComIfGp_roomControl_offStatusFlag(int i_roomNo, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_roomControl_checkStatusFlag(int i_roomNo, u8 flag);
+DUSK_NOINLINE s32 dComIfGp_roomControl_getZoneNo(int i_roomNo);
+DUSK_NOINLINE void dComIfGp_roomControl_setZoneNo(int roomNo, int zoneNo);
+DUSK_NOINLINE void dComIfGp_roomControl_init();
+DUSK_NOINLINE void dComIfGp_roomControl_initZone();
+DUSK_NOINLINE dStage_roomDt_c* dComIfGp_roomControl_getStatusRoomDt(int room_no);
+DUSK_NOINLINE void dComIfGp_roomControl_setStayNo(int stayNo);
+DUSK_NOINLINE BOOL dComIfGp_roomControl_checkRoomDisp(int i_roomNo);
+DUSK_NOINLINE int dComIfGp_roomControl_loadRoom(int param_0, u8* param_1, bool param_2);
+DUSK_NOINLINE void dComIfGp_roomControl_zoneCountCheck(int i_roomNo);
+DUSK_NOINLINE dEvt_control_c* dComIfGp_getEvent();
+DUSK_NOINLINE u16 dComIfGp_event_chkEventFlag(u16 i_flag);
+DUSK_NOINLINE void dComIfGp_event_onEventFlag(u16 i_flag);
+DUSK_NOINLINE void dComIfGp_event_onHindFlag(u16 i_flag);
+DUSK_NOINLINE void dComIfGp_event_offHindFlag(u16 i_flag);
+DUSK_NOINLINE u8 dComIfGp_event_getMode();
+DUSK_NOINLINE BOOL dComIfGp_event_runCheck();
+DUSK_NOINLINE u16 dComIfGp_event_checkHind(u16 i_hindFlag);
+DUSK_NOINLINE BOOL dComIfGp_event_chkTalkXY();
+DUSK_NOINLINE u8 dComIfGp_event_getPreItemNo();
+DUSK_NOINLINE f32 dComIfGp_event_getCullRate();
+DUSK_NOINLINE void dComIfGp_event_setCullRate(f32 i_rate);
+DUSK_NOINLINE int dComIfGp_event_order(u16 i_type, u16 i_prio, u16 i_flags, u16 i_hindFlags,
+    void* i_requestActor, void* i_targetActor, s16 i_eventID, u8 i_mapToolId);
+DUSK_NOINLINE void dComIfGp_event_reset();
+DUSK_NOINLINE int dComIfGp_event_moveApproval(void* i_actor);
+DUSK_NOINLINE BOOL dComIfGp_event_compulsory(
+    void* i_actor, const char* i_eventname, u16 i_hindFlag);
+DUSK_NOINLINE void dComIfGp_event_remove();
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_event_getPt1();
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_event_getPt2();
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_event_getTalkPartner();
+DUSK_NOINLINE void dComIfGp_event_setTalkPartner(void* i_actor);
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_event_getItemPartner();
+DUSK_NOINLINE void dComIfGp_event_setItemPartner(void* i_actor);
+DUSK_NOINLINE void dComIfGp_event_setItemPartnerId(fpc_ProcID i_id);
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_event_getDoorPartner();
+DUSK_NOINLINE void dComIfGp_event_setDoorPartner(void* i_partner);
+DUSK_NOINLINE u8 dComIfGp_event_getGtItm();
+DUSK_NOINLINE void dComIfGp_event_setGtItm(u8 i_itemNo);
+DUSK_NOINLINE dEvent_manager_c& dComIfGp_getEventManager();
+DUSK_NOINLINE dEvent_manager_c* dComIfGp_getPEvtManager();
+DUSK_NOINLINE int dComIfGp_evmng_cameraPlay();
+DUSK_NOINLINE int dComIfGp_evmng_startDemo(int i_mapToolId);
+DUSK_NOINLINE void dComIfGp_evmng_create();
+DUSK_NOINLINE void dComIfGp_evmng_remove();
+DUSK_NOINLINE bool dComIfGp_evmng_existence(s16 eventId);
+DUSK_NOINLINE s16 dComIfGp_evmng_getEventIdx(const char* eventName, u8 mapToolID);
+DUSK_NOINLINE bool dComIfGp_evmng_existence(const char* eventname);
+DUSK_NOINLINE BOOL dComIfGp_evmng_isMapToolCamera(u8 mapToolID);
+DUSK_NOINLINE BOOL dComIfGp_evmng_startCheck(s16 i_eventId);
+DUSK_NOINLINE BOOL dComIfGp_evmng_startCheck(char const* i_eventname);
+DUSK_NOINLINE BOOL dComIfGp_evmng_endCheck(s16 i_eventID);
+DUSK_NOINLINE BOOL dComIfGp_evmng_endCheck(const char* i_eventname);
+DUSK_NOINLINE int dComIfGp_evmng_getMyStaffId(
+    const char* i_staffname, fopAc_ac_c* i_actor, int i_tagId);
+DUSK_NOINLINE int dComIfGp_evmng_getIsAddvance(int i_staffId);
+DUSK_NOINLINE int dComIfGp_evmng_getMyActIdx(int i_staffId, DUSK_CONST char* DUSK_CONST* i_actions,
+    int i_actionNum, BOOL param_3, BOOL param_4);
+DUSK_NOINLINE f32* dComIfGp_evmng_getMyFloatP(int i_staffId, DUSK_CONST char* i_dataname);
+DUSK_NOINLINE cXyz* dComIfGp_evmng_getMyXyzP(int i_staffId, DUSK_CONST char* i_dataname);
+DUSK_NOINLINE int* dComIfGp_evmng_getMyIntegerP(int i_staffId, DUSK_CONST char* i_dataname);
+DUSK_NOINLINE char* dComIfGp_evmng_getMyStringP(int i_staffId, DUSK_CONST char* i_dataname);
+DUSK_NOINLINE int dComIfGp_evmng_getMySubstanceNum(int i_staffId, DUSK_CONST char* i_dataname);
+DUSK_NOINLINE void dComIfGp_evmng_cutEnd(int i_staffId);
+DUSK_NOINLINE void dComIfGp_evmng_setGoal(cXyz* i_pos);
+DUSK_NOINLINE cXyz* dComIfGp_evmng_getGoal();
+DUSK_NOINLINE BOOL dComIfGp_evmng_ChkPresentEnd();
+DUSK_NOINLINE int dComIfGp_evmng_checkStartDemo();
+DUSK_NOINLINE dAttention_c* dComIfGp_getAttention();
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_att_getZHint();
+DUSK_NOINLINE int dComIfGp_att_ZHintRequest(fopAc_ac_c* param_1, int param_2);
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_att_getCatghTarget();
+DUSK_NOINLINE u8 dComIfGp_att_getCatchChgItem();
+DUSK_NOINLINE int dComIfGp_att_CatchRequest(fopAc_ac_c* param_0, u8 param_1, f32 i_horizontalDist,
+    f32 i_upDist, f32 i_downDist, s16 i_angle, int param_5);
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_att_getLookTarget();
+DUSK_NOINLINE void dComIfGp_att_LookRequest(fopAc_ac_c* param_0, f32 i_horizontalDist, f32 i_upDist,
+    f32 i_downDist, s16 i_angle, int param_5);
+DUSK_NOINLINE dVibration_c& dComIfGp_getVibration();
+DUSK_NOINLINE JKRAramArchive* dComIfGp_getFieldMapArchive2();
+DUSK_NOINLINE void dComIfGp_setFieldMapArchive2(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getMsgArchive(int idx);
+DUSK_NOINLINE void dComIfGp_setMsgArchive(int i, JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getDemoMsgArchive();
+DUSK_NOINLINE void dComIfGp_setDemoMsgArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getMeterButtonArchive();
+DUSK_NOINLINE void dComIfGp_setMeterButtonArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getFontArchive();
+DUSK_NOINLINE void dComIfGp_setFontArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getRubyArchive();
+DUSK_NOINLINE void dComIfGp_setRubyArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getAnmArchive();
+DUSK_NOINLINE void dComIfGp_setAnmArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getCollectResArchive();
+DUSK_NOINLINE void dComIfGp_setCollectResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getFmapResArchive();
+DUSK_NOINLINE void dComIfGp_setFmapResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getDmapResArchive();
+DUSK_NOINLINE void dComIfGp_setDmapResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getOptionResArchive();
+DUSK_NOINLINE void dComIfGp_setOptionResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getItemIconArchive();
+DUSK_NOINLINE void dComIfGp_setItemIconArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getNameResArchive();
+DUSK_NOINLINE void dComIfGp_setNameResArchive(JKRArchive* arc);
+DUSK_NOINLINE void dComIfGp_setErrorResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getAllMapArchive();
+DUSK_NOINLINE void dComIfGp_setAllMapArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getMsgCommonArchive();
+DUSK_NOINLINE void dComIfGp_setMsgCommonArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getRingResArchive();
+DUSK_NOINLINE void dComIfGp_setRingResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getCardIconResArchive();
+DUSK_NOINLINE void dComIfGp_setCardIconResArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getMsgDtArchive();
+DUSK_NOINLINE JKRArchive* dComIfGp_getMsgDtArchive(int idx);
+DUSK_NOINLINE void dComIfGp_setMsgDtArchive(int i, JKRArchive* arc);
+DUSK_NOINLINE JKRArchive* dComIfGp_getMain2DArchive();
+DUSK_NOINLINE void dComIfGp_setMain2DArchive(JKRArchive* arc);
+DUSK_NOINLINE JKRExpHeap* dComIfGp_particle_getResHeap();
+DUSK_NOINLINE void dComIfGp_particle_levelExecute(u32 param_0);
+DUSK_NOINLINE void dComIfGp_particle_createCommon(const void* data);
+DUSK_NOINLINE void dComIfGp_particle_readScene(u8 particle_no, mDoDvdThd_toMainRam_c** param_1);
+DUSK_NOINLINE void dComIfGp_particle_createScene(const void* param_0);
+DUSK_NOINLINE void dComIfGp_particle_removeScene(bool param_0);
+DUSK_NOINLINE void dComIfGp_particle_cleanup();
+DUSK_NOINLINE void dComIfGp_particle_calc3D();
+DUSK_NOINLINE void dComIfGp_particle_calc2D();
+DUSK_NOINLINE void dComIfGp_particle_calcMenu();
+DUSK_NOINLINE void dComIfGp_particle_draw(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFog(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawP1(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawProjection(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawNormalPri0_A(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawNormalPri0_B(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFogPri0_A(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFogPri0_B(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFogPri1(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFogPri2(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFogPri3(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawFogPri4(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawDarkworld(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_drawScreen(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_draw2Dgame(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_draw2Dfore(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_draw2Dback(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_draw2DmenuFore(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_particle_draw2DmenuBack(JPADrawInfo* i_drawInfo);
+DUSK_NOINLINE void dComIfGp_setHitMark(u16 i_hitmark, fopAc_ac_c* param_1, const cXyz* param_2,
+    const csXyz* param_3, const cXyz* param_4, u32 i_atType);
+DUSK_NOINLINE void dComIfGp_particle_setWaterRipple(u32* param_0, cBgS_PolyInfo& param_1,
+    const cXyz* param_2, f32 param_3, const dKy_tevstr_c* param_4, const cXyz* param_5, s8 param_6);
+DUSK_NOINLINE u32 dComIfGp_particle_setPolyColor(u32 param_0, u16 param_1, cBgS_PolyInfo& param_2,
+    const cXyz* param_3, const dKy_tevstr_c* param_4, const csXyz* param_5, const cXyz* param_6,
+    int param_7, dPa_levelEcallBack* param_8, s8 param_9, const cXyz* param_10);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_setPolyColor(u16 param_1, cBgS_PolyInfo& param_2,
+    const cXyz* param_3, const dKy_tevstr_c* param_4, const csXyz* param_5, const cXyz* param_6,
+    int param_7, dPa_levelEcallBack* param_8, s8 param_9, const cXyz* param_10);
+DUSK_NOINLINE void dComIfGp_particle_setSimple(u16 param_0, cXyz* i_pos, u8 param_2,
+    GXColor& param_3, GXColor& param_4, int param_5, float param_6);
+DUSK_NOINLINE u32 dComIfGp_particle_setStopContinue(u32 param_0);
+DUSK_NOINLINE u32 dComIfGp_particle_setSimpleFoot(u32 param_0, u32* param_1, cBgS_PolyInfo& param_2,
+    cXyz const* param_3, dKy_tevstr_c const* param_4, int param_5, csXyz const* param_6,
+    cXyz const* param_7, dPa_levelEcallBack* param_8, s8 param_9, cXyz const* param_10);
+DUSK_NOINLINE u16 dComIfGp_particle_setCommonPoly(u32* param_0, cBgS_PolyInfo* param_1,
+    const cXyz* param_2, const cXyz* param_3, const dKy_tevstr_c* param_4, u32 param_5, u32 param_6,
+    const csXyz* param_7, const cXyz* param_8, s8 param_9);
+DUSK_NOINLINE void dComIfGp_particle_levelEmitterOnEventMove(u32 param_0);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_getEmitter(u32 param_0);
+DUSK_NOINLINE u32 dComIfGp_particle_set(u32 param_0, u16 param_1, const cXyz* i_pos,
+    const dKy_tevstr_c* param_3, const csXyz* i_rotation, const cXyz* i_scale, u8 i_alpha,
+    dPa_levelEcallBack* param_7, s8 param_8, const GXColor* param_9, const GXColor* param_10,
+    const cXyz* param_11);
+DUSK_NOINLINE u32 dComIfGp_particle_set(u32 param_0, u16 param_1, const cXyz* i_pos,
+    const csXyz* i_rotation, const cXyz* i_scale, u8 param_5, dPa_levelEcallBack* param_6,
+    s8 param_7, const GXColor* param_8, const GXColor* param_9, const cXyz* param_10);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_set(u16 i_resID, const cXyz* i_pos,
+    const dKy_tevstr_c* param_3, const csXyz* i_rotation, const cXyz* i_scale, u8 i_alpha,
+    dPa_levelEcallBack* i_callback, s8 param_8, const GXColor* i_prmColor,
+    const GXColor* i_envColor, const cXyz* i_particleScale);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_set(u16 i_resID, const cXyz* i_pos,
+    const csXyz* i_rotation, const cXyz* i_scale, u8 i_alpha, dPa_levelEcallBack* i_callback,
+    s8 param_7, const GXColor* i_prmColor, const GXColor* i_envColor, const cXyz* i_particleScale);
+DUSK_NOINLINE u32 dComIfGp_particle_set(
+    u32 param_0, u16 param_1, const cXyz* i_pos, const dKy_tevstr_c* param_3);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_set(
+    u16 i_resID, const cXyz* i_pos, const csXyz* i_rotation, const cXyz* i_scale);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_set(u16 i_resID, const cXyz* i_pos,
+    const dKy_tevstr_c* param_2, const csXyz* i_rotation, const cXyz* i_scale);
+DUSK_NOINLINE u32 dComIfGp_particle_set(
+    u32 param_0, u16 param_1, const cXyz* i_pos, const csXyz* param_3, const cXyz* param_4);
+DUSK_NOINLINE u32 dComIfGp_particle_setColor(u32 param_0, u16 param_1, const cXyz* i_pos,
+    const dKy_tevstr_c* param_3, const GXColor* param_4, const GXColor* param_5, f32 param_6,
+    u8 param_7, const csXyz* param_8, const cXyz* param_9, dPa_levelEcallBack* param_10,
+    s8 param_11, const cXyz* param_12);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_setColor(u16 param_0, const cXyz* i_pos,
+    const dKy_tevstr_c* param_2, const GXColor* param_3, const GXColor* param_4, f32 param_5,
+    u8 param_6, const csXyz* param_7, const cXyz* param_8, dPa_levelEcallBack* param_9, s8 param_10,
+    const cXyz* param_11);
+DUSK_NOINLINE JPABaseEmitter* dComIfGp_particle_setColor(u16 param_0, const cXyz* i_pos,
+    const dKy_tevstr_c* param_2, const GXColor* param_3, const GXColor* param_4, f32 param_5,
+    u8 param_6);
+DUSK_NOINLINE u32 dComIfGp_particle_getHeapSize();
+DUSK_NOINLINE u32 dComIfGp_particle_getSceneHeapSize();
+DUSK_NOINLINE int dComIfGp_particle_getEmitterNum();
+DUSK_NOINLINE int dComIfGp_particle_getParticleNum();
+DUSK_NOINLINE dSmplMdl_draw_c* dComIfGp_getSimpleModel();
+DUSK_NOINLINE int dComIfGp_getWindowNum();
+DUSK_NOINLINE void dComIfGp_setWindowNum(int num);
+DUSK_NOINLINE s8 dComIfGp_getLayerOld();
+DUSK_NOINLINE s32 dComIfGp_checkStatus(u16 flags);
+DUSK_NOINLINE void dComIfGp_setStatus(u16 status);
+DUSK_NOINLINE void dComIfGp_onStatus(u16 i_status);
+DUSK_NOINLINE dDlst_window_c* dComIfGp_getWindow(int i);
+DUSK_NOINLINE void dComIfGp_setWindow(u8 i, f32 param_1, f32 param_2, f32 param_3, f32 param_4,
+    f32 param_5, f32 param_6, int camID, int mode);
+DUSK_NOINLINE camera_process_class* dComIfGp_getCamera(int idx);
+DUSK_NOINLINE void dComIfGp_setCamera(int i, camera_class* cam);
+DUSK_NOINLINE int dComIfGp_getCameraWinID(int idx);
+DUSK_NOINLINE int dComIfGp_getCameraPlayer1ID(int idx);
+DUSK_NOINLINE int dComIfGp_getCameraPlayer2ID(int idx);
+DUSK_NOINLINE u32 dComIfGp_getCameraAttentionStatus(int i_no);
+DUSK_NOINLINE BOOL dComIfGp_checkCameraAttentionStatus(int i, u32 flag);
+DUSK_NOINLINE void dComIfGp_onCameraAttentionStatus(int i, u32 flag);
+DUSK_NOINLINE void dComIfGp_offCameraAttentionStatus(int i, u32 flag);
+DUSK_NOINLINE void dComIfGp_setCameraInfo(
+    int camIdx, camera_class* p_cam, int param_2, int param_3, int param_4);
+DUSK_NOINLINE f32 dComIfGp_getCameraZoomScale(int i_no);
+DUSK_NOINLINE void dComIfGp_setCameraZoomScale(int i_no, f32 i_scale);
+DUSK_NOINLINE f32 dComIfGp_getCameraZoomForcus(int i_no);
+DUSK_NOINLINE void dComIfGp_setCameraZoomForcus(int i_no, f32 i_focus);
+DUSK_NOINLINE const char* dComIfGp_getCameraParamFileName(int i);
+DUSK_NOINLINE void dComIfGp_setCameraParamFileName(int i, char* name);
+DUSK_NOINLINE void dComIfGp_saveCameraPosition(
+    int i, cXyz* i_pos, cXyz* i_target, f32 i_fovy, s16 i_bank);
+DUSK_NOINLINE void dComIfGp_loadCameraPosition(
+    int i, cXyz* o_pos, cXyz* o_target, f32* o_fovy, s16* o_bank);
+DUSK_NOINLINE fopAc_ac_c* dComIfGp_getPlayer(int idx);
+DUSK_NOINLINE void dComIfGp_setPlayer(int i, fopAc_ac_c* player);
+DUSK_NOINLINE int dComIfGp_getPlayerCameraID(int idx);
+DUSK_NOINLINE void dComIfGp_setPlayerInfo(int plyrIdx, fopAc_ac_c* ptr, int camIdx);
+DUSK_NOINLINE daPy_py_c* dComIfGp_getLinkPlayer();
+DUSK_NOINLINE daHorse_c* dComIfGp_getHorseActor();
+DUSK_NOINLINE void dComIfGp_setLinkPlayer(fopAc_ac_c* ptr);
+DUSK_NOINLINE void dComIfGp_setHorseActor(fopAc_ac_c* i_horse);
+DUSK_NOINLINE void dComIfGp_setPlayerPtr(int i, fopAc_ac_c* ptr);
+DUSK_NOINLINE dMsgObject_c* dComIfGp_getMsgObjectClass();
+DUSK_NOINLINE void dComIfGp_setMsgObjectClass(dMsgObject_c* obj);
+DUSK_NOINLINE f32 dComIfGp_getItemLifeCount();
+DUSK_NOINLINE u8 dComIfGp_getItemLifeCountType();
+DUSK_NOINLINE void dComIfGp_setItemLifeCount(f32 amount, u8 type);
+DUSK_NOINLINE void dComIfGp_clearItemLifeCount();
+DUSK_NOINLINE s32 dComIfGp_getItemRupeeCount();
+DUSK_NOINLINE void dComIfGp_setItemRupeeCount(s32 amount);
+DUSK_NOINLINE void dComIfGp_clearItemRupeeCount();
+DUSK_NOINLINE s16 dComIfGp_getItemKeyNumCount();
+DUSK_NOINLINE void dComIfGp_setItemKeyNumCount(s16 count);
+DUSK_NOINLINE void dComIfGp_clearItemKeyNumCount();
+DUSK_NOINLINE s16 dComIfGp_getItemMaxLifeCount();
+DUSK_NOINLINE void dComIfGp_setItemMaxLifeCount(s16 count);
+DUSK_NOINLINE void dComIfGp_clearItemMaxLifeCount();
+DUSK_NOINLINE void dComIfGp_setItemMagicCount(s16 count);
+DUSK_NOINLINE void dComIfGp_setItemNowMagic(s16 magic);
+DUSK_NOINLINE void dComIfGp_setItemMaxMagicCount(s16 count);
+DUSK_NOINLINE s32 dComIfGp_getItemOilCount();
+DUSK_NOINLINE void dComIfGp_setItemOilCount(s32 oil);
+DUSK_NOINLINE void dComIfGp_setItemMaxOilCount(s32 oil);
+DUSK_NOINLINE void dComIfGp_clearItemOilCount();
+DUSK_NOINLINE s32 dComIfGp_getItemNowOil();
+DUSK_NOINLINE void dComIfGp_setItemNowOil(s32 oil);
+DUSK_NOINLINE s32 dComIfGp_getItemMaxOilCount();
+DUSK_NOINLINE void dComIfGp_clearItemMaxOilCount();
+DUSK_NOINLINE int dComIfGp_getOxygen();
+DUSK_NOINLINE void dComIfGp_setOxygen(s32 oxygen);
+DUSK_NOINLINE int dComIfGp_getNowOxygen();
+DUSK_NOINLINE void dComIfGp_setNowOxygen(s32 oxygen);
+DUSK_NOINLINE s32 dComIfGp_getMaxOxygen();
+DUSK_NOINLINE void dComIfGp_setMaxOxygen(s32 i_oxygen);
+DUSK_NOINLINE s32 dComIfGp_getOxygenCount();
+DUSK_NOINLINE void dComIfGp_setOxygenCount(s32 oxygen);
+DUSK_NOINLINE void dComIfGp_clearOxygenCount();
+DUSK_NOINLINE void dComIfGp_setMaxOxygenCount(s32 oxygen);
+DUSK_NOINLINE s32 dComIfGp_getMaxOxygenCount();
+DUSK_NOINLINE void dComIfGp_clearMaxOxygenCount();
+DUSK_NOINLINE s16 dComIfGp_getItemArrowNumCount();
+DUSK_NOINLINE void dComIfGp_setItemArrowNumCount(s16 count);
+DUSK_NOINLINE void dComIfGp_clearItemArrowNumCount();
+DUSK_NOINLINE s16 dComIfGp_getItemPachinkoNumCount();
+DUSK_NOINLINE void dComIfGp_setItemPachinkoNumCount(s16 count);
+DUSK_NOINLINE void dComIfGp_clearItemPachinkoNumCount();
+DUSK_NOINLINE s16 dComIfGp_getItemMaxArrowNumCount();
+DUSK_NOINLINE int dComIfGp_getMessageCountNumber();
+DUSK_NOINLINE void dComIfGp_setMessageCountNumber(s32 number);
+DUSK_NOINLINE u16 dComIfGp_getItemNowLife();
+DUSK_NOINLINE void dComIfGp_setItemNowLife(u16 life);
+DUSK_NOINLINE u8 dComIfGp_getMesgStatus();
+DUSK_NOINLINE u8 dComIfGp_getRStatus();
+DUSK_NOINLINE bool dComIfGp_isRSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setRStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getRStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getRSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setRStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getAStatus();
+DUSK_NOINLINE bool dComIfGp_isASetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setAStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getAStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getASetFlagForce();
+DUSK_NOINLINE void dComIfGp_setAStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getNunStatus();
+DUSK_NOINLINE bool dComIfGp_isNunSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setNunStatus(u8 status, u8 param_1, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getBottleStatus();
+DUSK_NOINLINE bool dComIfGp_isBottleSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setBottleStatus(u8 param_0, u8 param_1);
+DUSK_NOINLINE u8 dComIfGp_getBottleStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getBottleSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setBottleStatusForce(u8 param_0, u8 param_1);
+DUSK_NOINLINE u8 dComIfGp_getRemoConStatus();
+DUSK_NOINLINE bool dComIfGp_isRemoConSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setRemoConStatus(u8 status, u8 param_1, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getDoStatus();
+DUSK_NOINLINE bool dComIfGp_isDoSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setDoStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getDoStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getDoSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setDoStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_get3DStatus();
+DUSK_NOINLINE u8 dComIfGp_get3DDirection();
+DUSK_NOINLINE bool dComIfGp_is3DSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_set3DStatus(u8 status, u8 direction, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_get3DStatusForce();
+DUSK_NOINLINE u8 dComIfGp_get3DDirectionForce();
+DUSK_NOINLINE u8 dComIfGp_get3DSetFlagForce();
+DUSK_NOINLINE void dComIfGp_set3DStatusForce(u8 status, u8 direction, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getCStickStatus();
+DUSK_NOINLINE u8 dComIfGp_getCStickDirection();
+DUSK_NOINLINE bool dComIfGp_isCStickSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setCStickStatus(u8 status, u8 param_1, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getCStickStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getCStickDirectionForce();
+DUSK_NOINLINE u8 dComIfGp_getCStickSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setCStickStatusForce(u8 status, u8 param_1, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getSButtonStatus();
+DUSK_NOINLINE bool dComIfGp_isSButtonSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setSButtonStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getSButtonStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getSButtonSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setSButtonStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getZStatus();
+DUSK_NOINLINE bool dComIfGp_isZSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setZStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getZStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getZSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setZStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getXStatus();
+DUSK_NOINLINE bool dComIfGp_isXSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setXStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getXStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getXSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setXStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getYStatus();
+DUSK_NOINLINE bool dComIfGp_isYSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setYStatus(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getYStatusForce();
+DUSK_NOINLINE u8 dComIfGp_getYSetFlagForce();
+DUSK_NOINLINE void dComIfGp_setYStatusForce(u8 status, u8 flag);
+DUSK_NOINLINE u8 dComIfGp_getNunZStatus();
+DUSK_NOINLINE bool dComIfGp_isNunZSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setNunZStatus(u8 param_0, u8 param_1);
+DUSK_NOINLINE u8 dComIfGp_getNunCStatus();
+DUSK_NOINLINE bool dComIfGp_isNunCSetFlag(u8 flag);
+DUSK_NOINLINE void dComIfGp_setNunCStatus(u8 param_0, u8 param_1);
+DUSK_NOINLINE void dComIfGp_setSelectEquipClothes(u8 i_clothNo);
+DUSK_NOINLINE void dComIfGp_setSelectEquipSword(u8 i_swordNo);
+DUSK_NOINLINE void dComIfGp_setSelectEquipShield(u8 i_shieldNo);
+DUSK_NOINLINE u8 dComIfGp_getMesgAnimeAttrInfo();
+DUSK_NOINLINE void dComIfGp_setMesgAnimeAttrInfo(u8 param_1);
+DUSK_NOINLINE void dComIfGp_clearMesgAnimeAttrInfo();
+DUSK_NOINLINE u8 dComIfGp_getMesgFaceAnimeAttrInfo();
+DUSK_NOINLINE void dComIfGp_setMesgFaceAnimeAttrInfo(u8 id);
+DUSK_NOINLINE void dComIfGp_clearMesgFaceAnimeAttrInfo();
+DUSK_NOINLINE void dComIfGp_clearMesgAnimeTagInfo();
+DUSK_NOINLINE void dComIfGp_setItem(u8 slot, u8 i_no);
+DUSK_NOINLINE u8 dComIfGp_getAdvanceDirection();
+DUSK_NOINLINE void dComIfGp_setAdvanceDirection(u8 i_dir);
+DUSK_NOINLINE u8 dComIfGp_checkMesgCancelButton();
+DUSK_NOINLINE void dComIfGp_setMesgCancelButton(u8 button);
+DUSK_NOINLINE u8 dComIfGp_getGameoverStatus();
+DUSK_NOINLINE void dComIfGp_setGameoverStatus(u8 i_status);
+DUSK_NOINLINE u8 dComIfGp_isHeapLockFlag();
+DUSK_NOINLINE u8 dComIfGp_getSubHeapLockFlag(int idx);
+DUSK_NOINLINE void dComIfGp_setSubHeapLockFlag(int idx, u8 status);
+DUSK_NOINLINE u8 dComIfGp_getNeedLightDropNum();
+DUSK_NOINLINE void dComIfGp_setNeedLightDropNum(u8 i_num);
+DUSK_NOINLINE u8 dComIfGp_checkMesgBgm();
+DUSK_NOINLINE void dComIfGp_setMesgBgmOff();
+DUSK_NOINLINE void dComIfGp_setMesgBgmOn();
+DUSK_NOINLINE u8 dComIfGp_isPauseFlag();
+DUSK_NOINLINE void dComIfGp_offPauseFlag();
+DUSK_NOINLINE void dComIfGp_onPauseFlag();
+DUSK_NOINLINE u8 dComIfGp_getOxygenShowFlag();
+DUSK_NOINLINE void dComIfGp_offOxygenShowFlag();
+DUSK_NOINLINE void dComIfGp_onOxygenShowFlag();
+DUSK_NOINLINE u8 dComIfGp_2dShowCheck();
+DUSK_NOINLINE void dComIfGp_2dShowOn();
+DUSK_NOINLINE void dComIfGp_2dShowOff();
+DUSK_NOINLINE JKRExpHeap* dComIfGp_getExpHeap2D();
+DUSK_NOINLINE void dComIfGp_setExpHeap2D(void* heap);
+DUSK_NOINLINE JKRExpHeap* dComIfGp_getSubExpHeap2D(int idx);
+DUSK_NOINLINE void dComIfGp_setSubExpHeap2D(int idx, void* heap);
+DUSK_NOINLINE JKRExpHeap* dComIfGp_getMsgExpHeap();
+DUSK_NOINLINE void dComIfGp_setMsgExpHeap(void* heap);
+DUSK_NOINLINE dComIfG_MesgCamInfo_c* dComIfGp_getMesgCameraInfo();
+DUSK_NOINLINE void dComIfGp_setMesgCameraTagInfo(int id);
+DUSK_NOINLINE void dComIfGp_clearMesgCameraTagInfo();
+DUSK_NOINLINE void dComIfGp_setMesgCameraAttrInfo(int param_1);
+DUSK_NOINLINE void dComIfGp_clearMesgCameraAttrInfo();
+DUSK_NOINLINE void dComIfGp_setMesgCameraInfoActor(fopAc_ac_c* param_1, fopAc_ac_c* param_2,
+    fopAc_ac_c* param_3, fopAc_ac_c* param_4, fopAc_ac_c* param_5, fopAc_ac_c* param_6,
+    fopAc_ac_c* param_7, fopAc_ac_c* param_8, fopAc_ac_c* param_9, fopAc_ac_c* param_10);
+DUSK_NOINLINE u32 dComIfGp_checkPlayerStatus0(int param_0, u32 flag);
+DUSK_NOINLINE u32 dComIfGp_checkPlayerStatus1(int param_0, u32 flag);
+DUSK_NOINLINE void dComIfGp_setPlayerStatus0(int param_0, u32 flag);
+DUSK_NOINLINE void dComIfGp_setPlayerStatus1(int param_0, u32 flag);
+DUSK_NOINLINE void dComIfGp_clearPlayerStatus0(int param_0, u32 flag);
+DUSK_NOINLINE void dComIfGp_clearPlayerStatus1(int param_0, u32 flag);
+DUSK_NOINLINE void dComIfGp_setCurrentWindow(dDlst_window_c* i_window);
+DUSK_NOINLINE void dComIfGp_setCurrentView(view_class* i_view);
+DUSK_NOINLINE void dComIfGp_setCurrentViewport(view_port_class* i_viewport);
+DUSK_NOINLINE J2DGrafContext* dComIfGp_getCurrentGrafPort();
+DUSK_NOINLINE void dComIfGp_setCurrentGrafPort(J2DOrthoGraph* i_graf);
+DUSK_NOINLINE void* dComIfGp_getItemTable();
+DUSK_NOINLINE void dComIfGp_setItemTable(void* data);
+DUSK_NOINLINE char* dComIfGp_getLastPlayStageName();
+DUSK_NOINLINE void dComIfGp_setLastPlayStageName(char* name);
+DUSK_NOINLINE void dComIfGp_init();
+DUSK_NOINLINE void dComIfGp_itemDataInit();
+DUSK_NOINLINE void dComIfGp_setItemBombNumCount(u8 i_item, s16 count);
+DUSK_NOINLINE s16 dComIfGp_getItemBombNumCount(u8 i_no);
+DUSK_NOINLINE void dComIfGp_clearItemBombNumCount(u8 i_no);
+DUSK_NOINLINE s16 dComIfGp_getItemMaxBombNumCount();
+DUSK_NOINLINE void dComIfGp_setNowVibration(u8 status);
+DUSK_NOINLINE u32 dComIfGp_getNowVibration();
+DUSK_NOINLINE void dComIfGp_particle_create();
+DUSK_NOINLINE void dComIfGp_createSimpleModel();
+DUSK_NOINLINE void dComIfGp_deleteSimpleModel();
+DUSK_NOINLINE void dComIfGp_drawSimpleModel();
+DUSK_NOINLINE int dComIfGp_addSimpleModel(J3DModelData* i_modelData, int roomNo, u8 i_drawBG);
+DUSK_NOINLINE void dComIfGp_removeSimpleModel(J3DModelData* i_modelData, int roomNo);
+DUSK_NOINLINE void dComIfGp_entrySimpleModel(J3DModel* model, int roomNo);
+DUSK_NOINLINE void dComIfG_ct();
+DUSK_NOINLINE dBgS& dComIfG_Bgsp();
+DUSK_NOINLINE dCcS* dComIfG_Ccsp();
+DUSK_NOINLINE dCcS& dComIfG_Ccsp2();
+DUSK_NOINLINE void dComIfG_setTimerNowTimeMs(int time);
+DUSK_NOINLINE int dComIfG_getTimerNowTimeMs();
+DUSK_NOINLINE void dComIfG_setTimerLimitTimeMs(int i_time);
+DUSK_NOINLINE int dComIfG_getTimerLimitTimeMs();
+DUSK_NOINLINE void dComIfG_setTimerMode(int mode);
+DUSK_NOINLINE int dComIfG_getTimerMode();
+DUSK_NOINLINE void dComIfG_setTimerType(u8 i_type);
+DUSK_NOINLINE u8 dComIfG_getTimerType();
+DUSK_NOINLINE void dComIfG_setTimerPtr(dTimer_c* i_ptr);
+DUSK_NOINLINE dTimer_c* dComIfG_getTimerPtr();
+
+/**
+ * Attempts to add a new Object Resource Archive (*.arc) into the Resource Control.
+ * @param i_arcName Name of archive to be added
+ * @param i_mountDirection The direction to mount the archive. mDoDvd_MOUNT_DIRECTION_HEAD or
+ * mDoDvd_MOUNT_DIRECTION_TAIL
+ * @param i_heap Pointer to heap to load resources into
+ * @return TRUE if successful, FALSE otherwise
+ */
+DUSK_NOINLINE int dComIfG_setObjectRes(const char* i_arcName, u8 i_mountDirection, JKRHeap* i_heap);
+DUSK_NOINLINE int dComIfG_setObjectRes(
+    const char* i_arcName, void* i_archiveRes, u32 i_bufferSize, JKRHeap* i_heap);
+
+/**
+ * Attempts to add a new Stage Resource Archive (*.arc) into the Resource Control.
+ * @param i_arcName Name of archive to be added
+ * @param i_heap Pointer to heap to load resources into
+ * @return TRUE if successful, FALSE otherwise
+ */
+DUSK_NOINLINE int dComIfG_setStageRes(const char* i_arcName, JKRHeap* i_heap);
+DUSK_NOINLINE int dComIfG_syncObjectRes(const char* i_arcName);
+DUSK_NOINLINE int dComIfG_syncStageRes(const char* i_arcName);
+DUSK_NOINLINE int dComIfG_deleteObjectResMain(const char* i_arcName);
+DUSK_NOINLINE int dComIfG_deleteStageRes(const char* i_arcName);
+DUSK_NOINLINE void* dComIfG_getStageRes(const char* i_arcName, const char* i_resName);
+DUSK_NOINLINE void* dComIfG_getObjectRes(const char* i_arcName, const char* i_resName);
+DUSK_NOINLINE void* dComIfG_getObjectRes(const char* i_arcName, int i_index);
+DUSK_NOINLINE void dComIfG_dumpResControl();
+DUSK_NOINLINE dRes_info_c* dComIfG_getObjectResInfo(const char* i_arcName);
+DUSK_NOINLINE dRes_info_c* dComIfG_getStageResInfo(const char* i_arcName);
+DUSK_NOINLINE int dComIfG_syncAllObjectRes();
+DUSK_NOINLINE void* dComIfG_getObjectIDRes(const char* i_arcName, u16 i_resID);
+DUSK_NOINLINE int dComIfG_getObjctResName2Index(const char* i_arcName, const char* i_resName);
+DUSK_NOINLINE u8 dComIfG_getBrightness();
+DUSK_NOINLINE void dComIfG_setBrightness(u8 brightness);
+DUSK_NOINLINE BOOL dComIfG_isDebugMode();
+DUSK_NOINLINE u32 dComIfG_getTrigB(u32 i_padNo);
+#if DEBUG
+DUSK_NOINLINE u32 dComIfG_getObjectAllSize();
+DUSK_NOINLINE u32 dComIfG_getStageAllSize();
+DUSK_NOINLINE u32 dComIfG_getObjectSize(const char* i_arcName);
+DUSK_NOINLINE u32 dComIfG_getStageSize(const char* i_arcName);
+DUSK_NOINLINE void dComIfG_initStopwatch();
+#endif
+
+DUSK_NOINLINE int dComIfGd_setRealShadow(u32 param_0, s8 param_1, J3DModel* param_2, cXyz* param_3,
+    f32 param_4, f32 param_5, dKy_tevstr_c* param_6);
+DUSK_NOINLINE int dComIfGd_setSimpleShadow(
+    cXyz* pos, f32 param_1, f32 param_2, cXyz* param_3, s16 angle, f32 param_5, TGXTexObj* tex);
+DUSK_NOINLINE bool dComIfGd_addRealShadow(u32 key, J3DModel* model);
+DUSK_NOINLINE void dComIfGd_drawListItem3d();
+
+#if VERSION > VERSION_GCN_JPN
+DUSK_NOINLINE void dComIfGd_drawListCursor();
+#endif
+
+DUSK_NOINLINE void dComIfGd_reset();
+DUSK_NOINLINE void dComIfGd_set2DOpa(dDlst_base_c* dlst);
+DUSK_NOINLINE void dComIfGd_set2DXlu(dDlst_base_c* dlst);
+DUSK_NOINLINE void dComIfGd_set2DOpaTop(dDlst_base_c* dlst);
+DUSK_NOINLINE void dComIfGd_setCopy2D(dDlst_base_c* dlst);
+DUSK_NOINLINE view_class* dComIfGd_getView();
+DUSK_NOINLINE Mtx44* dComIfGd_getProjViewMtx();
+DUSK_NOINLINE MtxP dComIfGd_getInvViewMtx();
+DUSK_NOINLINE view_port_class* dComIfGd_getViewport();
+DUSK_NOINLINE MtxP dComIfGd_getViewRotMtx();
+DUSK_NOINLINE MtxP dComIfGd_getViewMtx();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getListFilter();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getOpaListIndScreen();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getListPacket();
+DUSK_NOINLINE void dComIfGd_setListSky();
+DUSK_NOINLINE void dComIfGd_setListDark();
+DUSK_NOINLINE void dComIfGd_setListInvisisble();
+DUSK_NOINLINE void dComIfGd_setListDarkBG();
+DUSK_NOINLINE void dComIfGd_setXluListDarkBG();
+DUSK_NOINLINE void dComIfGd_setList();
+DUSK_NOINLINE void dComIfGd_setListItem3D();
+DUSK_NOINLINE void dComIfGd_setList3Dlast();
+DUSK_NOINLINE void dComIfGd_setXluList2DScreen();
+DUSK_NOINLINE void dComIfGd_setXluListBG();
+DUSK_NOINLINE void dComIfGd_setListBG();
+DUSK_NOINLINE void dComIfGd_setListIndScreen();
+DUSK_NOINLINE void dComIfGd_setListMiddle();
+DUSK_NOINLINE void dComIfGd_setListZxlu();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getOpaList();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getOpaListBG();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getOpaListDark();
+DUSK_NOINLINE J3DDrawBuffer* dComIfGd_getXluListBG();
+DUSK_NOINLINE void dComIfGd_setListFilter();
+DUSK_NOINLINE void dComIfGd_init();
+DUSK_NOINLINE void dComIfGd_peekZ(s16 param_0, s16 param_1, u32* param_2);
+DUSK_NOINLINE void dComIfGd_peekZdata();
+DUSK_NOINLINE void dComIfGd_setView(view_class* view);
+DUSK_NOINLINE void dComIfGd_setWindow(dDlst_window_c* window);
+DUSK_NOINLINE void dComIfGd_setViewport(view_port_class* port);
+DUSK_NOINLINE void dComIfGd_entryZSortListZxlu(J3DPacket* i_packet, cXyz& param_1);
+DUSK_NOINLINE void dComIfGd_entryZSortXluList(J3DPacket* i_packet, cXyz& param_1);
+DUSK_NOINLINE void dComIfGd_drawCopy2D();
+DUSK_NOINLINE void dComIfGd_drawOpaListSky();
+DUSK_NOINLINE void dComIfGd_drawXluListSky();
+DUSK_NOINLINE void dComIfGd_drawOpaListBG();
+DUSK_NOINLINE void dComIfGd_drawOpaListDarkBG();
+DUSK_NOINLINE void dComIfGd_drawOpaListMiddle();
+DUSK_NOINLINE void dComIfGd_drawOpaList();
+DUSK_NOINLINE void dComIfGd_drawOpaListDark();
+DUSK_NOINLINE void dComIfGd_drawOpaListPacket();
+DUSK_NOINLINE void dComIfGd_drawXluListBG();
+DUSK_NOINLINE void dComIfGd_drawXluListDarkBG();
+DUSK_NOINLINE void dComIfGd_drawXluList();
+DUSK_NOINLINE void dComIfGd_drawXluListDark();
+DUSK_NOINLINE void dComIfGd_drawXluListInvisible();
+DUSK_NOINLINE void dComIfGd_drawOpaListInvisible();
+DUSK_NOINLINE void dComIfGd_drawXluListZxlu();
+DUSK_NOINLINE void dComIfGd_drawXluList2DScreen();
+DUSK_NOINLINE void dComIfGd_drawOpaList3Dlast();
+DUSK_NOINLINE void dComIfGd_draw2DOpa();
+DUSK_NOINLINE void dComIfGd_draw2DOpaTop();
+DUSK_NOINLINE void dComIfGd_draw2DXlu();
+DUSK_NOINLINE void dComIfGd_drawOpaListFilter();
+DUSK_NOINLINE void dComIfGd_drawIndScreen();
+DUSK_NOINLINE void dComIfGd_drawListZxlu();
+DUSK_NOINLINE void dComIfGd_drawShadow(Mtx param_0);
+DUSK_NOINLINE void dComIfGd_imageDrawShadow(Mtx param_0);
+DUSK_NOINLINE void dComIfGd_set3DlineMat(mDoExt_3DlineMat_c* param_0);
+DUSK_NOINLINE void dComIfGd_set3DlineMatDark(mDoExt_3DlineMat_c* param_0);
+
+#if PLATFORM_WII || VERSION == VERSION_SHIELD_DEBUG
+DUSK_NOINLINE void dComIfGd_setListCursor();
+#endif
+
+#else
 inline dSv_info_c* dComIfGs_getSaveInfo() {
     return &g_dComIfG_gameInfo.info;
 }
@@ -1432,11 +2366,7 @@ inline BOOL dComIfGs_isTransformLV(int i_no) {
     return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().isTransformLV(i_no);
 }
 
-#if TARGET_PC
-inline cXyz dComIfGs_getHorseRestartPos() {
-#else
 inline cXyz& dComIfGs_getHorseRestartPos() {
-#endif
     return g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().getPos();
 }
 
@@ -1457,11 +2387,7 @@ inline void dComIfGs_setHorseRestart(const char* i_stageName, cXyz& i_pos, s16 i
     g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().set(i_stageName, i_pos, i_angle, i_roomNo);
 }
 
-#if TARGET_PC
-inline cXyz dComIfGs_getPlayerFieldLastStayPos() {
-#else
 inline cXyz& dComIfGs_getPlayerFieldLastStayPos() {
-#endif
     return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().getPos();
 }
 
@@ -1503,11 +2429,7 @@ inline void dComIfGs_setPlayerFieldLastStayInfo(const char* i_stage, cXyz& i_pos
                                                                          i_point, i_region);
 }
 
-#if TARGET_PC
-inline cXyz dComIfGs_getLastWarpMarkPlayerPos() {
-#else
 inline cXyz& dComIfGs_getLastWarpMarkPlayerPos() {
-#endif
     return g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().getPos();
 }
 
@@ -1845,12 +2767,6 @@ inline void dComIfGs_addDeathCount() {
     g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().addDeathCount();
 }
 
-#if TARGET_PC
-inline u16 dComIfGs_getDeathCount() {
-    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getDeathCount();
-}
-#endif
-
 inline TEXT_SPAN dComIfGs_getPlayerName() {
     return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getPlayerName();
 }
@@ -3117,133 +4033,114 @@ inline void dComIfGp_particle_calcMenu() {
 }
 
 inline void dComIfGp_particle_draw(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawNormal(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFog(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawNormalFog(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawP1(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawNormalP1(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawProjection(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawProjection(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawNormalPri0_A(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawNormalPri0_A(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawNormalPri0_B(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawNormalPri0_B(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFogPri0_A(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogPri0_A(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFogPri0_B(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogPri0_B(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFogPri1(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogPri1(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFogPri2(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogPri2(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFogPri3(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogPri3(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawFogPri4(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogPri4(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawDarkworld(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawDarkworld(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_drawScreen(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->drawFogScreen(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_draw2Dgame(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->draw2Dgame(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_draw2Dfore(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->draw2Dfore(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_draw2Dback(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->draw2Dback(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_draw2DmenuFore(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->draw2DmenuFore(i_drawInfo);
     }
 }
 
 inline void dComIfGp_particle_draw2DmenuBack(JPADrawInfo* i_drawInfo) {
-    ZoneScoped;
     if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
         g_dComIfG_gameInfo.play.getParticle()->draw2DmenuBack(i_drawInfo);
     }
@@ -4763,154 +5660,114 @@ inline void dComIfGd_setViewport(view_port_class* port) {
 }
 
 inline void dComIfGd_entryZSortListZxlu(J3DPacket* i_packet, cXyz& param_1) {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.entryZSortListZxlu(i_packet, param_1);
 }
 
 inline void dComIfGd_entryZSortXluList(J3DPacket* i_packet, cXyz& param_1) {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.entryZSortXluList(i_packet, param_1);
 }
 
 inline void dComIfGd_drawCopy2D() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawCopy2D();
 }
 
 inline void dComIfGd_drawOpaListSky() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListSky();
 }
 
 inline void dComIfGd_drawXluListSky() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluListSky();
 }
 
 inline void dComIfGd_drawOpaListBG() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListBG();
 }
 
 inline void dComIfGd_drawOpaListDarkBG() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListDarkBG();
 }
 
 inline void dComIfGd_drawOpaListMiddle() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListMiddle();
 }
 
 inline void dComIfGd_drawOpaList() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaList();
 }
 
 inline void dComIfGd_drawOpaListDark() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListDark();
 }
 
 inline void dComIfGd_drawOpaListPacket() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListPacket();
 }
 
 inline void dComIfGd_drawXluListBG() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluListBG();
 }
 
 inline void dComIfGd_drawXluListDarkBG() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluListDarkBG();
 }
 
 inline void dComIfGd_drawXluList() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluList();
 }
 
 inline void dComIfGd_drawXluListDark() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluListDark();
 }
 
 inline void dComIfGd_drawXluListInvisible() {
-    ZoneScoped;
-#ifdef TARGET_PC
-    if (!dusk::getSettings().game.disableWaterRefraction) {
-#endif
-        g_dComIfG_gameInfo.drawlist.drawXluListInvisible();
-#ifdef TARGET_PC
-    }
-#endif
+    g_dComIfG_gameInfo.drawlist.drawXluListInvisible();
 }
 
 inline void dComIfGd_drawOpaListInvisible() {
-    ZoneScoped;
-#ifdef TARGET_PC
-    if (!dusk::getSettings().game.disableWaterRefraction) {
-#endif
-        g_dComIfG_gameInfo.drawlist.drawOpaListInvisible();
-#ifdef TARGET_PC
-        }
-#endif
+    g_dComIfG_gameInfo.drawlist.drawOpaListInvisible();
 }
 
 inline void dComIfGd_drawXluListZxlu() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluListZxlu();
 }
 
 inline void dComIfGd_drawXluList2DScreen() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluList2DScreen();
 }
 
 inline void dComIfGd_drawOpaList3Dlast() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaList3Dlast();
 }
 
 inline void dComIfGd_draw2DOpa() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.draw2DOpa();
 }
 
 inline void dComIfGd_draw2DOpaTop() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.draw2DOpaTop();
 }
 
 inline void dComIfGd_draw2DXlu() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.draw2DXlu();
 }
 
 inline void dComIfGd_drawOpaListFilter() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListFilter();
 }
 
 inline void dComIfGd_drawIndScreen() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawOpaListP0();
 }
 
 inline void dComIfGd_drawListZxlu() {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawXluListZxlu();
 }
 
 inline void dComIfGd_drawShadow(Mtx param_0) {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.drawShadow(param_0);
 }
 
 inline void dComIfGd_imageDrawShadow(Mtx param_0) {
-    ZoneScoped;
     g_dComIfG_gameInfo.drawlist.imageDrawShadow(param_0);
 }
 
@@ -4929,4 +5786,6 @@ inline void dComIfGd_setListCursor() {
 }
 #endif
 
+#endif
+
 #endif /* D_COM_D_COM_INF_GAME_H */
diff --git a/include/d/d_cursor_mng.h b/include/d/d_cursor_mng.h
index 38ba03f214..9837e6f1cb 100644
--- a/include/d/d_cursor_mng.h
+++ b/include/d/d_cursor_mng.h
@@ -95,7 +95,7 @@ class dCsr_mng_c {
         BOOL set(mDoGph_gInf_c::csr_c* i_csr, u16, u8, u8);
     };
 
-private:
+public:
     dCsr_mng_c() : is_csr_on(true) {
     }
 
@@ -116,7 +116,6 @@ public:
 
     static dCsr_mng_c* m_myObj;
 
-private:
     /* 0x00 */ list_c m_csr_list;
     /* 0x08 */ list_c m_obj_list;
     /* 0x10 */ bool is_csr_on;
diff --git a/include/d/d_debug_pad.h b/include/d/d_debug_pad.h
index 4c5658adf4..b68e8f8b9b 100644
--- a/include/d/d_debug_pad.h
+++ b/include/d/d_debug_pad.h
@@ -29,6 +29,6 @@ public:
     /* 0x4 */ s32 mMode;
 };
 
-extern dDebugPad_c dDebugPad;
+DUSK_GAME_EXTERN dDebugPad_c dDebugPad;
 
 #endif
diff --git a/include/d/d_demo.h b/include/d/d_demo.h
index e72698ed9a..a35c44e0ed 100644
--- a/include/d/d_demo.h
+++ b/include/d/d_demo.h
@@ -155,7 +155,6 @@ public:
     f32 getAnmTransition() { return mAnmTransition; }
     u32 getShapeId() { return mShape; }
 
-private:
     /* 0x04 */ u16 mFlags;
     /* 0x08 */ cXyz mTrans;
     /* 0x14 */ cXyz mScale;
@@ -220,7 +219,6 @@ public:
     f32 getFovy() { return mProjFovy; }
     f32 getRoll() { return mViewRoll; }
 
-private:
     /* 0x04 */ u8 mFlags;
     /* 0x08 */ f32 mProjNear;
     /* 0x0C */ f32 mProjFar;
@@ -247,7 +245,6 @@ public:
 
     void onEnable(u8 flag) { mFlags |= flag; }
 
-private:
     /* 0x04 */ u8 mFlags;
     /* 0x05 */ GXColor mColor;
 };
@@ -275,7 +272,6 @@ public:
 
     void onEnable(u8 flag) { mFlags |= flag; }
 
-private:
     /* 0x04 */ u8 mFlags;
     /* 0x08 */ JStage::TELight mLightType;
     /* 0x0C */ GXDistAttnFn mDistAttenFn;
@@ -309,7 +305,6 @@ public:
 
     void onEnable(u8 flag) { mFlags |= flag; }
 
-private:
     /* 0x04 */ u8 mFlags;
     /* 0x05 */ s8 mFogType;
     /* 0x08 */ f32 mStartZ;
@@ -327,7 +322,6 @@ public:
 
     void setObject(dDemo_object_c* i_object) { mpObject = i_object; }
 
-private:
     /* 0x4 */ dDemo_object_c* mpObject;
 };
 
@@ -381,26 +375,26 @@ public:
         return m_object->getActiveCamera();
     }
 
-    static s16 m_branchId;
+    static DUSK_GAME_DATA s16 m_branchId;
     static u16 m_branchNum;
-    static dDemo_system_c* m_system;
-    static JStudio::TControl* m_control;
-    static JStudio_JStage::TCreateObject* m_stage;
-    static JStudio_JAudio2::TCreateObject* m_audio;
-    static dDemo_particle_c* m_particle;
-    static JStudio::TCreateObject* m_message;
-    static JStudio::TFactory* m_factory;
-    static jmessage_tControl* m_mesgControl;
-    static dDemo_object_c* m_object;
-    static const u8* m_data;
-    static int m_frame;
-    static cXyz* m_translation;
-    static f32 m_rotationY;
-    static u32 m_frameNoMsg;
-    static s32 m_mode;
-    static u32 m_status;
-    static u16 m_branchType;
-    static const u8* m_branchData;
+    static DUSK_GAME_DATA dDemo_system_c* m_system;
+    static DUSK_GAME_DATA JStudio::TControl* m_control;
+    static DUSK_GAME_DATA JStudio_JStage::TCreateObject* m_stage;
+    static DUSK_GAME_DATA JStudio_JAudio2::TCreateObject* m_audio;
+    static DUSK_GAME_DATA dDemo_particle_c* m_particle;
+    static DUSK_GAME_DATA JStudio::TCreateObject* m_message;
+    static DUSK_GAME_DATA JStudio::TFactory* m_factory;
+    static DUSK_GAME_DATA jmessage_tControl* m_mesgControl;
+    static DUSK_GAME_DATA dDemo_object_c* m_object;
+    static DUSK_GAME_DATA const u8* m_data;
+    static DUSK_GAME_DATA int m_frame;
+    static DUSK_GAME_DATA cXyz* m_translation;
+    static DUSK_GAME_DATA f32 m_rotationY;
+    static DUSK_GAME_DATA u32 m_frameNoMsg;
+    static DUSK_GAME_DATA s32 m_mode;
+    static DUSK_GAME_DATA u32 m_status;
+    static DUSK_GAME_DATA u16 m_branchType;
+    static DUSK_GAME_DATA const u8* m_branchData;
 };
 
 #endif /* D_D_DEMO_H */
diff --git a/include/d/d_drawlist.h b/include/d/d_drawlist.h
index 8368c9e92e..4baf6ed324 100644
--- a/include/d/d_drawlist.h
+++ b/include/d/d_drawlist.h
@@ -5,10 +5,13 @@
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include "SSystem/SComponent/c_m3d_g_pla.h"
-#include "dusk/gx_helper.h"
 #include "f_op/f_op_view.h"
-#include "global.h"
 #include "m_Do/m_Do_ext.h"
+#include "global.h"
+
+#if TARGET_PC
+#include "helpers/gx_helper.h"
+#endif
 
 class J3DDrawBuffer;
 class J3DModel;
@@ -107,7 +110,6 @@ public:
         mRnd.init(r0, r1, r2);
     }
 
-private:
     /* 0x04 */ cM_rnd_c mRnd;
     /* 0x10 */ cXyz field_0x10;
     /* 0x1C */ GXColor mLineColor;
@@ -129,7 +131,6 @@ public:
     void setAlpha(u8 alpha) { mAlpha = alpha; }
     J2DPicture* getPicture() { return &mpPicture; }
 
-private:
     /* 0x004 */ u8 field_0x4;
     /* 0x008 */ J2DPicture mpPicture;
     /* 0x158 */ s16 mPosX;
@@ -271,7 +272,6 @@ public:
     void setZsortNext(dDlst_shadowReal_c* next) { mZsortNext = next; }
     void setZsortPre(dDlst_shadowReal_c* pre) { mZsortPre = pre; }
 
-private:
     /* 0x0000 */ u8 mState;
     /* 0x0001 */ u8 field_0x1;
     /* 0x0002 */ u8 mModelNum;
@@ -301,9 +301,8 @@ public:
 
     static TGXTexObj* getSimpleTex() { return &mSimpleTexObj; }
 
-    static TGXTexObj mSimpleTexObj;
+    static DUSK_GAME_DATA TGXTexObj mSimpleTexObj;
 
-private:
     /* 0x00000 */ u8 field_0x0;
     /* 0x00001 */ u8 mRealNum;
     /* 0x00002 */ u8 mSimpleNum;
@@ -332,7 +331,6 @@ public:
     view_port_class* getViewPort() { return &mViewport; }
     scissor_class* getScissor() { return &mViewport.scissor; }
 
-private:
     /* 0x00 */ view_port_class mViewport;
     /* 0x28 */ s8 mCameraID;
     /* 0x29 */ u8 mMode;
@@ -443,7 +441,7 @@ public:
     }
 
 #if TARGET_PC
-    void refresh3DlineMats(const cXyz& eye);
+    void refresh3DlineMats();
 #endif
 
     void peekZdata() { mPeekZ.peekData(); }
@@ -512,13 +510,12 @@ public:
     static void offWipe() { mWipe = 0; }
     static f32 getWipeRate() { return mWipeRate; }
 
-    static dDlst_2DT2_c mWipeDlst;
-    static GXColor mWipeColor;
-    static f32 mWipeRate;
-    static f32 mWipeSpeed;
-    static u8 mWipe;
+    static DUSK_GAME_DATA dDlst_2DT2_c mWipeDlst;
+    static DUSK_GAME_DATA GXColor mWipeColor;
+    static DUSK_GAME_DATA f32 mWipeRate;
+    static DUSK_GAME_DATA f32 mWipeSpeed;
+    static DUSK_GAME_DATA u8 mWipe;
 
-private:
     /* 0x00000 */ J3DDrawBuffer* mDrawBuffers[DB_LIST_MAX];
     /* 0x00054 */ dDlst_base_c* mpCopy2DDrawLists[4];
     /* 0x00064 */ dDlst_base_c** mpCopy2DStart;
diff --git a/include/d/d_event_data.h b/include/d/d_event_data.h
index ee9b868af4..786088250f 100644
--- a/include/d/d_event_data.h
+++ b/include/d/d_event_data.h
@@ -3,7 +3,10 @@
 
 #include "global.h"
 #include "f_pc/f_pc_base.h"
-#include "dusk/endian.h"
+
+#if TARGET_PC
+#include "helpers/endian.h"
+#endif
 
 struct msg_class;
 
@@ -190,7 +193,6 @@ public:
     int getCurrentCut() { return mCurrentCut; }
     int getStartCut() { return mStartCut; }
 
-    // private:
     /* 0x00 */ char mName[8];
     /* 0x08 */ u8 mWork[0x18]; // PROBLEM: this buffer is now too small for StaffWork to fit in
     /* 0x20 */ BE(s32) mTagID;
@@ -293,7 +295,6 @@ public:
 
     static const int FlagMax = 0x2800;
 
-private:
     u32 mFlags[320];
 };  // Size = 0x500
 
@@ -346,7 +347,6 @@ public:
     void setIDataP(int* p_idata) { mIDataP = p_idata; }
     void setSDataP(char* p_sdata) { mSDataP = p_sdata; }
 
-    // private:
     /* 0x00 */ event_binary_data_header* mHeaderP;
     /* 0x04 */ dEvDtEvent_c* mEventP;
     /* 0x08 */ dEvDtStaff_c* mStaffP;
diff --git a/include/d/d_event_manager.h b/include/d/d_event_manager.h
index de046797ff..75aa5a4a03 100644
--- a/include/d/d_event_manager.h
+++ b/include/d/d_event_manager.h
@@ -112,7 +112,6 @@ public:
     dEvM_HIO_c& getEventHIO();
     #endif
 
-private:
     /* 0x000 */ dEvDtBase_c mEventList[BASE_MAX];
     /* 0x18C */ int mCameraPlay;
     /* 0x190 */ dEvent_exception_c mException;
diff --git a/include/d/d_eye_hl.h b/include/d/d_eye_hl.h
index e7a4d82d3c..23f93cf83d 100644
--- a/include/d/d_eye_hl.h
+++ b/include/d/d_eye_hl.h
@@ -17,7 +17,7 @@ public:
         JUT_ASSERT(51, m_obj == NULL);
     }
 
-    static dEyeHL_c* m_obj;
+    static DUSK_GAME_DATA dEyeHL_c* m_obj;
 };
 
 class dEyeHL_c {
diff --git a/include/d/d_file_sel_info.h b/include/d/d_file_sel_info.h
index 973349c469..89c4272b22 100644
--- a/include/d/d_file_sel_info.h
+++ b/include/d/d_file_sel_info.h
@@ -37,7 +37,6 @@ public:
     CPaneMgrAlpha* getNoDatBase() { return mNoDatBase; }
     void draw() { _draw(); }
 
-private:
     /* 0x04 */ JKRArchive* mArchive;
     /* 0x08 */ dDlst_FileInfo_c mFileInfo;
     /* 0x1C */ u8 field_0x1c[4];
diff --git a/include/d/d_file_select.h b/include/d/d_file_select.h
index 634c0db352..dd4d5a3aae 100644
--- a/include/d/d_file_select.h
+++ b/include/d/d_file_select.h
@@ -9,42 +9,13 @@
 #include "JSystem/J3DGraphLoader/J3DModelLoader.h"
 #include "JSystem/J3DGraphLoader/J3DAnmLoader.h"
 
+#if TARGET_PC
+#include "mods/svc/game_mode.h"
+#endif
+
 class dFile_info_c;
 class J2DPicture;
 
-#if TARGET_PC
-static PaneCache mSelDtPanes[] = {
-    {MULTI_CHAR('tate_n0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('tate_n1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('ken_n0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('ken_n1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fuku_n0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fuku_n1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fuku_n2'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('gray_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('b_base'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('b_base1'), 0.0f, 0.0f, false},
-};
-
-static PaneCache fileSelPanes[] = {
-    {MULTI_CHAR('w_uzu00'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu01'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu02'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu03'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu04'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu05'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu06'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu07'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu08'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_uzu09'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_er_msg'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_er_msE'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_er_msR'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('er_for0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('er_for1'), 0.0f, 0.0f, false},
-};
-#endif
-
 class dDlst_FileSel_c : public dDlst_base_c {
 public:
     void draw();
@@ -420,6 +391,13 @@ public:
     bool pointerMenuSelect();
     bool pointerCopyDataToSelect();
     bool pointerYesNoSelect(bool errorSelect);
+    void backToDataSelectMove() {
+        headerTxtSet(0x43, 1, 0);
+        fileRecScaleAnmInitSet2(0.0f, 1.0f);
+        nameMoveAnmInitSet(0xd29, 0xd1f);
+        modoruTxtDispAnmInit(0);
+        mDataSelProc = DATASELPROC_NAME_TO_DATA_SELECT_MOVE;
+    }
     #endif
     void _draw();
     void errorMoveAnmInitSet(int, int);
@@ -728,24 +706,23 @@ public:
     /* 0x2374 */ u8 mFadeFlag;
     /* 0x2375 */ bool mHasDrawn;
 
-    #if PLATFORM_GCN
+#if PLATFORM_GCN
     /* 0x2378 */ J2DPicture* mpFadePict;
-    #endif
-#ifdef TARGET_PC
-    dDlst_FileSelFade_c mFadeDlst;
 #endif
 
-    #if PLATFORM_WII || PLATFORM_SHIELD
+#if PLATFORM_WII || PLATFORM_SHIELD
     /* 0x2376 */ u8 field_0x2376[SAVEFILE_SIZE];
     /* 0x4332 */ u8 field_0x4332;
     /* 0x4333 */ u8 field_0x4333;
-    #endif
-};
-
-#ifdef TARGET_PC
-STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C + sizeof(dDlst_FileSelFade_c));
-#else
-STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C);
 #endif
 
+#if TARGET_PC
+    dDlst_FileSelFade_c mFadeDlst;
+    bool mGameModeSaveStartBuildUi = true;
+    GameModeNewSaveState mGameModeNewSaveState = GAME_MODE_STATE_PENDING;
+#endif
+};
+
+STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C);
+
 #endif /* D_FILE_D_FILE_SELECT_H */
diff --git a/include/d/d_item.h b/include/d/d_item.h
index 0d379c0578..bf1252f9d6 100644
--- a/include/d/d_item.h
+++ b/include/d/d_item.h
@@ -8,10 +8,12 @@ public:
     static void setItemData(u8* data) { mData = data; }
     static u8* getItemData() { return mData; }
 
-    static u8* mData;
+    static DUSK_GAME_DATA u8* mData;
 };
 
-void execItemGet(u8 item_id);
+class fopAc_ac_c;
+void execItemGet(
+    u8 item_id IF_DUSK_ARG(u32 item_give_tag = 0) IF_DUSK_ARG(fopAc_ac_c* giver = NULL));
 
 void item_func_HEART();
 void item_func_GREEN_RUPEE();
diff --git a/include/d/d_item_data.h b/include/d/d_item_data.h
index a1770be241..7672174c87 100644
--- a/include/d/d_item_data.h
+++ b/include/d/d_item_data.h
@@ -86,9 +86,9 @@ struct dItem_data {
 
     static u16 getFieldHeapSize(u8 index) { return field_item_res[index].mHeapSize; } 
 
-    static dItem_itemResource item_resource[255];
-    static dItem_fieldItemResource field_item_res[255];
-    static dItem_itemInfo item_info[255];
+    static DUSK_GAME_DATA dItem_itemResource item_resource[255];
+    static DUSK_GAME_DATA dItem_fieldItemResource field_item_res[255];
+    static DUSK_GAME_DATA dItem_itemInfo item_info[255];
 };
 
 enum {
@@ -142,7 +142,12 @@ enum {
     /* 0x2F */ dItemNo_WEAR_KOKIRI_e,
     /* 0x30 */ dItemNo_ARMOR_e,
     /* 0x31 */ dItemNo_WEAR_ZORA_e,
+#if TARGET_PC
     /* 0x32 */ dItemNo_MAGIC_LV1_e,
+    dItemNo_SHADOW_CRYSTAL_e = dItemNo_MAGIC_LV1_e,
+#else
+    /* 0x32 */ dItemNo_MAGIC_LV1_e,
+#endif
     /* 0x33 */ dItemNo_DUNGEON_EXIT_2_e,
     /* 0x34 */ dItemNo_WALLET_LV1_e,
     /* 0x35 */ dItemNo_WALLET_LV2_e,
diff --git a/include/d/d_k_wmark.h b/include/d/d_k_wmark.h
index 0190c94467..b4f28d1263 100644
--- a/include/d/d_k_wmark.h
+++ b/include/d/d_k_wmark.h
@@ -13,7 +13,7 @@ public:
     inline int execute();
     inline int draw();
 
-    static int m_nowID;
+    static DUSK_GAME_DATA int m_nowID;
 
     static void setFootMark(cXyz* i_pos, s16 param_1, int param_2) {
         fopKyM_create(fpcNm_WMARK_e, param_2 | (param_1 << 0x10), i_pos, NULL, NULL);
diff --git a/include/d/d_kankyo.h b/include/d/d_kankyo.h
index 06c8f0eb56..1a43d811f7 100644
--- a/include/d/d_kankyo.h
+++ b/include/d/d_kankyo.h
@@ -471,7 +471,7 @@ public:
     /* 0x130C */ u8 staffroll_next_timer;
 };  // Size: 0x1310
 
-extern dScnKy_env_light_c g_env_light;
+DUSK_GAME_EXTERN dScnKy_env_light_c g_env_light;
 
 STATIC_ASSERT(sizeof(dScnKy_env_light_c) == 4880);
 
@@ -967,7 +967,7 @@ public:
     /* 0x7A0 */ dKankyo_ParticlelightHIO_c particleLight;
 };
 
-extern dKankyo_HIO_c g_kankyoHIO;
+DUSK_GAME_EXTERN dKankyo_HIO_c g_kankyoHIO;
 
 enum dKy_dice_wether_mode {
     DICE_MODE_SUNNY_e,
diff --git a/include/d/d_kantera_icon_meter.h b/include/d/d_kantera_icon_meter.h
index 04466df8be..cf1464e82f 100644
--- a/include/d/d_kantera_icon_meter.h
+++ b/include/d/d_kantera_icon_meter.h
@@ -13,7 +13,6 @@ public:
     void setScreen(J2DScreen* screen) { mp_scrn = screen; }
     J2DScreen* getScreen() { return mp_scrn; }
 
-private:
     /* 0x04 */ J2DScreen* mp_scrn;
 };
 
@@ -30,7 +29,6 @@ public:
 
     void drawSelf() { mpKanteraIcon->draw(); }
 
-private:
     /* 0x04 */ dDlst_KanteraIcon_c* mpKanteraIcon;
     /* 0x08 */ CPaneMgr* mpParent;
     /* 0x0C */ CPaneMgr* mpGauge;
diff --git a/include/d/d_ky_thunder.h b/include/d/d_ky_thunder.h
index 1e174ad6f8..5a72252a9a 100644
--- a/include/d/d_ky_thunder.h
+++ b/include/d/d_ky_thunder.h
@@ -25,7 +25,6 @@ public:
 
     ~dThunder_c() { mDoExt_destroySolidHeap(mpHeap); }
 
-private:
     /* 0x0F8 */ JKRSolidHeap* mpHeap;
     /* 0x0FC */ dThunder_modelInfo_c mModelInfo;
     /* 0x138 */ cXyz field_0x138;
diff --git a/include/d/d_lib.h b/include/d/d_lib.h
index 1d3103ce96..c4f8fed7bb 100644
--- a/include/d/d_lib.h
+++ b/include/d/d_lib.h
@@ -85,11 +85,11 @@ struct dLib_time_c {
     static void stopTime();
     static void startTime();
 
-    static OSTime m_diffTime;
-    static OSTime m_stopTime;
-    static bool m_timeStopped;
+    static DUSK_GAME_DATA OSTime m_diffTime;
+    static DUSK_GAME_DATA OSTime m_stopTime;
+    static DUSK_GAME_DATA bool m_timeStopped;
 };
 
-extern Quaternion ZeroQuat;
+DUSK_GAME_EXTERN Quaternion ZeroQuat;
 
 #endif /* D_D_LIB_H */
diff --git a/include/d/d_map.h b/include/d/d_map.h
index 1cddbf3944..b70238cc46 100644
--- a/include/d/d_map.h
+++ b/include/d/d_map.h
@@ -87,7 +87,7 @@ struct dMap_HIO_prm_res_src_s {
 };
 
 struct dMap_HIO_prm_res_dst_s {
-    static dMap_prm_res_s* m_res;
+    static DUSK_GAME_DATA dMap_prm_res_s* m_res;
     static dMap_HIO_prm_other_s m_other;
 };
 
@@ -134,7 +134,6 @@ public:
     static const int PALETTE_NUMBER = 50;
 #endif
 
-private:
     /* 0x34 */ s32 m_outSideBlackLineCnt;
     /* 0x38 */ s32 field_0x38;
     /* 0x3C */ s32 field_0x3c;
@@ -199,7 +198,6 @@ public:
 
     static dMap_c* m_mySelfPointer;
 
-private:
     /* 0x40 */ dMap_prm_res_s* m_res_src;
     /* 0x44 */ dMap_prm_res_s* m_res;
     /* 0x48 */ ResTIMG* mResTIMG;
diff --git a/include/d/d_map_path.h b/include/d/d_map_path.h
index 495fdf396a..885c7ade87 100644
--- a/include/d/d_map_path.h
+++ b/include/d/d_map_path.h
@@ -260,7 +260,7 @@ struct dMpath_n {
         /* 0x0 */ TGXTexObj* mp_texObj[TEX_OBJ_NUMBER];
     };
 
-    static dTexObjAggregate_c m_texObjAgg;
+    static DUSK_GAME_DATA dTexObjAggregate_c m_texObjAgg;
 };
 
 STATIC_ASSERT(sizeof(dMpath_n::dTexObjAggregate_c) == 28);
diff --git a/include/d/d_map_path_dmap.h b/include/d/d_map_path_dmap.h
index bbffcd7809..7d23be73c9 100644
--- a/include/d/d_map_path_dmap.h
+++ b/include/d/d_map_path_dmap.h
@@ -33,17 +33,17 @@ public:
     static f32 getCenterX() { return mAllCenterX; }
     static f32 getCenterZ() { return mAllCenterZ; }
 
-    static dDrawPath_c::layer_data* mLayerList;  // this doesn't seem right, but can't figure it out atm
-    static f32 mMinX;
-    static f32 mMaxX;
-    static f32 mMinZ;
-    static f32 mMaxZ;
-    static f32 mAllCenterX;
-    static f32 mAllCenterZ;
-    static f32 mAllSizeX;
-    static f32 mAllSizeZ;
-    static s8 mBottomFloorNo;
-    static s8 mTopFloorNo;
+    static DUSK_GAME_DATA dDrawPath_c::layer_data* mLayerList;  // this doesn't seem right, but can't figure it out atm
+    static DUSK_GAME_DATA f32 mMinX;
+    static DUSK_GAME_DATA f32 mMaxX;
+    static DUSK_GAME_DATA f32 mMinZ;
+    static DUSK_GAME_DATA f32 mMaxZ;
+    static DUSK_GAME_DATA f32 mAllCenterX;
+    static DUSK_GAME_DATA f32 mAllCenterZ;
+    static DUSK_GAME_DATA f32 mAllSizeX;
+    static DUSK_GAME_DATA f32 mAllSizeZ;
+    static DUSK_GAME_DATA s8 mBottomFloorNo;
+    static DUSK_GAME_DATA s8 mTopFloorNo;
 };
 
 struct dMapInfo_n {
@@ -90,10 +90,10 @@ public:
     static void setNextRoomNoForMapPat0(int i_roomNo) { mNextRoomNo = i_roomNo; }
     static int getNextRoomNoForMapPat0() { return mNextRoomNo; }
 
-    static int mNextRoomNo;
-    static int mNowStayRoomNo;
-    static s8 mNowStayFloorNo;
-    static u8 mNowStayFloorNoDecisionFlg;
+    static DUSK_GAME_DATA int mNextRoomNo;
+    static DUSK_GAME_DATA int mNowStayRoomNo;
+    static DUSK_GAME_DATA s8 mNowStayFloorNo;
+    static DUSK_GAME_DATA u8 mNowStayFloorNoDecisionFlg;
 };
 
 class renderingDAmap_c : public dRenderingFDAmap_c {
diff --git a/include/d/d_menu_collect.h b/include/d/d_menu_collect.h
index d99b8f17cb..d2a4028b2e 100644
--- a/include/d/d_menu_collect.h
+++ b/include/d/d_menu_collect.h
@@ -15,49 +15,6 @@ class dMenu_Fishing_c;
 class dMenu_Skill_c;
 class dMenu_Insect_c;
 class dSelect_cursor_c;
-
-#if TARGET_PC
-struct PaneCache {
-    u64 tag;
-    f32 origTransX;
-    f32 origTransY;
-    bool cached;
-};
-
-static PaneCache mpScreenPanes[] = {
-    {MULTI_CHAR('sa_tex_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('op_tex_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('heart_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('wolf_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('item_0_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('item_1_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('item_2_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fish_3_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('lett_4_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('maki_5_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fuku_n0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fuku_n1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('fuku_n2'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('tate_n0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('tate_n1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('ken_n0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('ken_n1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('kabu_6n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('t_t00'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('f_t00'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('itemn_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('infotxtn'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('sa_op_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('title_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('menu_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('w_er_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('center_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('info_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('lavel_n'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('modelbgn'), 0.0f, 0.0f, false},
-};
-#endif
-
 class dMenu_Collect2D_c;
 class dMenu_Collect2DTop_c : public dDlst_base_c {
 public:
@@ -172,7 +129,6 @@ public:
     J2DPicture* getBlackTex() { return mpBlackTex; }
     u8 getSubWindowOpenCheck() { return mSubWindowOpenCheck; }
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ JKRExpHeap* mpSubHeap;
     /* 0x00C */ void* field_0xc;
@@ -266,9 +222,8 @@ public:
         mViewOffsetY = i_offset;
     }
 
-    static f32 mViewOffsetY;
+    static DUSK_GAME_DATA f32 mViewOffsetY;
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ JKRSolidHeap* mpSolidHeap;
     /* 0x00C */ dMenu_Collect2D_c* mpCollect2D;
@@ -303,7 +258,6 @@ public:
     bool isKeyCheck() { return mpCollect2D->isKeyCheck(); }
     bool isOutCheck() { return mpCollect2D->isOutCheck(); }
 
-private:
     /* 0x4 */ dMenu_Collect2D_c* mpCollect2D;
     /* 0x8 */ dMenu_Collect3D_c* mpCollect3D;
 };
diff --git a/include/d/d_menu_dmap.h b/include/d/d_menu_dmap.h
index 7740927f4e..039b42aab2 100644
--- a/include/d/d_menu_dmap.h
+++ b/include/d/d_menu_dmap.h
@@ -253,9 +253,8 @@ public:
     s8 getFloorPos(s8 param_0) { return param_0 - mBottomFloor; }
     u16 getCMessageNum() { return mCMessageNum; }
 
-    static dMenu_Dmap_c* myclass;
+    static DUSK_GAME_DATA dMenu_Dmap_c* myclass;
 
-private:
     /* 0x004 */ dMenu_DmapMapCtrl_c* mMapCtrl;
     /* 0x008 */ dMenu_DmapBg_c* mpDrawBg;
     /* 0x00C */ u8 field_0xc[0x10 - 0xC];
diff --git a/include/d/d_menu_dmap_map.h b/include/d/d_menu_dmap_map.h
index f1a5432391..3f3eb37a0f 100644
--- a/include/d/d_menu_dmap_map.h
+++ b/include/d/d_menu_dmap_map.h
@@ -151,10 +151,10 @@ public:
 
     ResTIMG* getResTIMGPointer(int i_no) const { return dMenu_DmapMap_c::getResTIMGPointer(i_no); }
 
-    static f32 m_zoomCenterMinX;
-    static f32 m_zoomCenterMaxX;
-    static f32 m_zoomCenterMinZ;
-    static f32 m_zoomCenterMaxZ;
+    static DUSK_GAME_DATA f32 m_zoomCenterMinX;
+    static DUSK_GAME_DATA f32 m_zoomCenterMaxX;
+    static DUSK_GAME_DATA f32 m_zoomCenterMinZ;
+    static DUSK_GAME_DATA f32 m_zoomCenterMaxZ;
 
     /* 0x88 */ u8 field_0x88[0x8C - 0x88];
     /* 0x8C */ dTres_c::typeGroupData_c* field_0x8c;
diff --git a/include/d/d_menu_fishing.h b/include/d/d_menu_fishing.h
index 972aa8f7c4..b3b451c968 100644
--- a/include/d/d_menu_fishing.h
+++ b/include/d/d_menu_fishing.h
@@ -43,7 +43,6 @@ public:
 
     u8 getStatus() { return mStatus; }
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ JKRArchive* mpArchive;
     /* 0x00C */ STControl* mpStick;
diff --git a/include/d/d_menu_fmap.h b/include/d/d_menu_fmap.h
index 48db37fef3..3104d7e76b 100644
--- a/include/d/d_menu_fmap.h
+++ b/include/d/d_menu_fmap.h
@@ -268,9 +268,8 @@ public:
         /* 0x1D */ PROC_HOWL_DEMO3,
      };
 
-    static dMenu_Fmap_c* MyClass;
+    static DUSK_GAME_DATA dMenu_Fmap_c* MyClass;
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ JKRExpHeap* mpTalkHeap;
     /* 0x00C */ STControl* mpStick;
@@ -356,7 +355,7 @@ public:
     /* 0x10 */ u8 mBaseBackAlpha;
     /* 0x11 */ u8 mMoyaAlpha;
 
-    static dMf_HIO_c* mMySelfPointer;
+    static DUSK_GAME_DATA dMf_HIO_c* mMySelfPointer;
 };
 
 const char* dMenuFmap_getStartStageName(void* param_0);
diff --git a/include/d/d_menu_fmap_map.h b/include/d/d_menu_fmap_map.h
index 95294ffb35..b0d1063d18 100644
--- a/include/d/d_menu_fmap_map.h
+++ b/include/d/d_menu_fmap_map.h
@@ -28,7 +28,7 @@ struct dMfm_prm_res_s {
 struct dMfm_HIO_prm_res_src_s {
     /* 0x0 */ u8 mFlashDuration;
 
-    static const dMfm_HIO_prm_res_src_s m_other;
+    static DUSK_GAME_DATA const dMfm_HIO_prm_res_src_s m_other;
 };
 
 struct dMfm_HIO_prm_res_dst_s {
diff --git a/include/d/d_menu_insect.h b/include/d/d_menu_insect.h
index 90cfca7d5a..43f4af0602 100644
--- a/include/d/d_menu_insect.h
+++ b/include/d/d_menu_insect.h
@@ -60,7 +60,6 @@ public:
 
     u8 getStatus() { return mStatus; }
 
-private:
     /* 0x04 */ JKRExpHeap* mpHeap;
     /* 0x08 */ JKRArchive* mpArchive;
     /* 0x0C */ STControl* mpStick;
diff --git a/include/d/d_menu_item_explain.h b/include/d/d_menu_item_explain.h
index 7b79ebbad5..59d212e53f 100644
--- a/include/d/d_menu_item_explain.h
+++ b/include/d/d_menu_item_explain.h
@@ -51,7 +51,6 @@ public:
         field_0xd8 = y;
     }
 
-private:
     /* 0x04 */ JKRExpHeap* mpHeap;
     /* 0x08 */ JKRArchive* mpArchive;
     /* 0x0C */ dMsgString_c* mpInfoString;
diff --git a/include/d/d_menu_letter.h b/include/d/d_menu_letter.h
index 208f8b65a9..8e112f04d2 100644
--- a/include/d/d_menu_letter.h
+++ b/include/d/d_menu_letter.h
@@ -64,7 +64,6 @@ public:
 
     u8 getStatus() { return mStatus; }
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ JKRArchive* mpArchive;
     /* 0x00C */ STControl* mpStick;
diff --git a/include/d/d_menu_option.h b/include/d/d_menu_option.h
index 03aca42808..ff4b84f5e3 100644
--- a/include/d/d_menu_option.h
+++ b/include/d/d_menu_option.h
@@ -17,6 +17,20 @@ class dSelect_cursor_c;
 
 class dMenu_Option_c : public dDlst_base_c {
 public:
+    enum {
+        PROC_ATTEN_e,
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+        PROC_RUBY_e,
+#endif
+        PROC_VIB_e,
+        PROC_SOUND_e,
+        PROC_CHANGE_MOVE_e,
+        PROC_CONFIRM_OPEN_MOVE_e,
+        PROC_CONFIRM_MOVE_MOVE_e,
+        PROC_CONFIRM_SELECT_MOVE_e,
+        PROC_CONFIRM_CLOSE_MOVE_e,
+    };
+
     dMenu_Option_c(JKRArchive*, STControl*);
     void _create();
     void _delete();
@@ -31,7 +45,7 @@ public:
     bool _close();
     void atten_init();
     void atten_move();
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
     void ruby_init();
     void ruby_move();
 #endif
@@ -103,7 +117,6 @@ public:
         return ((u8)mUseFlag & (u8)i_flag) != 0 ? true : false;
     }
 
-private:
     /* 0x004 */ J2DScreen* mpBackScreen;
     /* 0x008 */ J2DScreen* mpScreen;
     /* 0x00C */ J2DScreen* mpClipScreen;
@@ -189,7 +202,7 @@ private:
     /* 0x3E2 */ u8 field_0x3e2;
     /* 0x3E3 */ u8 field_0x3e3;
     /* 0x3E4 */ u8 field_0x3e4;
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
     /* 0x3E5 */ u8 field_0x3e5_JPN;
 #endif
     /* 0x3E5 */ u8 field_0x3e5;
diff --git a/include/d/d_menu_ring.h b/include/d/d_menu_ring.h
index c7467d2a4b..fa4f97496f 100644
--- a/include/d/d_menu_ring.h
+++ b/include/d/d_menu_ring.h
@@ -84,7 +84,6 @@ public:
     void drawFlag0() { mDrawFlag = 0; }
     void setStatus(u8 i_status) { mStatus = i_status; }
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ STControl* mpStick;
     /* 0x00C */ CSTControl* mpCStick;
diff --git a/include/d/d_menu_save.h b/include/d/d_menu_save.h
index d9d052aa33..a237bbb849 100644
--- a/include/d/d_menu_save.h
+++ b/include/d/d_menu_save.h
@@ -27,7 +27,6 @@ public:
 
     void setScrnExplain(dMsgScrnExplain_c* p_scrn) { mpScrn = p_scrn; }
 
-private:
     /* 0x4 */ dMsgScrnExplain_c* mpScrn;
 };
 
@@ -278,7 +277,6 @@ public:
     u8 getEndStatus() { return mEndStatus; }
     void setUseType(u8 type) { mUseType = type; }
 
-private:
     /* 0x0004 */ JKRArchive* mpArchive;
     /* 0x0008 */ mDoDvdThd_mountArchive_c* mpMount;
     /* 0x000C */ STControl* stick;
diff --git a/include/d/d_menu_skill.h b/include/d/d_menu_skill.h
index 2f9097b165..2c2dc445d1 100644
--- a/include/d/d_menu_skill.h
+++ b/include/d/d_menu_skill.h
@@ -58,7 +58,6 @@ public:
 
     u8 getStatus() { return mStatus; }
 
-private:
     /* 0x004 */ JKRExpHeap* mpHeap;
     /* 0x008 */ JKRArchive* mpArchive;
     /* 0x00C */ STControl* mpStick;
diff --git a/include/d/d_menu_window.h b/include/d/d_menu_window.h
index 65e415077d..1c5aeadbe5 100644
--- a/include/d/d_menu_window.h
+++ b/include/d/d_menu_window.h
@@ -193,7 +193,6 @@ public:
     bool isShowFlag() { return (mShowFlag & 1) != 0; }
     bool isFadeNowCheck() { return mDoGph_gInf_c::getFader()->getStatus() == 1; }
 
-private:
     /* 0x0FC */ int field_0xfc;
     /* 0x100 */ JKRExpHeap* mpHeap;
     /* 0x104 */ STControl* mpStick;
diff --git a/include/d/d_menu_window_HIO.h b/include/d/d_menu_window_HIO.h
index b5d5c81fb4..7ac32267c8 100644
--- a/include/d/d_menu_window_HIO.h
+++ b/include/d/d_menu_window_HIO.h
@@ -31,7 +31,7 @@ public:
     /* 0x1E5 */ u8 mMidBossClearCopy[32];
 };
 
-extern dMw_DHIO_c g_mwDHIO;
+DUSK_GAME_EXTERN dMw_DHIO_c g_mwDHIO;
 
 class dMw_HIO_c : public JORReflexible {
 public:
@@ -131,6 +131,6 @@ public:
     /* 0x12A */ u8 mMirrorShardCopy[4];
 };  // Size: 0x130
 
-extern dMw_HIO_c g_mwHIO;
+DUSK_GAME_EXTERN dMw_HIO_c g_mwHIO;
 
 #endif /* D_MENU_D_MENU_WINDOW_HIO_H */
diff --git a/include/d/d_meter2.h b/include/d/d_meter2.h
index c8dc17bca8..4246d9249d 100644
--- a/include/d/d_meter2.h
+++ b/include/d/d_meter2.h
@@ -100,7 +100,6 @@ public:
     bool isShowFlag(int i_no) { return field_0x1e6 & (1 << i_no); }
     void onShowFlag(int i_no) { field_0x1e6 |= (1 << i_no); }
 
-private:
     /* 0x0FC */ int field_0xfc;
     /* 0x100 */ JKRExpHeap* mpHeap;
     /* 0x104 */ JKRExpHeap* mpSubHeap;
diff --git a/include/d/d_meter2_draw.h b/include/d/d_meter2_draw.h
index 10cded803d..c9dc8217e9 100644
--- a/include/d/d_meter2_draw.h
+++ b/include/d/d_meter2_draw.h
@@ -154,7 +154,6 @@ public:
     }
 #endif
 
-private:
     /* 0x004 */ item_params mItemParams[4];
     /* 0x074 */ JKRExpHeap* heap;
     /* 0x078 */ J2DScreen* mpScreen;
diff --git a/include/d/d_meter2_info.h b/include/d/d_meter2_info.h
index 683e555386..377f51c34b 100644
--- a/include/d/d_meter2_info.h
+++ b/include/d/d_meter2_info.h
@@ -21,7 +21,7 @@ struct dMenu_Letter {
     static u16 getLetterText(int idx) { return letter_data[idx].mText; }
     static u16 getLetterEventFlag(int idx) { return letter_data[idx].mEventFlag; }
 
-    static dMenu_LetterData letter_data[64];
+    static DUSK_GAME_DATA dMenu_LetterData letter_data[64];
 };
 
 class dMw_c;
@@ -301,7 +301,7 @@ public:
     /* 0xF3 */ u8 unk_0xf3[5];
 };
 
-extern dMeter2Info_c g_meter2_info;
+DUSK_GAME_EXTERN dMeter2Info_c g_meter2_info;
 
 void dMeter2Info_setSword(u8 i_itemId, bool i_offItemBit);
 void dMeter2Info_setCloth(u8 i_clothId, bool i_offItemBit);
@@ -328,6 +328,150 @@ void dMeter2Info_onWide2D();
 void dMeter2Info_offWide2D();
 #endif
 
+#if TARGET_PC
+DUSK_NOINLINE void dMeter2Info_Initialize();
+DUSK_NOINLINE dMeterMap_c* dMeter2Info_getMeterMapClass();
+DUSK_NOINLINE dMw_c* dMeter2Info_getMenuWindowClass();
+DUSK_NOINLINE void dMeter2Info_setWindowStatus(u8 i_status);
+DUSK_NOINLINE CPaneMgr* dMeter2Info_getMeterItemPanePtr(s32 i_idx);
+DUSK_NOINLINE void dMeter2Info_getString(
+    u32 i_stringID, TEXT_SPAN o_string, JMSMesgEntry_c* i_msgEntry);
+DUSK_NOINLINE void dMeter2Info_getStringKanji(
+    u32 i_stringID, TEXT_SPAN o_string, JMSMesgEntry_c* i_msgEntry);
+DUSK_NOINLINE void dMeter2Info_getStringKana(
+    u32 i_stringID, TEXT_SPAN o_string, JMSMesgEntry_c* i_msgEntry);
+DUSK_NOINLINE f32 dMeter2Info_getStringLength(
+    JUTFont* i_font, f32 param_2, f32 param_3, char* i_string);
+DUSK_NOINLINE f32 dMeter2Info_getStringLength(J2DTextBox* i_textbox, char* i_string);
+DUSK_NOINLINE void dMeter2Info_setHotSpringTimer(u8 i_slotNo);
+DUSK_NOINLINE u16 dMeter2Info_getOilGaugeBackUp();
+DUSK_NOINLINE void dMeter2Info_setOilGaugeBackUp(u16 param_1);
+DUSK_NOINLINE void dMeter2Info_setSaveStageName(const char* i_stageName);
+DUSK_NOINLINE u8 dMeter2Info_getInsectSelectType();
+DUSK_NOINLINE void dMeter2Info_setInsectSelectType(u8 i_type);
+DUSK_NOINLINE u8 dMeter2Info_getWarpStatus();
+DUSK_NOINLINE void dMeter2Info_setWarpStatus(u8 i_status);
+DUSK_NOINLINE int dMeter2Info_readItemTexture(u8 i_itemNo, void* i_texBuf1, J2DPicture* i_pic1,
+    void* i_texBuf2, J2DPicture* i_pic2, void* i_texBuf3, J2DPicture* i_pic3, void* i_texBuf4,
+    J2DPicture* i_pic4, int param_9);
+DUSK_NOINLINE void dMeter2Info_setItemColor(
+    u8 i_itemNo, J2DPicture* i_pic1, J2DPicture* i_pic2, J2DPicture* i_pic3, J2DPicture* i_pic4);
+DUSK_NOINLINE u8 dMeter2Info_getWarpRoomNo();
+DUSK_NOINLINE u8 dMeter2Info_getWarpPlayerNo();
+DUSK_NOINLINE cXyz& dMeter2Info_getWarpPos();
+DUSK_NOINLINE const char* dMeter2Info_getWarpStageName();
+DUSK_NOINLINE void dMeter2Info_setNowCount(u8 i_count);
+DUSK_NOINLINE void dMeter2Info_setMaxCount(u8 i_count);
+DUSK_NOINLINE BOOL dMeter2Info_isDirectUseItem(int param_0);
+DUSK_NOINLINE bool dMeter2Info_isUseButton(int i_buttonBit);
+DUSK_NOINLINE void dMeter2Info_setMeterMapClass(dMeterMap_c* i_map);
+DUSK_NOINLINE void dMeter2Info_decHotSpringTimer();
+DUSK_NOINLINE void dMeter2Info_allUseButton();
+DUSK_NOINLINE void dMeter2Info_offUseButton(int i_buttonBit);
+DUSK_NOINLINE void dMeter2Info_resetGameStatus();
+DUSK_NOINLINE void dMeter2Info_onGameStatus(int i_status);
+DUSK_NOINLINE void dMeter2Info_setMapStatus(u8 i_status);
+DUSK_NOINLINE u8 dMeter2Info_getMapStatus();
+DUSK_NOINLINE void dMeter2Info_setPauseStatus(u8 i_status);
+DUSK_NOINLINE void dMeter2Info_resetPauseStatus();
+DUSK_NOINLINE u8 dMeter2Info_getPauseStatus();
+DUSK_NOINLINE bool dMeter2Info_isGameStatus(int i_status);
+DUSK_NOINLINE bool dMeter2Info_isTouchKeyCheck(int i_status);
+DUSK_NOINLINE void dMeter2Info_setMapKeyDirection(u16 i_direction);
+DUSK_NOINLINE bool dMeter2Info_isSub2DStatus(int i_flag);
+DUSK_NOINLINE void dMeter2Info_offMenuInForce(int i_flag);
+DUSK_NOINLINE bool dMeter2Info_isMenuInForce(int i_flag);
+DUSK_NOINLINE void dMeter2Info_setMenuWindowClass(dMw_c* i_menu);
+DUSK_NOINLINE void dMeter2Info_resetWarpStatus();
+DUSK_NOINLINE u16 dMeter2Info_getMapKeyDirection();
+DUSK_NOINLINE u8 dMeter2Info_getWindowStatus();
+DUSK_NOINLINE void dMeter2Info_setMsgResource(void* i_res);
+DUSK_NOINLINE void dMeter2Info_setStageMsgResource(void* i_res);
+DUSK_NOINLINE void dMeter2Info_setMsgUnitResource(void* i_res);
+DUSK_NOINLINE void* dMeter2Info_getMsgResource();
+DUSK_NOINLINE void* dMeter2Info_getStageMsgResource();
+DUSK_NOINLINE void* dMeter2Info_getMsgUnitResource();
+DUSK_NOINLINE u8 dMeter2Info_getLightDropGetFlag(int i_no);
+DUSK_NOINLINE s32 dMeter2Info_getMeterStringType();
+DUSK_NOINLINE void dMeter2Info_setMeterClass(dMeter2_c* i_meter);
+DUSK_NOINLINE void dMeter2Info_onLifeGaugeSE();
+DUSK_NOINLINE void dMeter2Info_offLifeGaugeSE();
+DUSK_NOINLINE u8 dMeter2Info_getLifeGaugeSE();
+DUSK_NOINLINE const char* dMeter2Info_getSaveStageName();
+DUSK_NOINLINE void dMeter2Info_onShopTalkFlag();
+DUSK_NOINLINE void dMeter2Info_setLightDropGetFlag(int i_no, u8 i_flag);
+DUSK_NOINLINE u8 dMeter2Info_getRentalBombBag();
+DUSK_NOINLINE u8 dMeter2Info_getMiniGameItemSetFlag();
+DUSK_NOINLINE void dMeter2Info_setMiniGameItem(u8 i_minigameFlag);
+DUSK_NOINLINE void dMeter2Info_resetMiniGameItem(bool i_saveItem);
+DUSK_NOINLINE void dMeter2Info_setTableMapRegionNo(u8 i_regionNo);
+DUSK_NOINLINE void dMeter2Info_setGoldWolfMapType(u8 i_mapType);
+DUSK_NOINLINE void dMeter2Info_changeWater(u8 i_slotNo);
+DUSK_NOINLINE void dMeter2Info_warpInProc();
+DUSK_NOINLINE void dMeter2Info_warpOutProc();
+DUSK_NOINLINE dMeter2_c* dMeter2Info_getMeterClass();
+DUSK_NOINLINE s16 dMeter2Info_getMsgKeyWaitTimer();
+DUSK_NOINLINE void dMeter2Info_onDirectUseItem(int param_0);
+DUSK_NOINLINE void dMeter2Info_setFloatingFlow(u16 i_flowID, s16 i_msgTimer, bool i_wakuVisible);
+DUSK_NOINLINE u8 dMeter2Info_getGameOverType();
+DUSK_NOINLINE void dMeter2Info_setGameOverType(u8 i_gameoverType);
+DUSK_NOINLINE void dMeter2Info_setMsgKeyWaitTimer(s16 i_waitTimer);
+DUSK_NOINLINE s32 dMeter2Info_getMsgTimeMs();
+DUSK_NOINLINE s32 dMeter2Info_getTimeMs();
+DUSK_NOINLINE void dMeter2Info_setMsgTimeMs(s32 i_msgTime);
+DUSK_NOINLINE void dMeter2Info_setTimeMs(s32 i_time);
+DUSK_NOINLINE u8 dMeter2Info_getNowCount();
+DUSK_NOINLINE u8 dMeter2Info_getMaxCount();
+DUSK_NOINLINE void dMeter2Info_setScopeZoomPointer(u8 param_0);
+DUSK_NOINLINE void dMeter2Info_decMsgKeyWaitTimer();
+DUSK_NOINLINE bool dMeter2Info_isFloatingMessageVisible();
+DUSK_NOINLINE u8 dMeter2Info_getItemExplainWindowStatus();
+DUSK_NOINLINE void dMeter2Info_setItemExplainWindowStatus(u8 i_value);
+DUSK_NOINLINE void dMeter2Info_resetDirectUseItem();
+DUSK_NOINLINE u16 dMeter2Info_getFloatingFlowID();
+DUSK_NOINLINE u8 dMeter2Info_getCollectCursorPosX();
+DUSK_NOINLINE u8 dMeter2Info_getCollectCursorPosY();
+DUSK_NOINLINE void dMeter2Info_setCollectCursorPosXY(u8 x, u8 y);
+DUSK_NOINLINE void dMeter2Info_onBlinkButton(int i_flag);
+DUSK_NOINLINE bool dMeter2Info_isFloatingMessageWakuVisible();
+DUSK_NOINLINE bool dMeter2Info_isBlinkButton(int i_flag);
+DUSK_NOINLINE void dMeter2Info_resetBlinkButton();
+DUSK_NOINLINE void dMeter2Info_resetFloatingMessage();
+DUSK_NOINLINE s16 dMeter2Info_decFloatingMessageTimer();
+DUSK_NOINLINE s16 dMeter2Info_getFloatingMessageTimer();
+DUSK_NOINLINE u16 dMeter2Info_getFloatingMessageID();
+DUSK_NOINLINE s16 dMeter2Info_getHorseLifeCount();
+DUSK_NOINLINE void dMeter2Info_setMeterString(s32 i_string);
+DUSK_NOINLINE void dMeter2Info_resetMeterString();
+DUSK_NOINLINE void dMeter2Info_setMeterItemPanePtr(int i_no, CPaneMgr* i_pane);
+DUSK_NOINLINE bool dMeter2Info_isShopTalkFlag();
+DUSK_NOINLINE void dMeter2Info_setMapDrugFlag(bool i_flag);
+DUSK_NOINLINE bool dMeter2Info_isTempBit(int i_bit);
+DUSK_NOINLINE void dMeter2Info_offSub2DStatus(int i_bit);
+DUSK_NOINLINE void dMeter2Info_onSub2DStatus(int i_bit);
+DUSK_NOINLINE void dMeter2Info_set2DWidth(f32 i_width);
+DUSK_NOINLINE void dMeter2Info_set2DHeight(f32 i_height);
+DUSK_NOINLINE void dMeter2Info_set2DPosH(f32 i_posH);
+DUSK_NOINLINE void dMeter2Info_set2DPosV(f32 i_posV);
+DUSK_NOINLINE void dMeter2Info_offShopTalkFlag();
+DUSK_NOINLINE void dMeter2Info_onUseButton(int i_button);
+DUSK_NOINLINE f32 dMeter2Info_get2DWidth();
+DUSK_NOINLINE f32 dMeter2Info_get2DHeight();
+DUSK_NOINLINE void dMeter2Info_setWarpInfo(const char* i_stageName, const cXyz& i_position,
+    s16 i_angle, u8 i_roomNo, u8 param_4, u8 i_warpPlayerNo);
+DUSK_NOINLINE u8 dMeter2Info_getTableMapRegionNo();
+DUSK_NOINLINE u8 dMeter2Info_getGoldWolfMapType();
+DUSK_NOINLINE bool dMeter2Info_isWindowAccept(int param_0);
+DUSK_NOINLINE void dMeter2Info_setHorseLifeCount(s16 i_count);
+DUSK_NOINLINE void dMeter2Info_offTempBit(int i_bit);
+DUSK_NOINLINE void dMeter2Info_onTempBit(int i_bit);
+DUSK_NOINLINE void dMeter2Info_setFloatingMessage(u16 i_msgID, s16 i_msgTimer, bool i_wakuVisible);
+DUSK_NOINLINE void dMeter2Info_setMiniGameCount(s8 i_count);
+DUSK_NOINLINE void dMeter2Info_onWindowAccept(int param_0);
+DUSK_NOINLINE void dMeter2Info_offWindowAccept(int param_0);
+DUSK_NOINLINE void dMeter2Info_onMenuInForce(int param_0);
+
+#else
 inline void dMeter2Info_Initialize() {
     g_meter2_info.init();
 }
@@ -865,4 +1009,6 @@ inline void dMeter2Info_onMenuInForce(int param_0) {
     g_meter2_info.onMenuInForce(param_0);
 }
 
+#endif
+
 #endif /* D_METER_D_METER2_INFO_H */
diff --git a/include/d/d_meter_HIO.h b/include/d/d_meter_HIO.h
index e52051095f..037b17779b 100644
--- a/include/d/d_meter_HIO.h
+++ b/include/d/d_meter_HIO.h
@@ -1332,10 +1332,10 @@ public:
 
 STATIC_ASSERT(sizeof(dMeter_cursorHIO_c) == 68);
 
-extern dMeter_menuHIO_c g_menuHIO;
-extern dMeter_drawHIO_c g_drawHIO;
-extern dMeter_ringHIO_c g_ringHIO;
-extern dMeter_fmapHIO_c g_fmapHIO;
-extern dMeter_cursorHIO_c g_cursorHIO;
+DUSK_GAME_EXTERN dMeter_menuHIO_c g_menuHIO;
+DUSK_GAME_EXTERN dMeter_drawHIO_c g_drawHIO;
+DUSK_GAME_EXTERN dMeter_ringHIO_c g_ringHIO;
+DUSK_GAME_EXTERN dMeter_fmapHIO_c g_fmapHIO;
+DUSK_GAME_EXTERN dMeter_cursorHIO_c g_cursorHIO;
 
 #endif /* D_METER_D_METER_HIO_H */
diff --git a/include/d/d_meter_map.h b/include/d/d_meter_map.h
index b17f51846e..648fb5aef5 100644
--- a/include/d/d_meter_map.h
+++ b/include/d/d_meter_map.h
@@ -102,7 +102,6 @@ public:
     /* 0x04 */ u8 field_0x4_debug;
     /* 0x08 */ int field_0x8_debug;
 #endif
-private:
     /* 0x04 */ J2DPicture* mMapJ2DPicture;
     /* 0x08 */ dMap_c* mMap;
     /* 0x0C */ s32 mIsCompass;
diff --git a/include/d/d_model.h b/include/d/d_model.h
index 2dd1abaabf..466592d89c 100644
--- a/include/d/d_model.h
+++ b/include/d/d_model.h
@@ -33,7 +33,6 @@ public:
     u16 getMaterialId() { return mMaterialId; }
     dKy_tevstr_c* getTevstr() { return mpTevstr; }
 
-private:
     /* 0x10 */ J3DModelData* mpModelData;
     /* 0x14 */ dKy_tevstr_c* mpTevstr;
     /* 0x18 */ u16 mMaterialId;
@@ -53,9 +52,8 @@ public:
     static void remove();
     static void reset();
 
-    static dMdl_mng_c* m_myObj;
+    static DUSK_GAME_DATA dMdl_mng_c* m_myObj;
 
-private:
     /* 0x00 */ dMdl_c field_0x0[4];
     /* 0x80 */ u8 field_0x80;
 };
diff --git a/include/d/d_msg_class.h b/include/d/d_msg_class.h
index 307d48f291..49a99a6ef1 100644
--- a/include/d/d_msg_class.h
+++ b/include/d/d_msg_class.h
@@ -4,10 +4,15 @@
 #include "JSystem/JMessage/control.h"
 #include "JSystem/JMessage/JMessage.h"
 #include "SSystem/SComponent/c_xyz.h"
-#include "dusk/endian.h"
-#include "dusk/string.hpp"
 
-#if REGION_JPN
+#if TARGET_PC
+#include "helpers/endian.h"
+#include "helpers/string.hpp"
+
+#define D_MSG_CLASS_PAGE_CNT_MAX 40
+#define D_MSG_CLASS_CHAR_CNT_MAX 0x210
+#define D_MSG_CLASS_LINE_MAX 12
+#elif REGION_JPN
 #define D_MSG_CLASS_PAGE_CNT_MAX 30
 #define D_MSG_CLASS_CHAR_CNT_MAX 0x210
 #define D_MSG_CLASS_LINE_MAX 9
@@ -23,18 +28,20 @@ public:
 
     // Attributes
     /* 0x04 */ BE(u16) message_id;
-    /* 0x06 */ BE(u16) event_label_id;
-    /* 0x08 */ u8 se_speaker;
-    /* 0x09 */ u8 fuki_kind;
-    /* 0x0A */ u8 output_type;
-    /* 0x0B */ u8 fuki_pos_type;
-    /* 0x0C */ u8 unk_0xc;
-    /* 0x0D */ u8 unk_0xd;
-    /* 0x0E */ u8 se_mood;
-    /* 0x0F */ u8 camera_id;
-    /* 0x10 */ u8 base_anm_id;
-    /* 0x11 */ u8 face_anm_id;
-    /* 0x12 */ BE(u16) unk_0x12;
+    /* 0x06 */ BE(u16) event_label_id;  // saveBitLabels index set when the message displays
+    /* 0x08 */ u8 speaker;              // Z2SpeechMgr2 voice bank ID
+    /* 0x09 */ u8 box_kind;             // screen class, see dMsgObject_c::talkStartInit
+    /* 0x0A */ u8 draw_type;            // text pacing, see jmessage_tSequenceProcessor::do_begin
+    /* 0x0B */ u8 box_position;         // see dMsgObject_c::fukiPosCalc
+    /* 0x0C */ u8 item_no;              // unused; legacy dItemNo, 0xFF = none
+    /* 0x0D */ u8 line_alignment;       // 0 centered (JP only), 1 left; also copied to
+                                        // jmessage_tReference::mForm
+    /* 0x0E */ u8 speaker_mood;         // grunt emotion index for the voice bank
+    /* 0x0F */ u8 camera_attr;          // 1-10 talk-actor slot, >=11 talk-camera style
+    /* 0x10 */ u8 talk_anim;            // NPC talk motion attribute
+    /* 0x11 */ u8 face_anim;            // NPC talk face attribute
+    /* 0x12 */ u8 lines_per_page;       // unused; runtime uses getLineMax()
+    /* 0x13 */ u8 _pad;
 };
 
 class JMSMesgInfo_c {
@@ -115,6 +122,25 @@ struct jmessage_tReference : public JMessage::TReference {
     void setDemoFrame(u32 i_frame) { mDemoFrame = i_frame; }
     void setTopColorType(u8 i_colorType) { mTopColorType = i_colorType; }
     void setNowColorType(u8 i_colorType) { mNowColorType = i_colorType; }
+#if TARGET_PC
+    void resetColors() {
+        mNowCCColor = 0xFFFFFFFF;
+        mNowGCColor = 0xFFFFFFFF;
+        mTopCCColor = 0xFFFFFFFF;
+        mTopGCColor = 0xFFFFFFFF;
+        mNowFullColor = false;
+        mTopFullColor = false;
+    }
+    void setFullColor(u32 ccColor, u32 gcColor) {
+        mNowCCColor = ccColor;
+        mNowGCColor = gcColor;
+        mNowFullColor = true;
+    }
+    void clearNowFullColor() { mNowFullColor = false; }
+    bool hasTopFullColor() { return mTopFullColor; }
+    u32 getTopCCColor() { return mTopCCColor; }
+    u32 getTopGCColor() { return mTopGCColor; }
+#endif
     void setTopTagScale(u16 i_tagScale) { mTopTagScale = i_tagScale; }
     void setNowTagScale(u16 i_tagScale) { mNowTagScale = i_tagScale; }
     void setRevoMessageID(u32 i_msgID) { mRevoMessageID = i_msgID; }
@@ -359,6 +385,14 @@ struct jmessage_tReference : public JMessage::TReference {
     /* 0x1274 */ bool mSelectSetCancelFlag;
     /* 0x1275 */ bool mBombNameUseFlag;
     /* 0x1276 */ u8 mBatchColorFlag;
+#if TARGET_PC
+    u32 mNowCCColor;
+    u32 mNowGCColor;
+    u32 mTopCCColor;
+    u32 mTopGCColor;
+    bool mNowFullColor;
+    bool mTopFullColor;
+#endif
 };  // Size: 0x1278
 
 struct jmessage_tMeasureProcessor : public JMessage::TRenderingProcessor {
@@ -456,6 +490,9 @@ struct jmessage_tRenderingProcessor : public JMessage::TRenderingProcessor {
     void do_selwidthcenter(int);
     void do_heightcenter();
     void do_color(u8);
+#if TARGET_PC
+    void do_fullcolor(u32 ccColor, u32 gcColor);
+#endif
     void do_scale(f32);
     void do_linedown(s16);
     void do_transY(s16, bool);
@@ -634,6 +671,9 @@ struct jmessage_string_tRenderingProcessor : public JMessage::TRenderingProcesso
     void do_rubystrcat(char*);
     void do_outfont(u8);
     void do_color(u8);
+#if TARGET_PC
+    void do_fullcolor(u32 ccColor, u32 gcColor);
+#endif
     void do_scale(f32);
     void do_linedown(s16);
     void do_numset(s16);
diff --git a/include/d/d_msg_flow.h b/include/d/d_msg_flow.h
index cd9a7c4e5f..b7ffb11fc7 100644
--- a/include/d/d_msg_flow.h
+++ b/include/d/d_msg_flow.h
@@ -2,7 +2,10 @@
 #define D_MSG_D_MSG_FLOW_H
 
 #include <types.h>
-#include "dusk/endian.h"
+
+#if TARGET_PC
+#include "helpers/endian.h"
+#endif
 
 enum {
     NODETYPE_MESSAGE_e = 1,
@@ -22,7 +25,7 @@ struct msg_class;
 // all mesg_flow_node structs members might be wrong
 struct mesg_flow_node {
     /* 0x00 */ u8 type;
-    /* 0x01 */ u8 field_0x1;
+    /* 0x01 */ u8 subtype;
     /* 0x02 */ BE(u16) msg_index;
     /* 0x04 */ BE(u16) next_node_idx;
     /* 0x06 */ BE(u16) unk_0x6;
@@ -30,7 +33,7 @@ struct mesg_flow_node {
 
 struct mesg_flow_node_branch {
     /* 0x00 */ u8 type;
-    /* 0x01 */ u8 field_0x1;
+    /* 0x01 */ u8 result_count;
     /* 0x02 */ BE(u16) query_idx;
     /* 0x04 */ BE(u16) param;
     /* 0x06 */ BE(u16) next_node_idx;
@@ -185,10 +188,9 @@ public:
     void setMsg(u32 msg) { mMsg = msg; }
     bool checkEndFlow() { return (u32)field_0x26 == 1; }
 
-    static queryFunc mQueryList[53];
-    static eventFunc mEventList[43];
+    static DUSK_GAME_DATA queryFunc mQueryList[53];
+    static DUSK_GAME_DATA eventFunc mEventList[43];
 
-private:
     /* 0x04 */ u8* mFlow_p;
     /* 0x08 */ u8* mLabelInfo_p;
     /* 0x0C */ union mesg_flow {
diff --git a/include/d/d_msg_object.h b/include/d/d_msg_object.h
index d4d8bb7f47..3e8c535800 100644
--- a/include/d/d_msg_object.h
+++ b/include/d/d_msg_object.h
@@ -280,13 +280,13 @@ public:
     /* 0x150 */ f32 field_0x150;
     /* 0x154 */ u32 mMessageID;
     /* 0x158 */ u32 field_0x158;
-    /* 0x15C */ u32 field_0x15c;
+    /* 0x15C */ u32 mSelectMessageID;  // message ID of the selection options message; 1000 = none
     /* 0x160 */ int mIdx;
     /* 0x164 */ u16 mNodeIdx;
     /* 0x166 */ u16 field_0x166;
     /* 0x168 */ u16 field_0x168;
     /* 0x16A */ s16 field_0x16a;
-    /* 0x16C */ s16 field_0x16c;
+    /* 0x16C */ s16 mCurrentGroupID;  // group whose BMG is parsed; -1 none, 0 common, 1-8 stage
     /* 0x16E */ s16 field_0x16e;
     /* 0x170 */ s16 mNowTalkFlowNo;
     /* 0x172 */ s16 field_0x172;
@@ -771,6 +771,6 @@ public:
     /* 0x35C */ dMsgObject_HowlHIO_c mHowlHIO;
 };
 
-extern dMsgObject_HIO_c g_MsgObject_HIO_c;
+DUSK_GAME_EXTERN dMsgObject_HIO_c g_MsgObject_HIO_c;
 
 #endif /* D_MSG_D_MSG_OBJECT_H */
diff --git a/include/d/d_msg_out_font.h b/include/d/d_msg_out_font.h
index 2b2d0fa33d..3bd41ca825 100644
--- a/include/d/d_msg_out_font.h
+++ b/include/d/d_msg_out_font.h
@@ -25,7 +25,6 @@ public:
     void setTextBoxPtr(J2DTextBox* p_textBox) { mpTextBoxPtr = p_textBox; }
     void resetType() { mType = 0x47; }
 
-private:
     /* 0x04 */ J2DTextBox* mpTextBoxPtr;
     /* 0x08 */ f32 mPosX;
     /* 0x0C */ f32 mPosY;
@@ -53,7 +52,6 @@ public:
 
     void setRupeeColor(u8 color) { mRupeeColor = color; }
 
-private:
     /* 0x004 */ COutFontSet_c* mpOfs[35];
     /* 0x090 */ J2DPicture* mpPane[70];
     /* 0x1A8 */ f32 mAlphaRatio;
diff --git a/include/d/d_msg_scrn_3select.h b/include/d/d_msg_scrn_3select.h
index 1cb92e5be6..35c831d3c5 100644
--- a/include/d/d_msg_scrn_3select.h
+++ b/include/d/d_msg_scrn_3select.h
@@ -60,7 +60,6 @@ public:
     void offAnimeUpdate(int param_0) { field_0x114 &= ~(u8)(1 << param_0); }
     u8 getDPDPoint() { return mDPDPoint; }
 
-private:
     /* 0x004 */ J2DScreen* mpScreen;
     /* 0x008 */ J2DAnmTransform* mpAnmBck;
     /* 0x00C */ J2DAnmColorKey* mpAnmBpk;
diff --git a/include/d/d_msg_scrn_boss.h b/include/d/d_msg_scrn_boss.h
index d72c992b39..3adcc57289 100644
--- a/include/d/d_msg_scrn_boss.h
+++ b/include/d/d_msg_scrn_boss.h
@@ -15,7 +15,6 @@ public:
     virtual void fontAlpha(f32);
     virtual void fukiAlpha(f32);
 
-private:
     /* 0xC4 */ CPaneMgr* mpBaseParent;
     /* 0xC8 */ CPaneMgr* mpFontParent;
 };
diff --git a/include/d/d_msg_scrn_explain.h b/include/d/d_msg_scrn_explain.h
index 20931ec9ac..1b638f9b83 100644
--- a/include/d/d_msg_scrn_explain.h
+++ b/include/d/d_msg_scrn_explain.h
@@ -49,7 +49,6 @@ public:
     void onForceSelect() { mForceSelect = 1; }
     void setKeyWaitTimer(s16 timer) { mKeyWaitTimer = timer; }
 
-private:
     /* 0x04 */ dMsgString_c* mpString_c;
     /* 0x08 */ CPaneMgr* mpTm_c[2];
     /* 0x10 */ CPaneMgr* mpTmr_c[2];
diff --git a/include/d/d_msg_string.h b/include/d/d_msg_string.h
index 45a148b401..2d92939141 100644
--- a/include/d/d_msg_string.h
+++ b/include/d/d_msg_string.h
@@ -39,7 +39,6 @@ public:
         drawOutFontLocal(param_0, param_1);
     }
 
-private:
     /* 0x24 */ COutFont_c* mpOutFont;
     /* 0x28 */ u8 field_0x28;
 };
diff --git a/include/d/d_msg_string_base.h b/include/d/d_msg_string_base.h
index 4624393f06..020c557f85 100644
--- a/include/d/d_msg_string_base.h
+++ b/include/d/d_msg_string_base.h
@@ -30,7 +30,6 @@ public:
     virtual void drawOutFontLocal(J2DTextBox*, f32);
     virtual void drawFontLocal(J2DTextBox*, u8, f32, f32, f32, f32, u32, u8);
 
-private:
     /* 0x04 */ JMessage::TResourceContainer* mpResCont;
     /* 0x08 */ jmessage_string_tControl* mpCtrl;
     /* 0x0C */ jmessage_string_tReference* mpRefer;
diff --git a/include/d/d_msg_unit.h b/include/d/d_msg_unit.h
index 47e40e31cf..59e0a81183 100644
--- a/include/d/d_msg_unit.h
+++ b/include/d/d_msg_unit.h
@@ -8,10 +8,14 @@ public:
     dMsgUnit_c();
     void setTag(int, int, TEXT_SPAN, bool);
 
+#if TARGET_PC
+    void setTag_jpn(int, int, TEXT_SPAN, bool);
+#endif
+
     virtual ~dMsgUnit_c();
 };
 
-extern dMsgUnit_c g_msg_unit;
+DUSK_GAME_EXTERN dMsgUnit_c g_msg_unit;
 
 inline void dMsgUnit_setTag(int param_0, int param_1, TEXT_SPAN param_2) {
     g_msg_unit.setTag(param_0, param_1, param_2, true);
diff --git a/include/d/d_name.h b/include/d/d_name.h
index 68a4930baf..de084defb3 100644
--- a/include/d/d_name.h
+++ b/include/d/d_name.h
@@ -12,34 +12,6 @@ class J2DTextBox;
 class JUTFont;
 class STControl;
 
-#if TARGET_PC
-struct PaneCache {
-    u64 tag;
-    f32 origTransX;
-    f32 origTransY;
-    bool cached;
-};
-
-static PaneCache l_tagName[] = {
-    {MULTI_CHAR('m_00_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_3'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m_01_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m03_0'), 0.0f, 0.0f, false},  {MULTI_CHAR('m03_1'), 0.0f, 0.0f, false},  {MULTI_CHAR('m03_2'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m03_3'), 0.0f, 0.0f, false},  {MULTI_CHAR('m03_4'), 0.0f, 0.0f, false},  {MULTI_CHAR('m_04_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_1'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m_05_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_0'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m_07_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_4'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m_09_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_3'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m_10_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m12_0'), 0.0f, 0.0f, false},  {MULTI_CHAR('m12_1'), 0.0f, 0.0f, false},  {MULTI_CHAR('m12_2'), 0.0f, 0.0f, false},
-    {MULTI_CHAR('m12_3'), 0.0f, 0.0f, false},  {MULTI_CHAR('m12_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('p_end_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('p_end_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('p_end_0'), 0.0f, 0.0f, false},
-};                                             
-
-static PaneCache l_nameTagName[] = {
-    {MULTI_CHAR('name_00'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_01'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_02'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_03'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_04'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_05'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_06'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_07'), 0.0f, 0.0f, false},
-};
-
-static PaneCache l_nameCurTagName[] = {
-    {MULTI_CHAR('s__n_00'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_01'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_02'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_03'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_04'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_05'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_06'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_07'), 0.0f, 0.0f, false},
-};
-#endif
-
 class dNm_HIO_c {
 public:
     dNm_HIO_c();
@@ -158,7 +130,6 @@ public:
     void setNextNameStr(char* i_name) { SAFE_STRCPY(mNextNameStr,i_name); }
     void draw() { _draw(); }
 
-private:
     /* 0x004 */ STControl* stick;
     /* 0x008 */ JKRArchive* archive;
     /* 0x00C */ dDlst_NameIN_c nameIn;
diff --git a/include/d/d_pane_class.h b/include/d/d_pane_class.h
index 345cae1274..ffc067e411 100644
--- a/include/d/d_pane_class.h
+++ b/include/d/d_pane_class.h
@@ -93,7 +93,6 @@ public:
     JUtility::TColor getInitBlack() { return mInitBlack; }
     JUtility::TColor getInitWhite() { return mInitWhite; }
 
-private:
     /* 0x1C */ void* mpFirstStackSize;
     /* 0x20 */ s16* field_0x20;
     /* 0x24 */ JGeometry::TVec2<f32> mInitPos;
diff --git a/include/d/d_pane_class_alpha.h b/include/d/d_pane_class_alpha.h
index 82590e5f02..cf38229b97 100644
--- a/include/d/d_pane_class_alpha.h
+++ b/include/d/d_pane_class_alpha.h
@@ -54,7 +54,6 @@ public:
 
     virtual ~CPaneMgrAlphaMorf();
 
-private:
     /* 0x1C */ void* mpFirstSaveAlpha;
     /* 0x20 */ u8* field_0x20;
     /* 0x24 */ void* mpFirstGetAlpha;
diff --git a/include/d/d_particle.h b/include/d/d_particle.h
index 3098dbd521..a5849288f3 100644
--- a/include/d/d_particle.h
+++ b/include/d/d_particle.h
@@ -116,10 +116,10 @@ public:
     }
 
     static dPa_modelEcallBack& getEcallback() { return mEcallback; }
-    static dPa_modelEcallBack mEcallback;
+    static DUSK_GAME_DATA dPa_modelEcallBack mEcallback;
 
-    static dPa_modelPcallBack mPcallback;
-    static model_c* mModel;
+    static DUSK_GAME_DATA dPa_modelPcallBack mPcallback;
+    static DUSK_GAME_DATA model_c* mModel;
     #if DEBUG
     static u8 mNum;
     #endif
@@ -261,7 +261,6 @@ public:
     void setRate(f32 rate) { mRate = rate; }
     void setMaxCnt(int i_maxCnt) { mMaxCnt = i_maxCnt; }
 
-private:
     /* 0x04 */ f32 mRate;
     /* 0x08 */ int mMaxCnt;
     /* 0x0C */ cXyz const* field_0xc;
@@ -313,7 +312,6 @@ public:
             u16 getNameId() { return mNameId; }
             dPa_levelEcallBack* getCallback() { return mCallback; }
 
-        private:
             /* 0x00 */ u32 mId;
             /* 0x04 */ u16 mNameId;
             /* 0x06 */ u8 mStatus;
@@ -495,22 +493,21 @@ public:
         return &mWaterBubblePcallBack; 
     }
 
-    static dPa_selectTexEcallBack mTsubo[8];
-    static dPa_setColorEcallBack mLifeBall[3];
-    static Mtx mWindViewMatrix;
-    static JPAEmitterManager* mEmitterMng;
-    static dPa_wbPcallBack_c mWaterBubblePcallBack;
-    static dPa_fsenthPcallBack mFsenthPcallBack;
-    static dPa_light8EcallBack mLight8EcallBack;
-    static dPa_light8PcallBack mLight8PcallBack;
-    static dPa_gen_b_light8EcallBack m_b_Light8EcallBack;
-    static dPa_gen_b_light8PcallBack m_b_Light8PcallBack;
-    static dPa_gen_d_light8EcallBack m_d_Light8EcallBack;
-    static dPa_gen_d_light8PcallBack m_d_Light8PcallBack;
-    static dPa_particleTracePcallBack_c mParticleTracePCB;
-    static u8 mStatus;
+    static DUSK_GAME_DATA dPa_selectTexEcallBack mTsubo[8];
+    static DUSK_GAME_DATA dPa_setColorEcallBack mLifeBall[3];
+    static DUSK_GAME_DATA Mtx mWindViewMatrix;
+    static DUSK_GAME_DATA JPAEmitterManager* mEmitterMng;
+    static DUSK_GAME_DATA dPa_wbPcallBack_c mWaterBubblePcallBack;
+    static DUSK_GAME_DATA dPa_fsenthPcallBack mFsenthPcallBack;
+    static DUSK_GAME_DATA dPa_light8EcallBack mLight8EcallBack;
+    static DUSK_GAME_DATA dPa_light8PcallBack mLight8PcallBack;
+    static DUSK_GAME_DATA dPa_gen_b_light8EcallBack m_b_Light8EcallBack;
+    static DUSK_GAME_DATA dPa_gen_b_light8PcallBack m_b_Light8PcallBack;
+    static DUSK_GAME_DATA dPa_gen_d_light8EcallBack m_d_Light8EcallBack;
+    static DUSK_GAME_DATA dPa_gen_d_light8PcallBack m_d_Light8PcallBack;
+    static DUSK_GAME_DATA dPa_particleTracePcallBack_c mParticleTracePCB;
+    static DUSK_GAME_DATA u8 mStatus;
 
-private:
     /* 0x000 */ JKRSolidHeap* mHeap;
     /* 0x004 */ JPAResourceManager* mCommonResMng;
     /* 0x008 */ JKRExpHeap* m_resHeap;
diff --git a/include/d/d_particle_copoly.h b/include/d/d_particle_copoly.h
index c50b71387e..7bc8621546 100644
--- a/include/d/d_particle_copoly.h
+++ b/include/d/d_particle_copoly.h
@@ -78,8 +78,8 @@ public:
         return (this->*m_emitterTwoData[param_0])(param_1, param_2);
     }
 
-    static const effTypeFunc m_typeTwoData[];
-    static const emitterFunc m_emitterTwoData[];
+    static DUSK_GAME_DATA const effTypeFunc m_typeTwoData[];
+    static DUSK_GAME_DATA const emitterFunc m_emitterTwoData[];
 
     /* 0x38 */ u32 mLeftEmitter[2][4];
     /* 0x58 */ u32 mRightEmitter[2][4];
@@ -117,8 +117,8 @@ public:
         return (this->*m_emitterFourData[param_0])(param_1, param_2);
     }
 
-    static const effTypeFunc m_typeFourData[];
-    static const emitterFunc m_emitterFourData[];
+    static DUSK_GAME_DATA const effTypeFunc m_typeFourData[];
+    static DUSK_GAME_DATA const emitterFunc m_emitterFourData[];
 
     /* 0x80 */ u32 mBackLeftEmitter[2][4];
     /* 0xA0 */ u32 mBackRightEmitter[2][4];
diff --git a/include/d/d_particle_name.h b/include/d/d_particle_name.h
index 193cd9c96d..b5df5421a7 100644
--- a/include/d/d_particle_name.h
+++ b/include/d/d_particle_name.h
@@ -10,9 +10,9 @@
 struct dPa_name {
     static DUSK_CONST char* getName(u32 i_id);
 
-    static u16 j_o_id[5];
-    static u16 s_o_id[14];
-    static DUSK_CONST char* jpaName[];
+    static DUSK_GAME_DATA u16 j_o_id[5];
+    static DUSK_GAME_DATA u16 s_o_id[14];
+    static DUSK_GAME_DATA DUSK_CONST char* jpaName[];
 };
 
 // enum names made up based on debug strings
diff --git a/include/d/d_resorce.h b/include/d/d_resorce.h
index b70d2d5452..3330ff5b3d 100644
--- a/include/d/d_resorce.h
+++ b/include/d/d_resorce.h
@@ -51,7 +51,6 @@ public:
     static const int NAME_MAX = 9;
 #endif
 
-private:
     /* 0x00 */ char mArchiveName[11];
     /* 0x0C */ u16 mCount;
     /* 0x10 */ mDoDvdThd_mountArchive_c* mDMCommand;
diff --git a/include/d/d_s_name.h b/include/d/d_s_name.h
index 72a44c02de..c32b4b903c 100644
--- a/include/d/d_s_name.h
+++ b/include/d/d_s_name.h
@@ -56,7 +56,6 @@ public:
     void tex_data_set();
     #endif
 
-private:
     #if VERSION == VERSION_GCN_PAL
     u8 field_0x1c4_pal[0x28];
     #endif
diff --git a/include/d/d_s_play.h b/include/d/d_s_play.h
index 45b60220b0..936f29b277 100644
--- a/include/d/d_s_play.h
+++ b/include/d/d_s_play.h
@@ -83,8 +83,8 @@ public:
     #endif
     static void setPauseTimer(s8 time) { nextPauseTimer = time; }
 
-    static s8 pauseTimer;
-    static s8 nextPauseTimer;
+    static DUSK_GAME_DATA s8 pauseTimer;
+    static DUSK_GAME_DATA s8 nextPauseTimer;
 
     #if DEBUG
     void onDebugPause() {
@@ -104,8 +104,8 @@ public:
     /* 0x1D4 */ u8 field_0x1d4;
 };
 
-extern dScnPly_env_HIO_c g_envHIO;
-extern dScnPly_reg_HIO_c g_regHIO;
+DUSK_GAME_EXTERN dScnPly_env_HIO_c g_envHIO;
+DUSK_GAME_EXTERN dScnPly_reg_HIO_c g_regHIO;
 
 #if DEBUG
 extern dScnPly_preset_HIO_c g_presetHIO;
diff --git a/include/d/d_save.h b/include/d/d_save.h
index fc54e541f4..ec10360034 100644
--- a/include/d/d_save.h
+++ b/include/d/d_save.h
@@ -8,7 +8,10 @@
 #include "d/d_item_data.h"
 #include "JSystem/JUtility/JUTAssert.h"
 #include "JSystem/JHostIO/JORReflexible.h"
-#include "dusk/endian.h"
+
+#if TARGET_PC
+#include "helpers/endian.h"
+#endif
 
 static const int DEFAULT_SELECT_ITEM_INDEX = 0;
 static const int MAX_SELECT_ITEM = 4;
@@ -494,7 +497,7 @@ public:
 #endif
     void setPlayerName(const char* i_name) {
 #if AVOID_UB
-        dusk::SafeStringCopyTruncate(mPlayerName, i_name);
+        SafeStringCopyTruncate(mPlayerName, i_name);
 #else
         strcpy(mPlayerName, i_name);
 #endif
@@ -506,7 +509,7 @@ public:
 #endif
     void setHorseName(const char* i_name) {
 #if AVOID_UB
-        dusk::SafeStringCopyTruncate(mHorseName, i_name);
+        SafeStringCopyTruncate(mHorseName, i_name);
 #else
         strcpy(mHorseName, i_name);
 #endif
@@ -594,7 +597,6 @@ public:
     dSv_player_info_c& getPlayerInfo() { return mPlayerInfo; }
     dSv_player_config_c& getConfig() { return mConfig; }
 
-private:
     /* 0x000 */ dSv_player_status_a_c mPlayerStatusA;
     /* 0x028 */ dSv_player_status_b_c mPlayerStatusB;
     /* 0x040 */ dSv_horse_place_c mHorsePlace;
@@ -892,7 +894,6 @@ public:
 
 class dSv_reserve_c {
 public:
-private:
     u8 unk[80];
 };
 
@@ -1049,7 +1050,7 @@ public:
 #else
     u16
 #endif
-    static saveBitLabels[822];
+    static DUSK_GAME_DATA saveBitLabels[822];
 };
 
 class dSv_event_tmp_flag_c {
@@ -1058,7 +1059,7 @@ public:
         #include "d/d_save_temp_bit_labels.inc"
     };
 
-    static u16 const tempBitLabels[185];
+    static DUSK_GAME_DATA u16 const tempBitLabels[185];
 };
 
 #endif /* D_SAVE_D_SAVE_H */
diff --git a/include/d/d_save_HIO.h b/include/d/d_save_HIO.h
index e149f7fcb9..f7d4770e08 100644
--- a/include/d/d_save_HIO.h
+++ b/include/d/d_save_HIO.h
@@ -10,7 +10,6 @@ public:
 
     virtual ~dSvBit_childTransformHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 WF[4];
     /* 0x09 */ u8 field_0x9[4];
@@ -23,7 +22,6 @@ public:
 
     virtual ~dSvBit_childDarknessHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 TW[6];
     /* 0x0B */ u8 field_0xB[6];
@@ -36,7 +34,6 @@ public:
 
     virtual ~dSvBit_childOtherHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 mDropNum;
     /* 0x06 */ u8 field_0x6;
@@ -51,7 +48,6 @@ public:
 
     virtual ~dSvBit_childTbPerfectionHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x40];
     /* 0x45 */ u8 field_0x45[0x40];
@@ -64,7 +60,6 @@ public:
         mPerfectSave.init();
     }
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x08 */ dSvBit_childTbPerfectionHIO_c mPerfectSave;
 };
@@ -76,7 +71,6 @@ public:
 
     virtual ~dSvBit_childSwZoneHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ bool field_0x5[0x20];
     /* 0x25 */ bool field_0x25[0x20];
@@ -89,7 +83,6 @@ public:
 
     virtual ~dSvBit_childSwPerfectionHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x80];
     /* 0x85 */ u8 field_0x85[0x80];
@@ -102,7 +95,6 @@ public:
 
     virtual ~dSvBit_childSwOneZoneHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ bool field_0x5[0x10];
     /* 0x15 */ bool field_0x15[0x10];
@@ -115,7 +107,6 @@ public:
 
     virtual ~dSvBit_childSwDungeonHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x40];
     /* 0x45 */ u8 field_0x45[0x40];
@@ -131,7 +122,6 @@ public:
         field_0x1e0.init();
     }
 
-private:
     /* 0x004 */ u8 field_0x4;
     /* 0x008 */ dSvBit_childSwPerfectionHIO_c field_0x8;
     /* 0x110 */ dSvBit_childSwDungeonHIO_c field_0x110;
@@ -146,7 +136,6 @@ public:
 
     virtual ~dSvBit_childItZoneHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x20];
     /* 0x25 */ u8 field_0x25[0x20];
@@ -159,7 +148,6 @@ public:
 
     virtual ~dSvBit_childItPerfectionHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x20];
     /* 0x25 */ u8 field_0x25[0x20];
@@ -172,7 +160,6 @@ public:
 
     virtual ~dSvBit_childItOneZoneHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x10];
     /* 0x15 */ u8 field_0x15[0x10];
@@ -185,7 +172,6 @@ public:
 
     virtual ~dSvBit_childItDungeonHIO_c() {}
 
-private:
     /* 0x04 */ u8 field_0x4;
     /* 0x05 */ u8 field_0x5[0x80];
     /* 0x85 */ u8 field_0x85[0x80];
@@ -201,7 +187,6 @@ public:
         mOneZoneSave.init();
     }
 
-private:
     /* 0x004 */ u8 field_0x4;
     /* 0x008 */ dSvBit_childItPerfectionHIO_c mFullSave;
     /* 0x050 */ dSvBit_childItDungeonHIO_c mDungeonSave;
@@ -229,6 +214,6 @@ public:
 
 STATIC_ASSERT(sizeof(dSvBit_HIO_c) == 0x4A0);
 
-extern dSvBit_HIO_c g_save_bit_HIO;
+DUSK_GAME_EXTERN dSvBit_HIO_c g_save_bit_HIO;
 
 #endif /* D_SAVE_D_SAVE_HIO_H */
diff --git a/include/d/d_select_cursor.h b/include/d/d_select_cursor.h
index e98db19731..766463b5b3 100644
--- a/include/d/d_select_cursor.h
+++ b/include/d/d_select_cursor.h
@@ -66,7 +66,6 @@ public:
     void onPlayAllAnime() { field_0xb4 = 0xff; }
     void offPlayAllAnime() { field_0xb4 = 0; }
 
-private:
     /* 0x04 */ J2DScreen* mpScreen;
     /* 0x08 */ J2DPane* mpPane;
     /* 0x0C */ dSelect_icon_c* mpSelectIcon;
diff --git a/include/d/d_shop_item_ctrl.h b/include/d/d_shop_item_ctrl.h
index 9016be18ea..61ed325241 100644
--- a/include/d/d_shop_item_ctrl.h
+++ b/include/d/d_shop_item_ctrl.h
@@ -18,7 +18,6 @@ public:
     void setMessageIndex(int i, u16 messageIndex) { mMessageIndex[i] = messageIndex; }
     u16 getMessageIndex(int i) { return mMessageIndex[i]; }
 
-private:
     /* 0x04 */ u32 mItemIndex[7];
     /* 0x20 */ u16 mMessageIndex[7];
 };
diff --git a/include/d/d_simple_model.h b/include/d/d_simple_model.h
index 25b9e6e2d1..e87462c318 100644
--- a/include/d/d_simple_model.h
+++ b/include/d/d_simple_model.h
@@ -36,7 +36,6 @@ public:
     void setIdx(u8 idx) { this->idx = idx; }
 #endif
 
-private:
     /* 0x00 */ JKRSolidHeap* mpHeap;
     /* 0x04 */ J3DModel* mpModel;
     /* 0x08 */ int mCreateNum;
@@ -59,7 +58,6 @@ public:
 
     virtual ~dSmplMdl_draw_c();
 
-private:
     /* 0x04 */ diff_model_c mModel[8];
     /* 0xA4 */ int mListCount;
     /* 0xA8 */ modelList_c mList[500];
diff --git a/include/d/d_stage.h b/include/d/d_stage.h
index 83a1c808fd..fb8fd3124b 100644
--- a/include/d/d_stage.h
+++ b/include/d/d_stage.h
@@ -4,10 +4,14 @@
 #include "SSystem/SComponent/c_lib.h"
 #include "d/d_kankyo.h"
 #include "d/d_kankyo_data.h"
-#include "dusk/offset_ptr.h"
 #include "f_op/f_op_actor_mng.h"
 #include "global.h"
+
+#if TARGET_PC
+#include "helpers/offset_ptr.h"
+
 #include "os_report.h"
+#endif
 
 enum StageType {
     /* 0x0 */ ST_FIELD,
@@ -547,7 +551,6 @@ public:
     /* vt[91] */ virtual void setElst(dStage_Elst_c*) = 0;
     /* vt[92] */ virtual dStage_Elst_c* getElst(void) = 0;
 
-private:
     /* 0x04 */ s8 mRoomNo;
 };
 
@@ -1237,20 +1240,20 @@ public:
 
     static const int MEMORY_BLOCK_MAX = 19;
 
-    static JKRExpHeap* mMemoryBlock[MEMORY_BLOCK_MAX];
-    static char mArcBank[32][10];
-    static dStage_roomStatus_c mStatus[0x40];
-    static char mDemoArcName[10];
-    static fpc_ProcID mProcID;
-    static dStage_bankName* mArcBankName;
-    static dStage_bankData* mArcBankData;
-    static roomDzs_c m_roomDzs;
-    static s8 mStayNo;
-    static s8 mOldStayNo;
-    static s8 mNextStayNo;
-    static u8 m_time_pass;
-    static u8 mNoChangeRoom;
-    static s8 mRoomReadId;
+    static DUSK_GAME_DATA JKRExpHeap* mMemoryBlock[MEMORY_BLOCK_MAX];
+    static DUSK_GAME_DATA char mArcBank[32][10];
+    static DUSK_GAME_DATA dStage_roomStatus_c mStatus[0x40];
+    static DUSK_GAME_DATA char mDemoArcName[10];
+    static DUSK_GAME_DATA fpc_ProcID mProcID;
+    static DUSK_GAME_DATA dStage_bankName* mArcBankName;
+    static DUSK_GAME_DATA dStage_bankData* mArcBankData;
+    static DUSK_GAME_DATA roomDzs_c m_roomDzs;
+    static DUSK_GAME_DATA s8 mStayNo;
+    static DUSK_GAME_DATA s8 mOldStayNo;
+    static DUSK_GAME_DATA s8 mNextStayNo;
+    static DUSK_GAME_DATA u8 m_time_pass;
+    static DUSK_GAME_DATA u8 mNoChangeRoom;
+    static DUSK_GAME_DATA s8 mRoomReadId;
 
     #if DEBUG
     static void onNoArcBank() {
@@ -1261,7 +1264,6 @@ public:
     static u8 mNoArcBank;
     #endif
 
-private:
     /* 0x0 */ u8 field_0x0[4];
 };
 
@@ -1276,7 +1278,6 @@ public:
     s8 getDarkArea() const { return mDarkArea; }
     void setDarkArea(s8 darkArea) { mDarkArea = darkArea; }
 
-private:
     /* 0x0 */ char mName[8];
     /* 0x8 */ s16 mPoint;
     /* 0xA */ s8 mRoomNo;
@@ -1291,12 +1292,12 @@ public:
     }
     void set(const char*, s8, s16, s8, s8, u8);
     void offEnable() { enabled = 0; }
+    void onEnable() { enabled = 1; }
     BOOL isEnable() const { return enabled; }
     s8 getWipe() const { return wipe; }
     u8 getWipeSpeed() const { return wipe_speed; }
     dStage_startStage_c* getStartStage() { return this; }
 
-private:
     s8 enabled;
     s8 wipe;
     u8 wipe_speed;
@@ -1351,6 +1352,9 @@ enum dStage_SaveTbl {
 
 const char* dStage_getName2(s16, s8);
 dStage_objectNameInf* dStage_searchName(const char*);
+#if TARGET_PC
+dStage_objectNameInf* dStage_searchNameCI(const char*);
+#endif
 static int dStage_stageKeepTresureInit(dStage_dt_c*, void*, int, void*);
 static int dStage_filiInfo2Init(dStage_dt_c*, void*, int, void*);
 static int dStage_mapPathInitCommonLayer(dStage_dt_c*, void*, int, void*);
diff --git a/include/d/d_timer.h b/include/d/d_timer.h
index 9d3bd7ce1f..de145650ac 100644
--- a/include/d/d_timer.h
+++ b/include/d/d_timer.h
@@ -52,7 +52,7 @@ public:
     s32 createStart(u16);
     bool checkStartAnimeEnd();
     void playBckAnimation(f32);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
     bool isLeadByte(int);
 #endif
     void drawPikari(int);
@@ -77,7 +77,6 @@ public:
         mTimerTransY = y;
     }
 
-private:
     /* 0x004 */ J2DScreen* mpScreen;
     /* 0x008 */ J2DScreen* mpGetInScreen;
     /* 0x00C */ J2DAnmTransform* mpGetInBck;
@@ -145,7 +144,6 @@ public:
 
     u8 isReadyFlag() { return m_is_ready; }
 
-private:
     /* 0x0FC */ dDlst_TimerScrnDraw_c* mp_tm_scrn;
     /* 0x100 */ JKRExpHeap* mp_heap;
     /* 0x104 */ u8 field_0x104[4];
diff --git a/include/d/d_tresure.h b/include/d/d_tresure.h
index 236e2690c6..4335a6a215 100644
--- a/include/d/d_tresure.h
+++ b/include/d/d_tresure.h
@@ -2,7 +2,10 @@
 #define D_D_TRESURE_H
 
 #include <mtx.h>
-#include "dusk/offset_ptr.h"
+
+#if TARGET_PC
+#include "helpers/offset_ptr.h"
+#endif
 
 class dTres_c {
 public:
@@ -113,10 +116,10 @@ public:
         return mTypeGroupData;
     }
 
-    static u8 const typeToTypeGroup[17][2];
-    static type_group_list mTypeGroupListAll[17];
-    static typeGroupData_c* mTypeGroupData;
-    static u16 mNum;
+    static DUSK_GAME_DATA u8 const typeToTypeGroup[17][2];
+    static DUSK_GAME_DATA type_group_list mTypeGroupListAll[17];
+    static DUSK_GAME_DATA typeGroupData_c* mTypeGroupData;
+    static DUSK_GAME_DATA u16 mNum;
 
     static void setNpcYkmPosition(int param_1, Vec* param_2) {
         setPosition(param_1, 13, param_2, -1);
diff --git a/include/d/d_vibration.h b/include/d/d_vibration.h
index ee87f7dcc4..6e886a314b 100644
--- a/include/d/d_vibration.h
+++ b/include/d/d_vibration.h
@@ -89,12 +89,11 @@ public:
     int testShake();
     #endif
 
-    static const vib_pattern MS_patt[VIBMODE_S_MAX];
-    static const vib_pattern CS_patt[VIBMODE_S_MAX];
-    static const vib_pattern MQ_patt[VIBMODE_Q_MAX];
-    static const vib_pattern CQ_patt[VIBMODE_Q_MAX];
+    static DUSK_GAME_DATA const vib_pattern MS_patt[VIBMODE_S_MAX];
+    static DUSK_GAME_DATA const vib_pattern CS_patt[VIBMODE_S_MAX];
+    static DUSK_GAME_DATA const vib_pattern MQ_patt[VIBMODE_Q_MAX];
+    static DUSK_GAME_DATA const vib_pattern CQ_patt[VIBMODE_Q_MAX];
 
-private:
 #if DEBUG
     /* 0x00 */ dVibTest_c mVibTest;
 #elif PARTIAL_DEBUG
@@ -133,7 +132,7 @@ private:
     /* 0x8C */ s32 mMode;
 };  // Size: 0x90
 
-extern const char* shock_names[VIBMODE_S_MAX];
-extern const char* quake_names[VIBMODE_Q_MAX];
+DUSK_GAME_EXTERN const char* shock_names[VIBMODE_S_MAX];
+DUSK_GAME_EXTERN const char* quake_names[VIBMODE_Q_MAX];
 
 #endif /* D_D_VIBRATION_H */
diff --git a/include/d/dolzel.h b/include/d/dolzel.h
index d51eb22372..d4f53c842d 100644
--- a/include/d/dolzel.h
+++ b/include/d/dolzel.h
@@ -8,7 +8,7 @@
 #endif
 
 #ifndef __MWERKS__
-#include "dusk/math.h"
+#include "helpers/math.h"
 #endif
 
 #endif // dolzel.h
diff --git a/include/dusk/app_info.hpp b/include/dusk/app_info.hpp
deleted file mode 100644
index e08fe680d9..0000000000
--- a/include/dusk/app_info.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef DUSK_APPNAME_HPP
-#define DUSK_APPNAME_HPP
-
-namespace dusk {
-    /**
-     * \brief The internal application name for the game.
-     *
-     * This gets used for file paths and such, and cannot be changed!
-     */
-    constexpr auto AppName = "Dusklight";
-
-    /**
-     * Previous AppName to migrate data from.
-     */
-    constexpr auto LegacyAppName = "Dusk";
-
-    /**
-     * \brief The internal organization name for the game.
-     *
-     * This gets used for file paths and such, and cannot be changed!
-     */
-    constexpr auto OrgName = "TwilitRealm";
-}
-
-#endif  // DUSK_APPNAME_HPP
diff --git a/include/dusk/crash_handler.h b/include/dusk/crash_handler.h
deleted file mode 100644
index c2cfadf5d1..0000000000
--- a/include/dusk/crash_handler.h
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-namespace dusk::crash_handler {
-
-void install();
-
-}  // namespace dusk::crash_handler
diff --git a/include/dusk/crash_reporting.h b/include/dusk/crash_reporting.h
deleted file mode 100644
index c42079a6f6..0000000000
--- a/include/dusk/crash_reporting.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#pragma once
-
-namespace dusk::crash_reporting {
-
-enum class Consent {
-    Unavailable,
-    Unknown,
-    Given,
-    Revoked,
-};
-
-void initialize();
-void shutdown();
-Consent get_consent();
-void set_consent(bool enabled);
-
-}  // namespace dusk::crash_reporting
diff --git a/include/dusk/frame_interpolation.h b/include/dusk/frame_interpolation.h
deleted file mode 100644
index 5f2f3d134b..0000000000
--- a/include/dusk/frame_interpolation.h
+++ /dev/null
@@ -1,54 +0,0 @@
-#pragma once
-
-#include <dolphin/mtx.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#include "settings.h"
-
-class camera_process_class;
-class view_class;
-
-#ifdef __cplusplus
-namespace dusk {
-namespace frame_interp {
-
-void ensure_initialized();
-
-void begin_record();
-void end_record();
-void begin_sim_tick();
-uint64_t sim_tick_seq();
-void begin_frame(FrameInterpMode mode, bool is_sim_frame, float step);
-void interpolate();
-float get_interpolation_step();
-
-void request_presentation_sync();
-bool presentation_sync_active();
-
-bool is_enabled();
-
-// TODO: These should be phased out as UI is progressively updated to use game_clock
-void set_ui_tick_pending(bool value);
-bool get_ui_tick_pending();
-
-bool is_sim_frame();
-
-void record_camera(::camera_process_class* cam, int camera_id);
-void interp_view(::view_class* view);
-void record_final_mtx(Mtx m, const void *key);
-void record_final_mtx(Mtx m);
-
-bool lookup_replacement(const void* key, Mtx out);
-bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out);
-
-typedef void (*InterpolationCallBack)(bool isSimFrame, void* pUserWork);
-// call on a sim tick, will get called during presentation
-void add_interpolation_callback(InterpolationCallBack pCallBack, void* pUserWork);
-
-void begin_presentation_camera();
-void end_presentation_camera();
-
-}  // namespace frame_interp
-}  // namespace dusk
-#endif
diff --git a/include/dusk/game_clock.h b/include/dusk/game_clock.h
deleted file mode 100644
index 8bb277e070..0000000000
--- a/include/dusk/game_clock.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-
-namespace dusk::game_clock {
-
-void ensure_initialized();
-void reset_frame_timer();
-
-constexpr float sim_pace() { return 1.0f / 30.0f; }
-constexpr float period_for_original_frames(float frame_count) { return frame_count * sim_pace(); }
-constexpr float ui_maximum_dt() { return 0.05f; }
-constexpr float ui_initial_dt() { return 1.0f / 60.0f; }
-
-struct MainLoopPacer {
-    float presentation_dt_seconds;
-    bool is_interpolating;
-    int sim_ticks_to_run;
-    float sim_pace;
-};
-
-MainLoopPacer advance_main_loop();
-void commit_sim_tick();
-float sample_interpolation_step();
-
-float consume_interval(const void* consumer);
-
-} // namespace dusk::game_clock
diff --git a/include/dusk/imgui.h b/include/dusk/imgui.h
deleted file mode 100644
index 5c761fb026..0000000000
--- a/include/dusk/imgui.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef _SRC_IMGUI_H_
-#define _SRC_IMGUI_H_
-
-#include <aurora/aurora.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-    void imgui_main(const AuroraInfo* info);
-    void frame_limiter();
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/include/dusk/logging.h b/include/dusk/logging.h
deleted file mode 100644
index 54350af4bf..0000000000
--- a/include/dusk/logging.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef DUSK_LOGGING_H
-#define DUSK_LOGGING_H
-
-#include <aurora/aurora.h>
-#include <aurora/lib/logging.hpp>
-
-#include <filesystem>
-
-void aurora_log_callback(AuroraLogLevel level, const char* module, const char* message, unsigned int len);
-
-namespace dusk {
-    void InitializeFileLogging(const std::filesystem::path& configDir, AuroraLogLevel logLevel);
-    void ShutdownFileLogging();
-    const char* GetLogFilePath();
-    int GetLogFileDescriptor();
-    void SendToStubLog(AuroraLogLevel level, const char* module, const char* message);
-}
-
-extern bool StubLogEnabled;
-
-extern aurora::Module DuskLog;
-
-#ifndef NDEBUG
-#define STUB_LOG() DuskLog.debug("{} is a stub", __FUNCTION__)
-#else
-#define STUB_LOG()
-#endif
-
-#if TARGET_PC
-#define STUB_RET(...) \
-    STUB_LOG(); \
-    return __VA_ARGS__;
-
-#else
-#define STUB_RET() (void)0
-#endif
-
-#endif
diff --git a/include/dusk/profiling.hpp b/include/dusk/profiling.hpp
deleted file mode 100644
index 82dab45216..0000000000
--- a/include/dusk/profiling.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-#if defined(__has_include)
-#if __has_include(<tracy/Tracy.hpp>)
-#include <tracy/Tracy.hpp>
-#endif
-#endif
-
-#ifndef ZoneScoped
-#define ZoneScoped
-#define ZoneScopedN(name)
-#endif
diff --git a/include/dusk/speedrun.h b/include/dusk/speedrun.h
deleted file mode 100644
index c1a92e4a50..0000000000
--- a/include/dusk/speedrun.h
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-#include <aurora/aurora.h>
-
-namespace dusk {
-
-struct SpeedrunInfo {
-    void startRun() {
-        m_isRunStarted = true;
-        m_startTimestamp = OSGetTime();
-    }
-
-    void stopRun() {
-        m_isRunStarted = false;
-        m_endTimestamp = OSGetTime() - m_startTimestamp;
-    }
-
-    void reset() {
-        m_isRunStarted = false;
-        m_startTimestamp = 0;
-        m_endTimestamp = 0;
-        m_isPauseIGT = false;
-        m_loadStartTimestamp = 0;
-        m_totalLoadTime = 0;
-        m_igtTimer = 0;
-    }
-
-    bool m_isRunStarted = false;
-    OSTime m_startTimestamp = 0;
-    OSTime m_endTimestamp = 0;
-
-    bool m_isPauseIGT = false;
-    OSTime m_loadStartTimestamp = 0;
-    OSTime m_totalLoadTime = 0;
-    OSTime m_igtTimer = 0;
-};
-
-extern SpeedrunInfo m_speedrunInfo;
-
-void resetForSpeedrunMode();
-
-}  // namespace dusk
diff --git a/include/f_ap/f_ap_game.h b/include/f_ap/f_ap_game.h
index fca2e70705..aa2c9dbd9d 100644
--- a/include/f_ap/f_ap_game.h
+++ b/include/f_ap/f_ap_game.h
@@ -75,7 +75,7 @@ public:
 
     static u8 mCaptureMagnification;
 
-    static u8 mCaptureScreenDivH;
+    static DUSK_GAME_DATA u8 mCaptureScreenDivH;
     static u8 mCaptureScreenDivV;
 
     static u8 mPackArchiveMode;
@@ -115,7 +115,7 @@ public:
     /* 0x3E */ u8 mBackgroundAlpha;
 };  // Size: 0x40
 
-extern fapGm_HIO_c g_HIO;
+DUSK_GAME_EXTERN fapGm_HIO_c g_HIO;
 
 inline void fapGmHIO_offMenu() {
     g_HIO.mDisplayPrint &= (u8)~2;
diff --git a/include/f_op/f_op_actor.h b/include/f_op/f_op_actor.h
index ed0126eefa..2ac262ced1 100644
--- a/include/f_op/f_op_actor.h
+++ b/include/f_op/f_op_actor.h
@@ -318,6 +318,11 @@ public:
     /* 0x566 */ s8 field_0x566;
     /* 0x567 */ s8 field_0x567;
 
+#if TARGET_PC
+    u32 mItemGiveTag;
+    u8 mItemGiveOriginalNo;
+#endif
+
 #if !__MWERKS__
     s8 actor_last_base_field;
 #endif
@@ -332,7 +337,7 @@ public:
     static u32 getStopStatus() { return stopStatus; }
     static void setStopStatus(u32 status) { stopStatus = status; }
 
-    static u32 stopStatus;
+    static DUSK_GAME_DATA u32 stopStatus;
 };  // Size: 0x568
 
 STATIC_ASSERT(sizeof(fopAc_ac_c) == 0x568);
@@ -431,6 +436,6 @@ public:
 
 BOOL fopAc_IsActor(void* i_actor);
 
-extern actor_method_class g_fopAc_Method;
+DUSK_GAME_EXTERN actor_method_class g_fopAc_Method;
 
 #endif
diff --git a/include/f_op/f_op_actor_mng.h b/include/f_op/f_op_actor_mng.h
index 76a9f8517c..29dfac1389 100644
--- a/include/f_op/f_op_actor_mng.h
+++ b/include/f_op/f_op_actor_mng.h
@@ -12,9 +12,10 @@
 #include "f_pc/f_pc_manager.h"
 #include "m_Do/m_Do_hostIO.h"
 #include "SSystem/SComponent/c_phase.h"
-#include "dusk/endian_ssystem.h"
 
-#if !__MWERKS__
+#if TARGET_PC
+#include "helpers/endian_ssystem.h"
+
 // mwerks compiler makes value initialization act like default initialization so we need
 // to be explicit about default initialization in modern compilers
 #define fopAcM_ct_placement(ptr, ClassName) JKR_NEW_ARGS (ptr) ClassName
@@ -23,13 +24,10 @@
 #endif
 
 #define fopAcM_ct(ptr, ClassName)                                           \
-    if ((ptr)->layer_tag.layer == NULL) { OSPanic(__FILE__, __LINE__, "UH OH"); } \
     if (!fopAcM_CheckCondition(ptr, fopAcCnd_INIT_e)) {                     \
         fopAcM_ct_placement(ptr, ClassName);                                \
         fopAcM_OnCondition(ptr, fopAcCnd_INIT_e);                           \
-    } \
-    if ((ptr)->layer_tag.layer == NULL) { OSPanic(__FILE__, __LINE__, "Oh come on"); }
-
+    }
 
 #define fopAcM_RegisterDeleteID(i_this, actor_name_str)                     \
     ("Delete -> " actor_name_str "(id=%d)\n", fopAcM_GetID(i_this))
@@ -50,14 +48,14 @@ class cM3dGPla;
 s8 dComIfGp_getReverb(int roomNo);
 
 namespace fopAcM {
-extern u8 HeapAdjustEntry;
-extern u8 HeapAdjustUnk;
-extern u8 HeapAdjustVerbose;
-extern u8 HeapAdjustQuiet;
-extern u8 HeapDummyCreate;
-extern u8 HeapDummyCheck;
-extern u8 HeapSkipMargin;
-extern int HeapAdjustMargin;
+DUSK_GAME_EXTERN u8 HeapAdjustEntry;
+DUSK_GAME_EXTERN u8 HeapAdjustUnk;
+DUSK_GAME_EXTERN u8 HeapAdjustVerbose;
+DUSK_GAME_EXTERN u8 HeapAdjustQuiet;
+DUSK_GAME_EXTERN u8 HeapDummyCreate;
+DUSK_GAME_EXTERN u8 HeapDummyCheck;
+DUSK_GAME_EXTERN u8 HeapSkipMargin;
+DUSK_GAME_EXTERN int HeapAdjustMargin;
 }  // namespace fopAcM
 
 struct fopAcM_prmBase_class {
@@ -79,6 +77,10 @@ struct fopAcM_prm_class {
     /* 0x1C */ fpc_ProcID parent_id;
     /* 0x20 */ s8 argument;
     /* 0x21 */ s8 room_no;
+#if TARGET_PC
+    u32 mItemGiveTag;
+    u8 mItemGiveOriginalNo;
+#endif
 };
 
 struct fopAcM_search4ev_prm {
@@ -516,8 +518,9 @@ s32 fopAcM_SearchByName(s16 i_procName, fopAc_ac_c** i_outActor);
 fopAcM_prm_class* fopAcM_CreateAppend();
 
 fopAcM_prm_class* createAppend(u16 i_setId, u32 i_parameters, const cXyz* i_pos, int i_roomNo,
-                               const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
-                               fpc_ProcID i_parentId);
+    const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
+    fpc_ProcID i_parentId IF_DUSK_ARG(u32 i_itemGiveTag = 0)
+        IF_DUSK_ARG(u8 i_itemOriginalNo = 0xFF));
 
 void fopAcM_Log(fopAc_ac_c const* i_actor, char const* i_message);
 
@@ -526,19 +529,22 @@ s32 fopAcM_delete(fopAc_ac_c* i_actor);
 s32 fopAcM_delete(fpc_ProcID i_actorID);
 
 fpc_ProcID fopAcM_create(s16 i_procName, u16 i_setId, u32 i_parameters, const cXyz* i_pos,
-                         int i_roomNo, const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
-                         createFunc i_createFunc);
+    int i_roomNo, const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
+    createFunc i_createFunc IF_DUSK_ARG(u32 i_itemGiveTag = 0)
+        IF_DUSK_ARG(u8 i_itemOriginalNo = 0xFF));
 
 fpc_ProcID fopAcM_create(s16 i_procName, u32 i_parameters, const cXyz* i_pos, int i_roomNo,
-                         const csXyz* i_angle, const cXyz* i_scale, s8 i_argument);
+    const csXyz* i_angle, const cXyz* i_scale, s8 i_argument IF_DUSK_ARG(u32 i_itemGiveTag = 0)
+        IF_DUSK_ARG(u8 i_itemOriginalNo = 0xFF));
 
 inline fpc_ProcID fopAcM_Create(s16 i_procName, createFunc i_createFunc, void* params) {
     return fpcM_Create(i_procName, i_createFunc,params);
 }
 
 fopAc_ac_c* fopAcM_fastCreate(s16 i_procName, u32 i_parameters, const cXyz* i_pos, int i_roomNo,
-                              const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
-                              createFunc i_createFunc, void* i_createFuncData);
+    const csXyz* i_angle, const cXyz* i_scale, s8 i_argument, createFunc i_createFunc,
+    void* i_createFuncData IF_DUSK_ARG(u32 i_itemGiveTag = 0)
+        IF_DUSK_ARG(u8 i_itemOriginalNo = 0xFF));
 
 fopAc_ac_c* fopAcM_fastCreate(const char* i_actorname, u32 i_parameters, const cXyz* i_pos,
                               int i_roomNo, const csXyz* i_angle, const cXyz* i_scale,
@@ -623,11 +629,11 @@ fopAc_ac_c* fopAcM_getItemEventPartner(const fopAc_ac_c*);
 fopAc_ac_c* fopAcM_getEventPartner(const fopAc_ac_c*);
 
 fpc_ProcID fopAcM_createItemForPresentDemo(cXyz const* i_pos, int i_itemNo, u8 param_2,
-                                           int i_itemBitNo, int i_roomNo, csXyz const* i_angle,
-                                           cXyz const* i_scale);
+    int i_itemBitNo, int i_roomNo, csXyz const* i_angle,
+    cXyz const* i_scale IF_DUSK_ARG(u32 i_itemGiveTag = 0));
 
 fpc_ProcID fopAcM_createItemForTrBoxDemo(cXyz const* i_pos, int i_itemNo, int i_itemBitNo,
-                                         int i_roomNo, csXyz const* i_angle, cXyz const* i_scale);
+    int i_roomNo, csXyz const* i_angle, cXyz const* i_scale IF_DUSK_ARG(u32 i_itemGiveTag = 0));
 
 u8 fopAcM_getItemNoFromTableNo(u8 i_tableNo);
 
@@ -641,11 +647,12 @@ fpc_ProcID fopAcM_createItemFromTable(cXyz const* i_pos, int i_tableNo, int i_it
                                       bool i_createDirect);
 
 fpc_ProcID fopAcM_createDemoItem(const cXyz* i_pos, int i_itemNo, int i_itemBitNo,
-                                 const csXyz* i_angle, int i_roomNo, const cXyz* scale, u8 param_7);
+    const csXyz* i_angle, int i_roomNo, const cXyz* scale,
+    u8 param_7 IF_DUSK_ARG(u32 i_itemGiveTag = 0));
 
 fpc_ProcID fopAcM_createItemForBoss(const cXyz* i_pos, int i_itemNo, int i_roomNo,
-                                    const csXyz* i_angle, const cXyz* i_scale, f32 i_speedF,
-                                    f32 i_speedY, int param_8);
+    const csXyz* i_angle, const cXyz* i_scale, f32 i_speedF, f32 i_speedY,
+    int param_8 IF_DUSK_ARG(const char* i_itemCheckName = NULL));
 
 fpc_ProcID fopAcM_createItemForMidBoss(const cXyz* i_pos, int i_itemNo, int i_roomNo,
                                        const csXyz* i_angle, const cXyz* i_scale, int param_6,
@@ -826,8 +833,8 @@ BOOL fopAcM_getNameString(const fopAc_ac_c*, char*);
 
 inline void fopAcM_SetStatusMap(fopAc_ac_c*, u32) {}
 
-extern cull_box l_cullSizeBox[fopAc_CULLBOX_MAX_e];
-extern cull_sphere l_cullSizeSphere[fopAc_CULLSPHERE_MAX_e];
+DUSK_GAME_EXTERN cull_box l_cullSizeBox[fopAc_CULLBOX_MAX_e];
+DUSK_GAME_EXTERN cull_sphere l_cullSizeSphere[fopAc_CULLSPHERE_MAX_e];
 
 class fopAcM_lc_c {
 public:
@@ -854,7 +861,7 @@ public:
         return cBgW_CheckBGround(poly.mNormal.y);
     }
 
-    static dBgS_ObjLinChk mLineCheck;
+    static DUSK_GAME_DATA dBgS_ObjLinChk mLineCheck;
 };
 
 class dBgS_RoofChk;
@@ -864,16 +871,16 @@ public:
     static f32 getRoofY() { return mRoofY; }
     static bool roofCheck(const cXyz*);
 
-    static dBgS_ObjRoofChk mRoofCheck;
-    static f32 mRoofY;
+    static DUSK_GAME_DATA dBgS_ObjRoofChk mRoofCheck;
+    static DUSK_GAME_DATA f32 mRoofY;
 };
 
 class dBgS_GndChk;
 class fopAcM_gc_c {
 public:
     static bool gndCheck(const cXyz*);
-    static dBgS_ObjGndChk mGndCheck;
-    static f32 mGroundY;
+    static DUSK_GAME_DATA dBgS_ObjGndChk mGndCheck;
+    static DUSK_GAME_DATA f32 mGroundY;
 
     static bool getTriPla(cM3dGPla* i_plane) {
         return dComIfG_Bgsp().GetTriPla(mGndCheck, i_plane);
@@ -900,8 +907,8 @@ public:
     static int getPolyAtt0() { return dComIfG_Bgsp().GetPolyAtt0(mWaterCheck); }
 
     static bool waterCheck(const cXyz*);
-    static dBgS_WtrChk mWaterCheck;
-    static f32 mWaterY;
+    static DUSK_GAME_DATA dBgS_WtrChk mWaterCheck;
+    static DUSK_GAME_DATA f32 mWaterY;
 };
 
 #endif
diff --git a/include/f_op/f_op_actor_tag.h b/include/f_op/f_op_actor_tag.h
index a354178a8b..dfad5b5b83 100644
--- a/include/f_op/f_op_actor_tag.h
+++ b/include/f_op/f_op_actor_tag.h
@@ -7,6 +7,6 @@ void fopAcTg_ActorQTo(create_tag_class* i_createTag);
 int fopAcTg_Init(create_tag_class* i_createTag, void* i_data);
 int fopAcTg_ToActorQ(create_tag_class* i_createTag);
 
-extern node_list_class g_fopAcTg_Queue;
+DUSK_GAME_EXTERN node_list_class g_fopAcTg_Queue;
 
 #endif
diff --git a/include/f_op/f_op_camera.h b/include/f_op/f_op_camera.h
index 584bff29d4..30bcd3fe60 100644
--- a/include/f_op/f_op_camera.h
+++ b/include/f_op/f_op_camera.h
@@ -15,6 +15,6 @@ static s32 fopCam_Draw(camera_class* i_this);
 static int fopCam_Execute(camera_class* i_this);
 int fopCam_IsDelete(camera_class* i_this);
 
-extern leafdraw_method_class g_fopCam_Method;
+DUSK_GAME_EXTERN leafdraw_method_class g_fopCam_Method;
 
 #endif
diff --git a/include/f_op/f_op_draw_tag.h b/include/f_op/f_op_draw_tag.h
index 317cad1baf..1071616988 100644
--- a/include/f_op/f_op_draw_tag.h
+++ b/include/f_op/f_op_draw_tag.h
@@ -5,7 +5,7 @@
 
 typedef struct create_tag_class create_tag_class;
 
-extern node_lists_tree_class g_fopDwTg_Queue;
+DUSK_GAME_EXTERN node_lists_tree_class g_fopDwTg_Queue;
 
 void fopDwTg_DrawQTo(create_tag_class* i_createTag);
 void fopDwTg_CreateQueue();
diff --git a/include/f_op/f_op_kankyo.h b/include/f_op/f_op_kankyo.h
index 7741d6c09d..75833fe5ad 100644
--- a/include/f_op/f_op_kankyo.h
+++ b/include/f_op/f_op_kankyo.h
@@ -21,6 +21,6 @@ struct kankyo_process_profile_definition {
 
 BOOL fopKy_IsKankyo(void* i_this);
 
-extern leafdraw_method_class g_fopKy_Method;
+DUSK_GAME_EXTERN leafdraw_method_class g_fopKy_Method;
 
 #endif /* F_OP_F_OP_KANKYO_H */
diff --git a/include/f_op/f_op_msg.h b/include/f_op/f_op_msg.h
index 72a57b594f..1338732a4b 100644
--- a/include/f_op/f_op_msg.h
+++ b/include/f_op/f_op_msg.h
@@ -30,13 +30,13 @@ struct msg_class {
     /* 0xDC */ fopAc_ac_c* talk_actor;
     /* 0xE0 */ cXyz pos;
     /* 0xEC */ u32 msg_idx;
-    /* 0xF0 */ u32 field_0xf0;
+    /* 0xF0 */ u32 select_msg_idx;  // selection options message ID; 1000 = none
     /* 0xF4 */ u32 field_0xf4;
     /* 0xF8 */ u16 mode;
     /* 0xFA */ u8 select_idx;
 };  // Size: 0xFC
 
-extern leafdraw_method_class g_fopMsg_Method;
+DUSK_GAME_EXTERN leafdraw_method_class g_fopMsg_Method;
 
 namespace fopMsg {
     extern u8 MemCheck;
diff --git a/include/f_op/f_op_msg_mng.h b/include/f_op/f_op_msg_mng.h
index 330347fc18..35d0e28ea7 100644
--- a/include/f_op/f_op_msg_mng.h
+++ b/include/f_op/f_op_msg_mng.h
@@ -19,7 +19,7 @@ struct fopMsg_prm_class {
     /* 0x00 */ fopAc_ac_c* talk_actor;
     /* 0x04 */ cXyz pos;
     /* 0x10 */ u32 msg_idx;
-    /* 0x14 */ u32 field_0x14;
+    /* 0x14 */ u32 select_msg_idx;  // selection options message ID; 1000 = none
     /* 0x18 */ fpc_ProcID field_0x18;
 };  // Size: 0x1C
 
@@ -46,8 +46,8 @@ void fopMsgM_setMessageID(fpc_ProcID msg_id);
 void fopMsgM_destroyExpHeap(JKRExpHeap* i_heap);
 f32 fopMsgM_valueIncrease(int param_0, int param_1, u8 i_type);
 s32 fopMsgM_setStageLayer(void* i_process);
-fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, fopAc_ac_c* i_talkActor, u32 param_2);
-fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, u32 param_1);
+fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, fopAc_ac_c* i_talkActor, u32 i_selectMsgIdx);
+fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, u32 i_selectMsgIdx);
 fpc_ProcID fopMsgM_messageSetDemo(u32 i_msgidx);
 msg_class* fopMsgM_SearchByID(fpc_ProcID i_id);
 TEXT_SPAN fopMsgM_messageGet(TEXT_SPAN i_stringBuf, u32 i_msgId);
diff --git a/include/f_op/f_op_overlap.h b/include/f_op/f_op_overlap.h
index c639ff38e0..275b86fc40 100644
--- a/include/f_op/f_op_overlap.h
+++ b/include/f_op/f_op_overlap.h
@@ -18,6 +18,6 @@ struct overlap_process_profile_definition {
 
 static s32 fopOvlp_Draw(void* param_1);
 
-extern leafdraw_method_class g_fopOvlp_Method;
+DUSK_GAME_EXTERN leafdraw_method_class g_fopOvlp_Method;
 
 #endif
diff --git a/include/f_op/f_op_scene.h b/include/f_op/f_op_scene.h
index 0e736093f1..b7e182e890 100644
--- a/include/f_op/f_op_scene.h
+++ b/include/f_op/f_op_scene.h
@@ -24,6 +24,6 @@ public:
     /* 0x1B0 */ scene_tag_class scene_tag;
 };
 
-extern leafdraw_method_class g_fopScn_Method;
+DUSK_GAME_EXTERN leafdraw_method_class g_fopScn_Method;
 
 #endif
diff --git a/include/f_op/f_op_scene_tag.h b/include/f_op/f_op_scene_tag.h
index ad26ab3564..f4bb4ebad6 100644
--- a/include/f_op/f_op_scene_tag.h
+++ b/include/f_op/f_op_scene_tag.h
@@ -12,6 +12,6 @@ void fopScnTg_QueueTo(scene_tag_class* i_sceneTag);
 void fopScnTg_ToQueue(scene_tag_class* i_sceneTag);
 void fopScnTg_Init(scene_tag_class* i_sceneTag, void* i_data);
 
-extern node_list_class g_fopScnTg_SceneList;
+DUSK_GAME_EXTERN node_list_class g_fopScnTg_SceneList;
 
 #endif
diff --git a/include/f_op/f_op_view.h b/include/f_op/f_op_view.h
index a605923b2f..62c135fb68 100644
--- a/include/f_op/f_op_view.h
+++ b/include/f_op/f_op_view.h
@@ -56,6 +56,6 @@ struct view_class {
     /* 0x1E0 */ Mtx viewMtxNoTrans;
 };
 
-extern leafdraw_method_class g_fopVw_Method;
+DUSK_GAME_EXTERN leafdraw_method_class g_fopVw_Method;
 
 #endif
diff --git a/include/f_pc/f_pc_base.h b/include/f_pc/f_pc_base.h
index 23c7893b91..63c629e624 100644
--- a/include/f_pc/f_pc_base.h
+++ b/include/f_pc/f_pc_base.h
@@ -57,6 +57,6 @@ int fpcBs_Delete(base_process_class* i_proc);
 base_process_class* fpcBs_Create(s16 i_profname, fpc_ProcID i_procID, void* i_append);
 int fpcBs_SubCreate(base_process_class* i_proc);
 
-extern int g_fpcBs_type;
+DUSK_GAME_EXTERN int g_fpcBs_type;
 
 #endif
diff --git a/include/f_pc/f_pc_create_tag.h b/include/f_pc/f_pc_create_tag.h
index 45b1f2ea8b..4706b3862a 100644
--- a/include/f_pc/f_pc_create_tag.h
+++ b/include/f_pc/f_pc_create_tag.h
@@ -13,6 +13,6 @@ void fpcCtTg_ToCreateQ(create_tag* i_createTag);
 void fpcCtTg_CreateQTo(create_tag* i_createTag);
 int fpcCtTg_Init(create_tag* i_createTag, void* i_data);
 
-extern node_list_class g_fpcCtTg_Queue;
+DUSK_GAME_EXTERN node_list_class g_fpcCtTg_Queue;
 
 #endif
diff --git a/include/f_pc/f_pc_delete_tag.h b/include/f_pc/f_pc_delete_tag.h
index 57b049c2f2..1dd0cd728a 100644
--- a/include/f_pc/f_pc_delete_tag.h
+++ b/include/f_pc/f_pc_delete_tag.h
@@ -25,6 +25,6 @@ void fpcDtTg_DeleteQTo(delete_tag_class* i_deleteTag);
 int fpcDtTg_Do(delete_tag_class* i_deleteTag, delete_tag_func i_func);
 int fpcDtTg_Init(delete_tag_class* i_deleteTag, void* i_data);
 
-extern node_list_class g_fpcDtTg_Queue;
+DUSK_GAME_EXTERN node_list_class g_fpcDtTg_Queue;
 
 #endif
diff --git a/include/f_pc/f_pc_deletor.h b/include/f_pc/f_pc_deletor.h
index c0b7da0fc2..1667303fc4 100644
--- a/include/f_pc/f_pc_deletor.h
+++ b/include/f_pc/f_pc_deletor.h
@@ -7,6 +7,7 @@
 typedef struct base_process_class base_process_class;
 
 BOOL fpcDt_IsComplete();
+int fpcDt_deleteMethod(base_process_class* i_proc);
 int fpcDt_ToDeleteQ(base_process_class* i_proc);
 int fpcDt_ToQueue(base_process_class* i_proc);
 void fpcDt_Handler();
diff --git a/include/f_pc/f_pc_leaf.h b/include/f_pc/f_pc_leaf.h
index 2234fa87a5..99b176e73c 100644
--- a/include/f_pc/f_pc_leaf.h
+++ b/include/f_pc/f_pc_leaf.h
@@ -43,7 +43,7 @@ int fpcLf_IsDelete(leafdraw_class* i_leaf);
 int fpcLf_Delete(leafdraw_class* i_leaf);
 int fpcLf_Create(leafdraw_class* i_leaf);
 
-extern int g_fpcLf_type;
-extern leafdraw_method_class DUSK_CONST g_fpcLf_Method;
+DUSK_GAME_EXTERN int g_fpcLf_type;
+DUSK_GAME_EXTERN leafdraw_method_class DUSK_CONST g_fpcLf_Method;
 
 #endif
diff --git a/include/f_pc/f_pc_line.h b/include/f_pc/f_pc_line.h
index 47a8018792..4527653a90 100644
--- a/include/f_pc/f_pc_line.h
+++ b/include/f_pc/f_pc_line.h
@@ -5,6 +5,6 @@
 
 void fpcLn_Create();
 
-extern node_lists_tree_class g_fpcLn_Queue;
+DUSK_GAME_EXTERN node_lists_tree_class g_fpcLn_Queue;
 
 #endif
diff --git a/include/f_pc/f_pc_node.h b/include/f_pc/f_pc_node.h
index 0d96fd2de5..a519393b1c 100644
--- a/include/f_pc/f_pc_node.h
+++ b/include/f_pc/f_pc_node.h
@@ -35,7 +35,7 @@ int fpcNd_IsDelete(process_node_class* pProcNode);
 int fpcNd_Delete(process_node_class* pProcNode);
 int fpcNd_Create(process_node_class* pProcNode);
 
-extern int g_fpcNd_type;
-extern nodedraw_method_class g_fpcNd_Method;
+DUSK_GAME_EXTERN int g_fpcNd_type;
+DUSK_GAME_EXTERN nodedraw_method_class g_fpcNd_Method;
 
 #endif
diff --git a/include/f_pc/f_pc_profile.h b/include/f_pc/f_pc_profile.h
index bccbfda215..f1ebfa144e 100644
--- a/include/f_pc/f_pc_profile.h
+++ b/include/f_pc/f_pc_profile.h
@@ -6,7 +6,7 @@
 #include "global.h"
 
 // Putting const on these profiles make them have internal linkage. Make sure they're extern!
-#define DUSK_PROFILE IF_DUSK(extern)
+#define DUSK_PROFILE IF_DUSK(extern) DUSK_GAME_DATA
 
 typedef struct nodedraw_method_class nodedraw_method_class;
 typedef struct leafdraw_method_class leafdraw_method_class;
@@ -27,6 +27,6 @@ typedef struct process_profile_definition {
 
 struct leaf_process_profile_definition;
 process_profile_definition DUSK_CONST* fpcPf_Get(s16 i_profname);
-extern process_profile_definition DUSK_CONST* DUSK_CONST* DUSK_CONST g_fpcPf_ProfileList_p;
+DUSK_GAME_EXTERN process_profile_definition DUSK_CONST* DUSK_CONST* DUSK_CONST g_fpcPf_ProfileList_p;
 
 #endif
diff --git a/include/f_pc/f_pc_profile_lst.h b/include/f_pc/f_pc_profile_lst.h
index e4e2e7c95f..b5d6e461b5 100644
--- a/include/f_pc/f_pc_profile_lst.h
+++ b/include/f_pc/f_pc_profile_lst.h
@@ -13,1594 +13,1594 @@
 #endif
 
 #ifdef __MWERKS__
-extern process_profile_definition g_profile_ALINK;
-extern process_profile_definition g_profile_NO_CHG_ROOM;
-extern process_profile_definition g_profile_ITEM;
-extern process_profile_definition g_profile_CAMERA;
-extern process_profile_definition g_profile_CAMERA2;
-extern process_profile_definition g_profile_ENVSE;
-extern process_profile_definition g_profile_GAMEOVER;
-extern process_profile_definition g_profile_KANKYO;
-extern process_profile_definition g_profile_KYEFF;
-extern process_profile_definition g_profile_KYEFF2;
-extern process_profile_definition g_profile_KY_THUNDER;
-extern process_profile_definition g_profile_MENUWINDOW;
-extern process_profile_definition g_profile_METER2;
-extern process_profile_definition g_profile_MSG_OBJECT;
-extern process_profile_definition g_profile_OVERLAP0;
-extern process_profile_definition g_profile_OVERLAP1;
-extern process_profile_definition g_profile_OVERLAP6;
-extern process_profile_definition g_profile_OVERLAP7;
-extern process_profile_definition g_profile_OVERLAP8;
-extern process_profile_definition g_profile_OVERLAP9;
-extern process_profile_definition g_profile_OVERLAP10;
-extern process_profile_definition g_profile_OVERLAP11;
-extern process_profile_definition g_profile_OVERLAP2;
-extern process_profile_definition g_profile_OVERLAP3;
-extern process_profile_definition g_profile_LOGO_SCENE;
-extern process_profile_definition g_profile_MENU_SCENE;
-extern process_profile_definition g_profile_NAME_SCENE;
-extern process_profile_definition g_profile_NAMEEX_SCENE;
-extern process_profile_definition g_profile_PLAY_SCENE;
-extern process_profile_definition g_profile_OPENING_SCENE;
-extern process_profile_definition g_profile_ROOM_SCENE;
-extern process_profile_definition g_profile_WARNING_SCENE;
-extern process_profile_definition g_profile_WARNING2_SCENE;
-extern process_profile_definition g_profile_TIMER;
-extern process_profile_definition g_profile_WMARK;
-extern process_profile_definition g_profile_WPILLAR;
-extern process_profile_definition g_profile_ANDSW;
-extern process_profile_definition g_profile_BG;
-extern process_profile_definition g_profile_BG_OBJ;
-extern process_profile_definition g_profile_DMIDNA;
-extern process_profile_definition g_profile_DBDOOR;
-extern process_profile_definition g_profile_KNOB20;
-extern process_profile_definition g_profile_DOOR20;
-extern process_profile_definition g_profile_SPIRAL_DOOR;
-extern process_profile_definition g_profile_DSHUTTER;
-extern process_profile_definition g_profile_EP;
-extern process_profile_definition g_profile_HITOBJ;
-extern process_profile_definition g_profile_KYTAG00;
-extern process_profile_definition g_profile_KYTAG04;
-extern process_profile_definition g_profile_KYTAG17;
-extern process_profile_definition g_profile_OBJ_BEF;
-extern process_profile_definition g_profile_Obj_BurnBox;
-extern process_profile_definition g_profile_Obj_Carry;
-extern process_profile_definition g_profile_OBJ_ITO;
-extern process_profile_definition g_profile_Obj_Movebox;
-extern process_profile_definition g_profile_Obj_Swpush;
-extern process_profile_definition g_profile_Obj_Timer;
-extern process_profile_definition g_profile_PATH_LINE;
-extern process_profile_definition g_profile_SCENE_EXIT;
-extern process_profile_definition g_profile_SET_BG_OBJ;
-extern process_profile_definition g_profile_SWHIT0;
-extern process_profile_definition g_profile_TAG_ALLMATO;
-extern process_profile_definition g_profile_TAG_CAMERA;
-extern process_profile_definition g_profile_TAG_CHKPOINT;
-extern process_profile_definition g_profile_TAG_EVENT;
-extern process_profile_definition g_profile_TAG_EVT;
-extern process_profile_definition g_profile_TAG_EVTAREA;
-extern process_profile_definition g_profile_TAG_EVTMSG;
-extern process_profile_definition g_profile_TAG_HOWL;
-extern process_profile_definition g_profile_TAG_KMSG;
-extern process_profile_definition g_profile_TAG_LANTERN;
-extern process_profile_definition g_profile_Tag_Mist;
-extern process_profile_definition g_profile_TAG_MSG;
-extern process_profile_definition g_profile_TAG_PUSH;
-extern process_profile_definition g_profile_TAG_TELOP;
-extern process_profile_definition g_profile_TBOX;
-extern process_profile_definition g_profile_TBOX2;
-extern process_profile_definition g_profile_VRBOX;
-extern process_profile_definition g_profile_VRBOX2;
-extern process_profile_definition g_profile_ARROW;
-extern process_profile_definition g_profile_BOOMERANG;
-extern process_profile_definition g_profile_CROD;
-extern process_profile_definition g_profile_DEMO00;
-extern process_profile_definition g_profile_DISAPPEAR;
-extern process_profile_definition g_profile_MG_ROD;
-extern process_profile_definition g_profile_MIDNA;
-extern process_profile_definition g_profile_NBOMB;
-extern process_profile_definition g_profile_Obj_LifeContainer;
-extern process_profile_definition g_profile_Obj_Yousei;
-extern process_profile_definition g_profile_SPINNER;
-extern process_profile_definition g_profile_SUSPEND;
-extern process_profile_definition g_profile_Tag_Attp;
-extern process_profile_definition g_profile_ALLDIE;
-extern process_profile_definition g_profile_ANDSW2;
-extern process_profile_definition g_profile_BD;
-extern process_profile_definition g_profile_CANOE;
-extern process_profile_definition g_profile_CSTAF;
-extern process_profile_definition g_profile_Demo_Item;
-extern process_profile_definition g_profile_L1BOSS_DOOR;
-extern process_profile_definition g_profile_E_DN;
-extern process_profile_definition g_profile_E_FM;
-extern process_profile_definition g_profile_E_GA;
-extern process_profile_definition g_profile_E_HB;
-extern process_profile_definition g_profile_E_NEST;
-extern process_profile_definition g_profile_E_RD;
-extern process_profile_definition g_profile_ECONT;
-extern process_profile_definition g_profile_FR;
-extern process_profile_definition g_profile_GRASS;
-extern process_profile_definition g_profile_KYTAG05;
-extern process_profile_definition g_profile_KYTAG10;
-extern process_profile_definition g_profile_KYTAG11;
-extern process_profile_definition g_profile_KYTAG14;
-extern process_profile_definition g_profile_MG_FISH;
-extern process_profile_definition g_profile_NPC_BESU;
-extern process_profile_definition g_profile_NPC_FAIRY_SEIREI;
-extern process_profile_definition g_profile_NPC_FISH;
-extern process_profile_definition g_profile_NPC_HENNA;
-extern process_profile_definition g_profile_NPC_KAKASHI;
-extern process_profile_definition g_profile_NPC_KKRI;
-extern process_profile_definition g_profile_NPC_KOLIN;
-extern process_profile_definition g_profile_NPC_MARO;
-extern process_profile_definition g_profile_NPC_TARO;
-extern process_profile_definition g_profile_NPC_TKJ;
-extern process_profile_definition g_profile_Obj_BHASHI;
-extern process_profile_definition g_profile_Obj_BkDoor;
-extern process_profile_definition g_profile_Obj_BossWarp;
-extern process_profile_definition g_profile_Obj_Cboard;
-extern process_profile_definition g_profile_Obj_Digpl;
-extern process_profile_definition g_profile_Obj_Eff;
-extern process_profile_definition g_profile_OBJ_FMOBJ;
-extern process_profile_definition g_profile_Obj_GpTaru;
-extern process_profile_definition g_profile_Obj_HHASHI;
-extern process_profile_definition g_profile_OBJ_KANBAN2;
-extern process_profile_definition g_profile_OBJ_KBACKET;
-extern process_profile_definition g_profile_Obj_KkrGate;
-extern process_profile_definition g_profile_Obj_KLift00;
-extern process_profile_definition g_profile_Tag_KtOnFire;
-extern process_profile_definition g_profile_Obj_Ladder;
-extern process_profile_definition g_profile_Obj_Lv2Candle;
-extern process_profile_definition g_profile_Obj_MagneArm;
-extern process_profile_definition g_profile_Obj_MetalBox;
-extern process_profile_definition g_profile_Obj_MGate;
-extern process_profile_definition g_profile_Obj_NamePlate;
-extern process_profile_definition g_profile_Obj_OnCloth;
-extern process_profile_definition g_profile_Obj_RopeBridge;
-extern process_profile_definition g_profile_Obj_SwallShutter;
-extern process_profile_definition g_profile_OBJ_STICK;
-extern process_profile_definition g_profile_Obj_StoneMark;
-extern process_profile_definition g_profile_Obj_Swpropeller;
-extern process_profile_definition g_profile_Obj_Swpush5;
-extern process_profile_definition g_profile_Obj_Yobikusa;
-extern process_profile_definition g_profile_SCENE_EXIT2;
-extern process_profile_definition g_profile_ShopItem;
-extern process_profile_definition g_profile_SQ;
-extern process_profile_definition g_profile_SWC00;
-extern process_profile_definition g_profile_Tag_CstaSw;
-extern process_profile_definition g_profile_Tag_AJnot;
-extern process_profile_definition g_profile_Tag_AttackItem;
-extern process_profile_definition g_profile_Tag_Gstart;
-extern process_profile_definition g_profile_Tag_Hinit;
-extern process_profile_definition g_profile_Tag_Hjump;
-extern process_profile_definition g_profile_Tag_Hstop;
-extern process_profile_definition g_profile_Tag_Lv2PrChk;
-extern process_profile_definition g_profile_Tag_Magne;
-extern process_profile_definition g_profile_Tag_Mhint;
-extern process_profile_definition g_profile_Tag_Mstop;
-extern process_profile_definition g_profile_Tag_Spring;
-extern process_profile_definition g_profile_Tag_Statue;
-extern process_profile_definition g_profile_Ykgr;
-extern process_profile_definition g_profile_DR;
-extern process_profile_definition g_profile_L7lowDr;
-extern process_profile_definition g_profile_L7ODR;
-extern process_profile_definition g_profile_B_BH;
-extern process_profile_definition g_profile_B_BQ;
-extern process_profile_definition g_profile_B_DR;
-extern process_profile_definition g_profile_B_DRE;
-extern process_profile_definition g_profile_B_DS;
-extern process_profile_definition g_profile_B_GG;
-extern process_profile_definition g_profile_B_GM;
-extern process_profile_definition g_profile_B_GND;
-extern process_profile_definition g_profile_B_GO;
-extern process_profile_definition g_profile_B_GOS;
-extern process_profile_definition g_profile_B_MGN;
-extern process_profile_definition g_profile_B_OB;
-extern process_profile_definition g_profile_B_OH;
-extern process_profile_definition g_profile_B_OH2;
-extern process_profile_definition g_profile_B_TN;
-extern process_profile_definition g_profile_B_YO;
-extern process_profile_definition g_profile_B_YOI;
-extern process_profile_definition g_profile_B_ZANT;
-extern process_profile_definition g_profile_B_ZANTM;
-extern process_profile_definition g_profile_B_ZANTZ;
-extern process_profile_definition g_profile_B_ZANTS;
-extern process_profile_definition g_profile_BALLOON2D;
-extern process_profile_definition g_profile_BULLET;
-extern process_profile_definition g_profile_COACH2D;
-extern process_profile_definition g_profile_COACH_FIRE;
-extern process_profile_definition g_profile_COW;
-extern process_profile_definition g_profile_CSTATUE;
-extern process_profile_definition g_profile_DO;
-extern process_profile_definition g_profile_BOSS_DOOR;
-extern process_profile_definition g_profile_L5BOSS_DOOR;
-extern process_profile_definition g_profile_L1MBOSS_DOOR;
-extern process_profile_definition g_profile_PushDoor;
-extern process_profile_definition g_profile_E_AI;
-extern process_profile_definition g_profile_E_ARROW;
-extern process_profile_definition g_profile_E_BA;
-extern process_profile_definition g_profile_E_BEE;
-extern process_profile_definition g_profile_E_BG;
-extern process_profile_definition g_profile_E_BI;
-extern process_profile_definition g_profile_E_BI_LEAF;
-extern process_profile_definition g_profile_E_BS;
-extern process_profile_definition g_profile_E_BU;
-extern process_profile_definition g_profile_E_BUG;
-extern process_profile_definition g_profile_E_CR;
-extern process_profile_definition g_profile_E_CR_EGG;
-extern process_profile_definition g_profile_E_DB;
-extern process_profile_definition g_profile_E_DB_LEAF;
-extern process_profile_definition g_profile_E_DD;
-extern process_profile_definition g_profile_E_DF;
-extern process_profile_definition g_profile_E_DK;
-extern process_profile_definition g_profile_E_DT;
-extern process_profile_definition g_profile_E_FB;
-extern process_profile_definition g_profile_E_FK;
-extern process_profile_definition g_profile_E_FS;
-extern process_profile_definition g_profile_E_FZ;
-extern process_profile_definition g_profile_E_GB;
-extern process_profile_definition g_profile_E_GE;
-extern process_profile_definition g_profile_E_GI;
-extern process_profile_definition g_profile_E_GM;
-extern process_profile_definition g_profile_E_GOB;
-extern process_profile_definition g_profile_E_GS;
-extern process_profile_definition g_profile_E_HB_LEAF;
-extern process_profile_definition g_profile_E_HM;
-extern process_profile_definition g_profile_E_HP;
-extern process_profile_definition g_profile_E_HZ;
-extern process_profile_definition g_profile_E_HZELDA;
-extern process_profile_definition g_profile_E_IS;
-extern process_profile_definition g_profile_E_KG;
-extern process_profile_definition g_profile_E_KK;
-extern process_profile_definition g_profile_E_KR;
-extern process_profile_definition g_profile_E_MB;
-extern process_profile_definition g_profile_E_MD;
-extern process_profile_definition g_profile_E_MF;
-extern process_profile_definition g_profile_E_MK;
-extern process_profile_definition g_profile_E_MK_BO;
-extern process_profile_definition g_profile_E_MM;
-extern process_profile_definition g_profile_E_MM_MT;
-extern process_profile_definition g_profile_E_MS;
-extern process_profile_definition g_profile_E_NZ;
-extern process_profile_definition g_profile_E_OC;
-extern process_profile_definition g_profile_E_OctBg;
-extern process_profile_definition g_profile_E_OT;
-extern process_profile_definition g_profile_E_PH;
-extern process_profile_definition g_profile_E_PM;
-extern process_profile_definition g_profile_E_PO;
-extern process_profile_definition g_profile_E_PZ;
-extern process_profile_definition g_profile_E_RB;
-extern process_profile_definition g_profile_E_RDB;
-extern process_profile_definition g_profile_E_RDY;
-extern process_profile_definition g_profile_E_S1;
-extern process_profile_definition g_profile_E_SB;
-extern process_profile_definition g_profile_E_SF;
-extern process_profile_definition g_profile_E_SG;
-extern process_profile_definition g_profile_E_SH;
-extern process_profile_definition g_profile_E_SM;
-extern process_profile_definition g_profile_E_SM2;
-extern process_profile_definition g_profile_E_ST;
-extern process_profile_definition g_profile_E_ST_LINE;
-extern process_profile_definition g_profile_E_SW;
-extern process_profile_definition g_profile_E_TH;
-extern process_profile_definition g_profile_E_TH_BALL;
-extern process_profile_definition g_profile_E_TK;
-extern process_profile_definition g_profile_E_TK2;
-extern process_profile_definition g_profile_E_TK_BALL;
-extern process_profile_definition g_profile_E_TT;
-extern process_profile_definition g_profile_E_VT;
-extern process_profile_definition g_profile_E_WAP;
-extern process_profile_definition g_profile_E_WB;
-extern process_profile_definition g_profile_E_WS;
-extern process_profile_definition g_profile_E_WW;
-extern process_profile_definition g_profile_E_YC;
-extern process_profile_definition g_profile_E_YD;
-extern process_profile_definition g_profile_E_YD_LEAF;
-extern process_profile_definition g_profile_E_YG;
-extern process_profile_definition g_profile_E_YH;
-extern process_profile_definition g_profile_E_YK;
-extern process_profile_definition g_profile_E_YM;
-extern process_profile_definition g_profile_E_YM_TAG;
-extern process_profile_definition g_profile_E_YMB;
-extern process_profile_definition g_profile_E_YR;
-extern process_profile_definition g_profile_E_ZH;
-extern process_profile_definition g_profile_E_ZM;
-extern process_profile_definition g_profile_E_ZS;
-extern process_profile_definition g_profile_FORMATION_MNG;
-extern process_profile_definition g_profile_GUARD_MNG;
-extern process_profile_definition g_profile_HORSE;
-extern process_profile_definition g_profile_HOZELDA;
-extern process_profile_definition g_profile_Izumi_Gate;
-extern process_profile_definition g_profile_KAGO;
-extern process_profile_definition g_profile_KYTAG01;
-extern process_profile_definition g_profile_KYTAG02;
-extern process_profile_definition g_profile_KYTAG03;
-extern process_profile_definition g_profile_KYTAG06;
-extern process_profile_definition g_profile_KYTAG07;
-extern process_profile_definition g_profile_KYTAG08;
-extern process_profile_definition g_profile_KYTAG09;
-extern process_profile_definition g_profile_KYTAG12;
-extern process_profile_definition g_profile_KYTAG13;
-extern process_profile_definition g_profile_KYTAG15;
-extern process_profile_definition g_profile_KYTAG16;
-extern process_profile_definition g_profile_MANT;
-extern process_profile_definition g_profile_FSHOP;
-extern process_profile_definition g_profile_MIRROR;
-extern process_profile_definition g_profile_MOVIE_PLAYER;
-extern process_profile_definition g_profile_MYNA;
-extern process_profile_definition g_profile_NI;
-extern process_profile_definition g_profile_NPC_ARU;
-extern process_profile_definition g_profile_NPC_ASH;
-extern process_profile_definition g_profile_NPC_ASHB;
-extern process_profile_definition g_profile_NPC_BANS;
-extern process_profile_definition g_profile_NPC_BLUENS;
-extern process_profile_definition g_profile_NPC_BOU;
-extern process_profile_definition g_profile_NPC_BOU_S;
-extern process_profile_definition g_profile_NPC_CD3;
-extern process_profile_definition g_profile_NPC_CHAT;
-extern process_profile_definition g_profile_NPC_CHIN;
-extern process_profile_definition g_profile_NPC_CLERKA;
-extern process_profile_definition g_profile_NPC_CLERKB;
-extern process_profile_definition g_profile_NPC_CLERKT;
-extern process_profile_definition g_profile_NPC_COACH;
-extern process_profile_definition g_profile_NPC_DF;
-extern process_profile_definition g_profile_NPC_DOC;
-extern process_profile_definition g_profile_NPC_DOORBOY;
-extern process_profile_definition g_profile_NPC_DRSOL;
-extern process_profile_definition g_profile_NPC_DU;
-extern process_profile_definition g_profile_NPC_FAIRY;
-extern process_profile_definition g_profile_NPC_FGUARD;
-extern process_profile_definition g_profile_NPC_GND;
-extern process_profile_definition g_profile_NPC_GRA;
-extern process_profile_definition g_profile_NPC_GRC;
-extern process_profile_definition g_profile_NPC_GRD;
-extern process_profile_definition g_profile_NPC_GRM;
-extern process_profile_definition g_profile_NPC_GRMC;
-extern process_profile_definition g_profile_NPC_GRO;
-extern process_profile_definition g_profile_NPC_GRR;
-extern process_profile_definition g_profile_NPC_GRS;
-extern process_profile_definition g_profile_NPC_GRZ;
-extern process_profile_definition g_profile_NPC_GUARD;
-extern process_profile_definition g_profile_NPC_GWOLF;
-extern process_profile_definition g_profile_NPC_HANJO;
-extern process_profile_definition g_profile_NPC_HENNA0;
-extern process_profile_definition g_profile_NPC_HOZ;
-extern process_profile_definition g_profile_NPC_IMPAL;
-extern process_profile_definition g_profile_NPC_INKO;
-extern process_profile_definition g_profile_NPC_INS;
-extern process_profile_definition g_profile_NPC_JAGAR;
-extern process_profile_definition g_profile_NPC_KASIHANA;
-extern process_profile_definition g_profile_NPC_KASIKYU;
-extern process_profile_definition g_profile_NPC_KASIMICH;
-extern process_profile_definition g_profile_NPC_KDK;
-extern process_profile_definition g_profile_NPC_KN;
-extern process_profile_definition g_profile_NPC_KNJ;
-extern process_profile_definition g_profile_NPC_KOLINB;
-extern process_profile_definition g_profile_NPC_KS;
-extern process_profile_definition g_profile_NPC_KYURY;
-extern process_profile_definition g_profile_NPC_LEN;
-extern process_profile_definition g_profile_NPC_LF;
-extern process_profile_definition g_profile_NPC_LUD;
-extern process_profile_definition g_profile_NPC_MIDP;
-extern process_profile_definition g_profile_NPC_MK;
-extern process_profile_definition g_profile_NPC_MOI;
-extern process_profile_definition g_profile_NPC_MOIR;
-extern process_profile_definition g_profile_MYNA2;
-extern process_profile_definition g_profile_NPC_NE;
-extern process_profile_definition g_profile_NPC_P2;
-extern process_profile_definition g_profile_NPC_PACHI_BESU;
-extern process_profile_definition g_profile_NPC_PACHI_MARO;
-extern process_profile_definition g_profile_NPC_PACHI_TARO;
-extern process_profile_definition g_profile_NPC_PASSER;
-extern process_profile_definition g_profile_NPC_PASSER2;
-extern process_profile_definition g_profile_NPC_POST;
-extern process_profile_definition g_profile_NPC_POUYA;
-extern process_profile_definition g_profile_NPC_PRAYER;
-extern process_profile_definition g_profile_NPC_RACA;
-extern process_profile_definition g_profile_NPC_RAFREL;
-extern process_profile_definition g_profile_NPC_SARU;
-extern process_profile_definition g_profile_NPC_SEIB;
-extern process_profile_definition g_profile_NPC_SEIC;
-extern process_profile_definition g_profile_NPC_SEID;
-extern process_profile_definition g_profile_NPC_SEIRA;
-extern process_profile_definition g_profile_NPC_SERA2;
-extern process_profile_definition g_profile_NPC_SEIREI;
-extern process_profile_definition g_profile_NPC_SHAD;
-extern process_profile_definition g_profile_NPC_SHAMAN;
-extern process_profile_definition g_profile_NPC_SHOE;
-extern process_profile_definition g_profile_NPC_SHOP0;
-extern process_profile_definition g_profile_NPC_SMARO;
-extern process_profile_definition g_profile_NPC_SOLA;
-extern process_profile_definition g_profile_NPC_SOLDIERa;
-extern process_profile_definition g_profile_NPC_SOLDIERb;
-extern process_profile_definition g_profile_NPC_SQ;
-extern process_profile_definition g_profile_NPC_THE;
-extern process_profile_definition g_profile_NPC_THEB;
-extern process_profile_definition g_profile_NPC_TK;
-extern process_profile_definition g_profile_NPC_TKC;
-extern process_profile_definition g_profile_NPC_TKJ2;
-extern process_profile_definition g_profile_NPC_TKS;
-extern process_profile_definition g_profile_NPC_TOBY;
-extern process_profile_definition g_profile_NPC_TR;
-extern process_profile_definition g_profile_NPC_URI;
-extern process_profile_definition g_profile_NPC_WORM;
-extern process_profile_definition g_profile_NPC_WRESTLER;
-extern process_profile_definition g_profile_NPC_YAMID;
-extern process_profile_definition g_profile_NPC_YAMIS;
-extern process_profile_definition g_profile_NPC_YAMIT;
-extern process_profile_definition g_profile_NPC_YELIA;
-extern process_profile_definition g_profile_NPC_YKM;
-extern process_profile_definition g_profile_NPC_YKW;
-extern process_profile_definition g_profile_NPC_ZANB;
-extern process_profile_definition g_profile_NPC_ZANT;
-extern process_profile_definition g_profile_NPC_ZELR;
-extern process_profile_definition g_profile_NPC_ZELRO;
-extern process_profile_definition g_profile_NPC_ZELDA;
-extern process_profile_definition g_profile_NPC_ZRA;
-extern process_profile_definition g_profile_NPC_ZRC;
-extern process_profile_definition g_profile_NPC_ZRZ;
-extern process_profile_definition g_profile_Obj_Lv5Key;
-extern process_profile_definition g_profile_Obj_Turara;
-extern process_profile_definition g_profile_Obj_TvCdlst;
-extern process_profile_definition g_profile_Obj_Ytaihou;
-extern process_profile_definition g_profile_Obj_AmiShutter;
-extern process_profile_definition g_profile_Obj_Ari;
-extern process_profile_definition g_profile_OBJ_AUTOMATA;
-extern process_profile_definition g_profile_Obj_Avalanche;
-extern process_profile_definition g_profile_OBJ_BALLOON;
-extern process_profile_definition g_profile_Obj_BarDesk;
-extern process_profile_definition g_profile_Obj_Batta;
-extern process_profile_definition g_profile_Obj_BBox;
-extern process_profile_definition g_profile_OBJ_BED;
-extern process_profile_definition g_profile_Obj_Bemos;
-extern process_profile_definition g_profile_Obj_Bhbridge;
-extern process_profile_definition g_profile_Obj_BkLeaf;
-extern process_profile_definition g_profile_BkyRock;
-extern process_profile_definition g_profile_Obj_BmWindow;
-extern process_profile_definition g_profile_Obj_BoomShutter;
-extern process_profile_definition g_profile_Obj_Bombf;
-extern process_profile_definition g_profile_OBJ_BOUMATO;
-extern process_profile_definition g_profile_OBJ_BRG;
-extern process_profile_definition g_profile_Obj_BsGate;
-extern process_profile_definition g_profile_Obj_awaPlar;
-extern process_profile_definition g_profile_Obj_CatDoor;
-extern process_profile_definition g_profile_OBJ_CB;
-extern process_profile_definition g_profile_Obj_ChainBlock;
-extern process_profile_definition g_profile_Obj_Cdoor;
-extern process_profile_definition g_profile_Obj_Chandelier;
-extern process_profile_definition g_profile_Obj_Chest;
-extern process_profile_definition g_profile_Obj_Cho;
-extern process_profile_definition g_profile_Obj_Cowdoor;
-extern process_profile_definition g_profile_Obj_Crope;
-extern process_profile_definition g_profile_Obj_CRVFENCE;
-extern process_profile_definition g_profile_Obj_CRVGATE;
-extern process_profile_definition g_profile_Obj_CRVHAHEN;
-extern process_profile_definition g_profile_Obj_CRVLH_DW;
-extern process_profile_definition g_profile_Obj_CRVLH_UP;
-extern process_profile_definition g_profile_Obj_CRVSTEEL;
-extern process_profile_definition g_profile_Obj_Crystal;
-extern process_profile_definition g_profile_Obj_ChainWall;
-extern process_profile_definition g_profile_Obj_DamCps;
-extern process_profile_definition g_profile_Obj_Dan;
-extern process_profile_definition g_profile_Obj_Digholl;
-extern process_profile_definition g_profile_Obj_DigSnow;
-extern process_profile_definition g_profile_Obj_Elevator;
-extern process_profile_definition g_profile_Obj_Drop;
-extern process_profile_definition g_profile_Obj_DUST;
-extern process_profile_definition g_profile_Obj_E_CREATE;
-extern process_profile_definition g_profile_Obj_FallObj;
-extern process_profile_definition g_profile_Obj_Fan;
-extern process_profile_definition g_profile_Obj_Fchain;
-extern process_profile_definition g_profile_Obj_FireWood;
-extern process_profile_definition g_profile_Obj_FireWood2;
-extern process_profile_definition g_profile_Obj_FirePillar;
-extern process_profile_definition g_profile_Obj_FirePillar2;
-extern process_profile_definition g_profile_Obj_Flag;
-extern process_profile_definition g_profile_Obj_Flag2;
-extern process_profile_definition g_profile_Obj_Flag3;
-extern process_profile_definition g_profile_OBJ_FOOD;
-extern process_profile_definition g_profile_OBJ_FW;
-extern process_profile_definition g_profile_OBJ_GADGET;
-extern process_profile_definition g_profile_Obj_GanonWall;
-extern process_profile_definition g_profile_Obj_GanonWall2;
-extern process_profile_definition g_profile_OBJ_GB;
-extern process_profile_definition g_profile_Obj_Geyser;
-extern process_profile_definition g_profile_Obj_glowSphere;
-extern process_profile_definition g_profile_OBJ_GM;
-extern process_profile_definition g_profile_Obj_GoGate;
-extern process_profile_definition g_profile_Obj_GOMIKABE;
-extern process_profile_definition g_profile_OBJ_GRA;
-extern process_profile_definition g_profile_GRA_WALL;
-extern process_profile_definition g_profile_Obj_GraRock;
-extern process_profile_definition g_profile_Obj_GraveStone;
-extern process_profile_definition g_profile_GRDWATER;
-extern process_profile_definition g_profile_Obj_GrzRock;
-extern process_profile_definition g_profile_Obj_H_Saku;
-extern process_profile_definition g_profile_Obj_HBarrel;
-extern process_profile_definition g_profile_Obj_HFtr;
-extern process_profile_definition g_profile_Obj_MHasu;
-extern process_profile_definition g_profile_Obj_Hata;
-extern process_profile_definition g_profile_OBJ_HB;
-extern process_profile_definition g_profile_Obj_HBombkoya;
-extern process_profile_definition g_profile_Obj_HeavySw;
-extern process_profile_definition g_profile_Obj_Hfuta;
-extern process_profile_definition g_profile_Obj_HsTarget;
-extern process_profile_definition g_profile_Obj_Ice_l;
-extern process_profile_definition g_profile_Obj_Ice_s;
-extern process_profile_definition g_profile_Obj_IceBlock;
-extern process_profile_definition g_profile_Obj_IceLeaf;
-extern process_profile_definition g_profile_OBJ_IHASI;
-extern process_profile_definition g_profile_Obj_Ikada;
-extern process_profile_definition g_profile_Obj_InoBone;
-extern process_profile_definition g_profile_Obj_ITA;
-extern process_profile_definition g_profile_OBJ_ITAMATO;
-extern process_profile_definition g_profile_Obj_Kabuto;
-extern process_profile_definition g_profile_Obj_Kag;
-extern process_profile_definition g_profile_OBJ_KAGE;
-extern process_profile_definition g_profile_OBJ_KAGO;
-extern process_profile_definition g_profile_Obj_Kaisou;
-extern process_profile_definition g_profile_Obj_Kam;
-extern process_profile_definition g_profile_Obj_Kantera;
-extern process_profile_definition g_profile_Obj_Kat;
-extern process_profile_definition g_profile_Obj_KazeNeko;
-extern process_profile_definition g_profile_OBJ_KBOX;
-extern process_profile_definition g_profile_OBJ_KEY;
-extern process_profile_definition g_profile_OBJ_KEYHOLE;
-extern process_profile_definition g_profile_OBJ_KI;
-extern process_profile_definition g_profile_Obj_KiPot;
-extern process_profile_definition g_profile_OBJ_KITA;
-extern process_profile_definition g_profile_Obj_KJgjs;
-extern process_profile_definition g_profile_Obj_KKanban;
-extern process_profile_definition g_profile_KN_BULLET;
-extern process_profile_definition g_profile_Obj_Kshutter;
-extern process_profile_definition g_profile_Obj_Kuw;
-extern process_profile_definition g_profile_Obj_KWheel00;
-extern process_profile_definition g_profile_Obj_KWheel01;
-extern process_profile_definition g_profile_Obj_KznkArm;
-extern process_profile_definition g_profile_Obj_Laundry;
-extern process_profile_definition g_profile_Obj_LndRope;
-extern process_profile_definition g_profile_OBJ_LBOX;
-extern process_profile_definition g_profile_OBJ_LP;
-extern process_profile_definition g_profile_Obj_Lv1Cdl00;
-extern process_profile_definition g_profile_Obj_Lv1Cdl01;
-extern process_profile_definition g_profile_Obj_Lv3Candle;
-extern process_profile_definition g_profile_Obj_Lv3Water;
-extern process_profile_definition g_profile_Obj_Lv3Water2;
-extern process_profile_definition g_profile_OBJ_LV3WATERB;
-extern process_profile_definition g_profile_Obj_Lv3R10Saka;
-extern process_profile_definition g_profile_Obj_WaterEff;
-extern process_profile_definition g_profile_Tag_Lv4CandleDm;
-extern process_profile_definition g_profile_Tag_Lv4Candle;
-extern process_profile_definition g_profile_Obj_Lv4EdShutter;
-extern process_profile_definition g_profile_Obj_Lv4Gate;
-extern process_profile_definition g_profile_Obj_Lv4HsTarget;
-extern process_profile_definition g_profile_Obj_Lv4PoGate;
-extern process_profile_definition g_profile_Obj_Lv4RailWall;
-extern process_profile_definition g_profile_Obj_Lv4SlideWall;
-extern process_profile_definition g_profile_Obj_Lv4Bridge;
-extern process_profile_definition g_profile_Obj_Lv4Chan;
-extern process_profile_definition g_profile_Obj_Lv4DigSand;
-extern process_profile_definition g_profile_Obj_Lv4Floor;
-extern process_profile_definition g_profile_Obj_Lv4Gear;
-extern process_profile_definition g_profile_Obj_PRElvtr;
-extern process_profile_definition g_profile_Obj_Lv4PRwall;
-extern process_profile_definition g_profile_Obj_Lv4Sand;
-extern process_profile_definition g_profile_Obj_Lv5FBoard;
-extern process_profile_definition g_profile_Obj_IceWall;
-extern process_profile_definition g_profile_Obj_Lv5SwIce;
-extern process_profile_definition g_profile_Obj_Ychndlr;
-extern process_profile_definition g_profile_Obj_YIblltray;
-extern process_profile_definition g_profile_Obj_Lv6ChgGate;
-extern process_profile_definition g_profile_Obj_Lv6FuriTrap;
-extern process_profile_definition g_profile_Obj_Lv6Lblock;
-extern process_profile_definition g_profile_Obj_Lv6SwGate;
-extern process_profile_definition g_profile_Obj_Lv6SzGate;
-extern process_profile_definition g_profile_Obj_Lv6Tenbin;
-extern process_profile_definition g_profile_Obj_Lv6TogeRoll;
-extern process_profile_definition g_profile_Obj_Lv6TogeTrap;
-extern process_profile_definition g_profile_Obj_Lv6bemos;
-extern process_profile_definition g_profile_Obj_Lv6bemos2;
-extern process_profile_definition g_profile_Obj_Lv6EGate;
-extern process_profile_definition g_profile_Obj_Lv6ElevtA;
-extern process_profile_definition g_profile_Obj_Lv6SwTurn;
-extern process_profile_definition g_profile_Obj_Lv7BsGate;
-extern process_profile_definition g_profile_Obj_Lv7PropY;
-extern process_profile_definition g_profile_Obj_Lv7Bridge;
-extern process_profile_definition g_profile_Obj_Lv8KekkaiTrap;
-extern process_profile_definition g_profile_Obj_Lv8Lift;
-extern process_profile_definition g_profile_Obj_Lv8OptiLift;
-extern process_profile_definition g_profile_Obj_Lv8UdFloor;
-extern process_profile_definition g_profile_Obj_Lv9SwShutter;
-extern process_profile_definition g_profile_Obj_MagLift;
-extern process_profile_definition g_profile_Obj_MagLiftRot;
-extern process_profile_definition g_profile_OBJ_MAKI;
-extern process_profile_definition g_profile_Obj_MasterSword;
-extern process_profile_definition g_profile_Obj_Mato;
-extern process_profile_definition g_profile_Obj_MHole;
-extern process_profile_definition g_profile_OBJ_MIE;
-extern process_profile_definition g_profile_Obj_Mirror6Pole;
-extern process_profile_definition g_profile_Obj_MirrorChain;
-extern process_profile_definition g_profile_Obj_MirrorSand;
-extern process_profile_definition g_profile_Obj_MirrorScrew;
-extern process_profile_definition g_profile_Obj_MirrorTable;
-extern process_profile_definition g_profile_OBJ_MSIMA;
-extern process_profile_definition g_profile_Obj_MvStair;
-extern process_profile_definition g_profile_OBJ_MYOGAN;
-extern process_profile_definition g_profile_Obj_Nagaisu;
-extern process_profile_definition g_profile_Obj_Nan;
-extern process_profile_definition g_profile_OBJ_NDOOR;
-extern process_profile_definition g_profile_OBJ_NOUGU;
-extern process_profile_definition g_profile_OCTHASHI;
-extern process_profile_definition g_profile_OBJ_OILTUBO;
-extern process_profile_definition g_profile_Obj_Onsen;
-extern process_profile_definition g_profile_OBJ_ONSEN_FIRE;
-extern process_profile_definition g_profile_Obj_OnsenTaru;
-extern process_profile_definition g_profile_Obj_PushDoor;
-extern process_profile_definition g_profile_Obj_PDtile;
-extern process_profile_definition g_profile_Obj_PDwall;
-extern process_profile_definition g_profile_Obj_Picture;
-extern process_profile_definition g_profile_Obj_Pillar;
-extern process_profile_definition g_profile_OBJ_PLEAF;
-extern process_profile_definition g_profile_Obj_poCandle;
-extern process_profile_definition g_profile_Obj_poFire;
-extern process_profile_definition g_profile_Obj_poTbox;
-extern process_profile_definition g_profile_Obj_Prop;
-extern process_profile_definition g_profile_OBJ_PUMPKIN;
-extern process_profile_definition g_profile_Obj_RCircle;
-extern process_profile_definition g_profile_Obj_RfHole;
-extern process_profile_definition g_profile_Obj_RiderGate;
-extern process_profile_definition g_profile_Obj_RIVERROCK;
-extern process_profile_definition g_profile_OBJ_ROCK;
-extern process_profile_definition g_profile_Obj_RotBridge;
-extern process_profile_definition g_profile_Obj_RotTrap;
-extern process_profile_definition g_profile_OBJ_ROTEN;
-extern process_profile_definition g_profile_Obj_RotStair;
-extern process_profile_definition g_profile_OBJ_RW;
-extern process_profile_definition g_profile_Obj_Saidan;
-extern process_profile_definition g_profile_Obj_Sakuita;
-extern process_profile_definition g_profile_Obj_ItaRope;
-extern process_profile_definition g_profile_Obj_SCannon;
-extern process_profile_definition g_profile_Obj_SCannonCrs;
-extern process_profile_definition g_profile_Obj_SCannonTen;
-extern process_profile_definition g_profile_OBJ_SEKIDOOR;
-extern process_profile_definition g_profile_OBJ_SEKIZO;
-extern process_profile_definition g_profile_OBJ_SEKIZOA;
-extern process_profile_definition g_profile_Obj_Shield;
-extern process_profile_definition g_profile_Obj_SM_DOOR;
-extern process_profile_definition g_profile_Obj_SmallKey;
-extern process_profile_definition g_profile_Obj_SmgDoor;
-extern process_profile_definition g_profile_Obj_Smoke;
-extern process_profile_definition g_profile_OBJ_SMTILE;
-extern process_profile_definition g_profile_Obj_SmWStone;
-extern process_profile_definition g_profile_Tag_SnowEff;
-extern process_profile_definition g_profile_Obj_SnowSoup;
-extern process_profile_definition g_profile_OBJ_SO;
-extern process_profile_definition g_profile_Obj_SpinLift;
-extern process_profile_definition g_profile_OBJ_SSDRINK;
-extern process_profile_definition g_profile_OBJ_SSITEM;
-extern process_profile_definition g_profile_Obj_StairBlock;
-extern process_profile_definition g_profile_Obj_Stone;
-extern process_profile_definition g_profile_Obj_Stopper;
-extern process_profile_definition g_profile_Obj_Stopper2;
-extern process_profile_definition g_profile_OBJ_SUISYA;
-extern process_profile_definition g_profile_OBJ_SW;
-extern process_profile_definition g_profile_Obj_SwBallA;
-extern process_profile_definition g_profile_Obj_SwBallB;
-extern process_profile_definition g_profile_Obj_SwBallC;
-extern process_profile_definition g_profile_Obj_SwLight;
-extern process_profile_definition g_profile_Obj_SwChain;
-extern process_profile_definition g_profile_Obj_SwHang;
-extern process_profile_definition g_profile_Obj_Sword;
-extern process_profile_definition g_profile_Obj_Swpush2;
-extern process_profile_definition g_profile_Obj_SwSpinner;
-extern process_profile_definition g_profile_Obj_SwTurn;
-extern process_profile_definition g_profile_Obj_SyRock;
-extern process_profile_definition g_profile_Obj_SZbridge;
-extern process_profile_definition g_profile_Obj_TaFence;
-extern process_profile_definition g_profile_Obj_Table;
-extern process_profile_definition g_profile_Obj_TakaraDai;
-extern process_profile_definition g_profile_OBJ_TATIGI;
-extern process_profile_definition g_profile_Obj_Ten;
-extern process_profile_definition g_profile_Obj_TestCube;
-extern process_profile_definition g_profile_Obj_Gake;
-extern process_profile_definition g_profile_Obj_THASHI;
-extern process_profile_definition g_profile_Obj_TDoor;
-extern process_profile_definition g_profile_Obj_TimeFire;
-extern process_profile_definition g_profile_OBJ_TKS;
-extern process_profile_definition g_profile_Obj_TMoon;
-extern process_profile_definition g_profile_Obj_ToaruMaki;
-extern process_profile_definition g_profile_OBJ_TOBY;
-extern process_profile_definition g_profile_Obj_TobyHouse;
-extern process_profile_definition g_profile_Obj_TogeTrap;
-extern process_profile_definition g_profile_Obj_Tombo;
-extern process_profile_definition g_profile_Obj_Tornado;
-extern process_profile_definition g_profile_Obj_Tornado2;
-extern process_profile_definition g_profile_OBJ_TP;
-extern process_profile_definition g_profile_TREESH;
-extern process_profile_definition g_profile_Obj_TwGate;
-extern process_profile_definition g_profile_OBJ_UDOOR;
-extern process_profile_definition g_profile_OBJ_USAKU;
-extern process_profile_definition g_profile_Obj_VolcGnd;
-extern process_profile_definition g_profile_Obj_VolcanicBall;
-extern process_profile_definition g_profile_Obj_VolcanicBomb;
-extern process_profile_definition g_profile_Obj_KakarikoBrg;
-extern process_profile_definition g_profile_Obj_OrdinBrg;
-extern process_profile_definition g_profile_Obj_WtGate;
-extern process_profile_definition g_profile_Obj_WaterPillar;
-extern process_profile_definition g_profile_Obj_WaterFall;
-extern process_profile_definition g_profile_Obj_Wchain;
-extern process_profile_definition g_profile_Obj_WdStick;
-extern process_profile_definition g_profile_OBJ_WEB0;
-extern process_profile_definition g_profile_OBJ_WEB1;
-extern process_profile_definition g_profile_Obj_WellCover;
-extern process_profile_definition g_profile_OBJ_WFLAG;
-extern process_profile_definition g_profile_Obj_WindStone;
-extern process_profile_definition g_profile_Obj_Window;
-extern process_profile_definition g_profile_Obj_WoodPendulum;
-extern process_profile_definition g_profile_Obj_WoodStatue;
-extern process_profile_definition g_profile_Obj_WoodenSword;
-extern process_profile_definition g_profile_OBJ_YBAG;
-extern process_profile_definition g_profile_OBJ_YSTONE;
-extern process_profile_definition g_profile_Obj_ZoraCloth;
-extern process_profile_definition g_profile_Obj_ZDoor;
-extern process_profile_definition g_profile_Obj_zrTurara;
-extern process_profile_definition g_profile_Obj_zrTuraraRc;
-extern process_profile_definition g_profile_ZRA_MARK;
-extern process_profile_definition g_profile_OBJ_ZRAFREEZE;
-extern process_profile_definition g_profile_Obj_ZraRock;
-extern process_profile_definition g_profile_PASSER_MNG;
-extern process_profile_definition g_profile_PERU;
-extern process_profile_definition g_profile_PPolamp;
-extern process_profile_definition g_profile_SKIP2D;
-extern process_profile_definition g_profile_START_AND_GOAL;
-extern process_profile_definition g_profile_SwBall;
-extern process_profile_definition g_profile_SwLBall;
-extern process_profile_definition g_profile_SwTime;
-extern process_profile_definition g_profile_Tag_Lv6Gate;
-extern process_profile_definition g_profile_Tag_Lv7Gate;
-extern process_profile_definition g_profile_Tag_Lv8Gate;
-extern process_profile_definition g_profile_Tag_TWGate;
-extern process_profile_definition g_profile_Tag_Arena;
-extern process_profile_definition g_profile_Tag_Assist;
-extern process_profile_definition g_profile_TAG_BTLITM;
-extern process_profile_definition g_profile_Tag_ChgRestart;
-extern process_profile_definition g_profile_TAG_CSW;
-extern process_profile_definition g_profile_Tag_Escape;
-extern process_profile_definition g_profile_Tag_FWall;
-extern process_profile_definition g_profile_TAG_GRA;
-extern process_profile_definition g_profile_TAG_GUARD;
-extern process_profile_definition g_profile_Tag_Instruction;
-extern process_profile_definition g_profile_Tag_KagoFall;
-extern process_profile_definition g_profile_Tag_LightBall;
-extern process_profile_definition g_profile_TAG_LV5SOUP;
-extern process_profile_definition g_profile_Tag_Lv6CstaSw;
-extern process_profile_definition g_profile_Tag_Mmsg;
-extern process_profile_definition g_profile_Tag_Mwait;
-extern process_profile_definition g_profile_TAG_MYNA2;
-extern process_profile_definition g_profile_TAG_MNLIGHT;
-extern process_profile_definition g_profile_TAG_PATI;
-extern process_profile_definition g_profile_Tag_poFire;
-extern process_profile_definition g_profile_TAG_QS;
-extern process_profile_definition g_profile_Tag_RetRoom;
-extern process_profile_definition g_profile_Tag_RiverBack;
-extern process_profile_definition g_profile_Tag_RmbitSw;
-extern process_profile_definition g_profile_Tag_Schedule;
-extern process_profile_definition g_profile_Tag_SetBall;
-extern process_profile_definition g_profile_Tag_Restart;
-extern process_profile_definition g_profile_TAG_SHOPCAM;
-extern process_profile_definition g_profile_TAG_SHOPITM;
-extern process_profile_definition g_profile_Tag_SmkEmt;
-extern process_profile_definition g_profile_Tag_Spinner;
-extern process_profile_definition g_profile_Tag_Sppath;
-extern process_profile_definition g_profile_TAG_SSDRINK;
-extern process_profile_definition g_profile_Tag_Stream;
-extern process_profile_definition g_profile_Tag_TheBHint;
-extern process_profile_definition g_profile_Tag_WaraHowl;
-extern process_profile_definition g_profile_Tag_WatchGe;
-extern process_profile_definition g_profile_Tag_WaterFall;
-extern process_profile_definition g_profile_Tag_Wljump;
-extern process_profile_definition g_profile_TAG_YAMI;
-extern process_profile_definition g_profile_TALK;
-extern process_profile_definition g_profile_TBOX_SW;
-extern process_profile_definition g_profile_TITLE;
-extern process_profile_definition g_profile_WarpBug;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ALINK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NO_CHG_ROOM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ITEM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_CAMERA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_CAMERA2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ENVSE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_GAMEOVER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KANKYO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYEFF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYEFF2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KY_THUNDER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MENUWINDOW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_METER2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MSG_OBJECT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP0;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP1;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP6;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP7;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP8;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP9;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP10;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP11;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OVERLAP3;
+DUSK_GAME_EXTERN process_profile_definition g_profile_LOGO_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MENU_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NAME_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NAMEEX_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_PLAY_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OPENING_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ROOM_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_WARNING_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_WARNING2_SCENE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TIMER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_WMARK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_WPILLAR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ANDSW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BG_OBJ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DMIDNA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DBDOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KNOB20;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DOOR20;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SPIRAL_DOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DSHUTTER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_EP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_HITOBJ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG00;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG04;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG17;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_BEF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BurnBox;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Carry;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_ITO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Movebox;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Swpush;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Timer;
+DUSK_GAME_EXTERN process_profile_definition g_profile_PATH_LINE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SCENE_EXIT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SET_BG_OBJ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SWHIT0;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_ALLMATO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_CAMERA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_CHKPOINT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_EVENT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_EVT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_EVTAREA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_EVTMSG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_HOWL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_KMSG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_LANTERN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Mist;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_MSG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_PUSH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_TELOP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TBOX;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TBOX2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_VRBOX;
+DUSK_GAME_EXTERN process_profile_definition g_profile_VRBOX2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ARROW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BOOMERANG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_CROD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DEMO00;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DISAPPEAR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MG_ROD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MIDNA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NBOMB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_LifeContainer;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Yousei;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SPINNER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SUSPEND;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Attp;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ALLDIE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ANDSW2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_CANOE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_CSTAF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Demo_Item;
+DUSK_GAME_EXTERN process_profile_definition g_profile_L1BOSS_DOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_FM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_HB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_NEST;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_RD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ECONT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_FR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_GRASS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG05;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG10;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG11;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG14;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MG_FISH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_BESU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_FAIRY_SEIREI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_FISH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_HENNA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KAKASHI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KKRI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KOLIN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_MARO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TARO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TKJ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BHASHI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BkDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BossWarp;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Cboard;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Digpl;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Eff;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_FMOBJ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GpTaru;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_HHASHI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KANBAN2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KBACKET;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KkrGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KLift00;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_KtOnFire;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ladder;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv2Candle;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MagneArm;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MetalBox;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_NamePlate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_OnCloth;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RopeBridge;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwallShutter;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_STICK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_StoneMark;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Swpropeller;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Swpush5;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Yobikusa;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SCENE_EXIT2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ShopItem;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SQ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SWC00;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_CstaSw;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_AJnot;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_AttackItem;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Gstart;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Hinit;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Hjump;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Hstop;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv2PrChk;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Magne;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Mhint;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Mstop;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Spring;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Statue;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Ykgr;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_L7lowDr;
+DUSK_GAME_EXTERN process_profile_definition g_profile_L7ODR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_BH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_BQ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_DR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_DRE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_DS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_GG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_GM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_GND;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_GO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_GOS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_MGN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_OB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_OH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_OH2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_TN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_YO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_YOI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_ZANT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_ZANTM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_ZANTZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_B_ZANTS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BALLOON2D;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BULLET;
+DUSK_GAME_EXTERN process_profile_definition g_profile_COACH2D;
+DUSK_GAME_EXTERN process_profile_definition g_profile_COACH_FIRE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_COW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_CSTATUE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_DO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BOSS_DOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_L5BOSS_DOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_L1MBOSS_DOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_PushDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_AI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_ARROW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BEE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BI_LEAF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_BUG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_CR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_CR_EGG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DB_LEAF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_DT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_FB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_FK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_FS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_FZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GOB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_GS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_HB_LEAF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_HM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_HP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_HZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_HZELDA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_IS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_KG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_KK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_KR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MK_BO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MM_MT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_MS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_NZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_OC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_OctBg;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_OT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_PH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_PM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_PO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_PZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_RB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_RDB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_RDY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_S1;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SM2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_ST;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_ST_LINE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_SW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_TH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_TH_BALL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_TK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_TK2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_TK_BALL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_TT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_VT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_WAP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_WB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_WS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_WW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YD_LEAF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YM_TAG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YMB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_YR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_ZH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_ZM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_E_ZS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_FORMATION_MNG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_GUARD_MNG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_HORSE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_HOZELDA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Izumi_Gate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KAGO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG01;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG02;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG03;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG06;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG07;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG08;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG09;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG12;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG13;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG15;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KYTAG16;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MANT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_FSHOP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MIRROR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MOVIE_PLAYER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MYNA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ARU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ASH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ASHB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_BANS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_BLUENS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_BOU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_BOU_S;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_CD3;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_CHAT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_CHIN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_CLERKA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_CLERKB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_CLERKT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_COACH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_DF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_DOC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_DOORBOY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_DRSOL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_DU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_FAIRY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_FGUARD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GND;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRMC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GRZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GUARD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_GWOLF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_HANJO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_HENNA0;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_HOZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_IMPAL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_INKO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_INS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_JAGAR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KASIHANA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KASIKYU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KASIMICH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KDK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KNJ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KOLINB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_KYURY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_LEN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_LF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_LUD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_MIDP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_MK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_MOI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_MOIR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_MYNA2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_NE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_P2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_PACHI_BESU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_PACHI_MARO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_PACHI_TARO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_PASSER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_PASSER2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_POST;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_POUYA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_PRAYER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_RACA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_RAFREL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SARU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SEIB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SEIC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SEID;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SEIRA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SERA2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SEIREI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SHAD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SHAMAN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SHOE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SHOP0;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SMARO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SOLA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SOLDIERa;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SOLDIERb;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_SQ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_THE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_THEB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TKC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TKJ2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TKS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TOBY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_TR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_URI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_WORM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_WRESTLER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_YAMID;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_YAMIS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_YAMIT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_YELIA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_YKM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_YKW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZANB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZANT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZELR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZELRO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZELDA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZRA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZRC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_NPC_ZRZ;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv5Key;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Turara;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TvCdlst;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ytaihou;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_AmiShutter;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ari;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_AUTOMATA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Avalanche;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_BALLOON;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BarDesk;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Batta;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BBox;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_BED;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Bemos;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Bhbridge;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BkLeaf;
+DUSK_GAME_EXTERN process_profile_definition g_profile_BkyRock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BmWindow;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BoomShutter;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Bombf;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_BOUMATO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_BRG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_BsGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_awaPlar;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CatDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_CB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ChainBlock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Cdoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Chandelier;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Chest;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Cho;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Cowdoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Crope;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CRVFENCE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CRVGATE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CRVHAHEN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CRVLH_DW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CRVLH_UP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_CRVSTEEL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Crystal;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ChainWall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_DamCps;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Dan;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Digholl;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_DigSnow;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Elevator;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Drop;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_DUST;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_E_CREATE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_FallObj;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Fan;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Fchain;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_FireWood;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_FireWood2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_FirePillar;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_FirePillar2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Flag;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Flag2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Flag3;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_FOOD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_FW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_GADGET;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GanonWall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GanonWall2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_GB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Geyser;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_glowSphere;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_GM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GoGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GOMIKABE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_GRA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_GRA_WALL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GraRock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GraveStone;
+DUSK_GAME_EXTERN process_profile_definition g_profile_GRDWATER;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_GrzRock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_H_Saku;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_HBarrel;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_HFtr;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MHasu;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Hata;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_HB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_HBombkoya;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_HeavySw;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Hfuta;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_HsTarget;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ice_l;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ice_s;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_IceBlock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_IceLeaf;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_IHASI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ikada;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_InoBone;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ITA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_ITAMATO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kabuto;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kag;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KAGE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KAGO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kaisou;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kam;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kantera;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kat;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KazeNeko;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KBOX;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KEY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KEYHOLE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KiPot;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_KITA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KJgjs;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KKanban;
+DUSK_GAME_EXTERN process_profile_definition g_profile_KN_BULLET;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kshutter;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Kuw;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KWheel00;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KWheel01;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KznkArm;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Laundry;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_LndRope;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_LBOX;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_LP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv1Cdl00;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv1Cdl01;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv3Candle;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv3Water;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv3Water2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_LV3WATERB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv3R10Saka;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WaterEff;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv4CandleDm;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv4Candle;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4EdShutter;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4Gate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4HsTarget;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4PoGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4RailWall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4SlideWall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4Bridge;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4Chan;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4DigSand;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4Floor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4Gear;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_PRElvtr;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4PRwall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv4Sand;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv5FBoard;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_IceWall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv5SwIce;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ychndlr;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_YIblltray;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6ChgGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6FuriTrap;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6Lblock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6SwGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6SzGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6Tenbin;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6TogeRoll;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6TogeTrap;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6bemos;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6bemos2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6EGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6ElevtA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv6SwTurn;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv7BsGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv7PropY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv7Bridge;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv8KekkaiTrap;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv8Lift;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv8OptiLift;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv8UdFloor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Lv9SwShutter;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MagLift;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MagLiftRot;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_MAKI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MasterSword;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Mato;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MHole;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_MIE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Mirror6Pole;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MirrorChain;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MirrorSand;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MirrorScrew;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MirrorTable;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_MSIMA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_MvStair;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_MYOGAN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Nagaisu;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Nan;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_NDOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_NOUGU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OCTHASHI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_OILTUBO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Onsen;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_ONSEN_FIRE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_OnsenTaru;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_PushDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_PDtile;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_PDwall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Picture;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Pillar;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_PLEAF;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_poCandle;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_poFire;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_poTbox;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Prop;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_PUMPKIN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RCircle;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RfHole;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RiderGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RIVERROCK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_ROCK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RotBridge;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RotTrap;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_ROTEN;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_RotStair;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_RW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Saidan;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Sakuita;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ItaRope;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SCannon;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SCannonCrs;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SCannonTen;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SEKIDOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SEKIZO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SEKIZOA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Shield;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SM_DOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SmallKey;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SmgDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Smoke;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SMTILE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SmWStone;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_SnowEff;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SnowSoup;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SO;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SpinLift;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SSDRINK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SSITEM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_StairBlock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Stone;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Stopper;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Stopper2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SUISYA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_SW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwBallA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwBallB;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwBallC;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwLight;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwChain;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwHang;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Sword;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Swpush2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwSpinner;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SwTurn;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SyRock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_SZbridge;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TaFence;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Table;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TakaraDai;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_TATIGI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Ten;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TestCube;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Gake;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_THASHI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TimeFire;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_TKS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TMoon;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ToaruMaki;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_TOBY;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TobyHouse;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TogeTrap;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Tombo;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Tornado;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Tornado2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_TP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TREESH;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_TwGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_UDOOR;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_USAKU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_VolcGnd;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_VolcanicBall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_VolcanicBomb;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_KakarikoBrg;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_OrdinBrg;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WtGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WaterPillar;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WaterFall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Wchain;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WdStick;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_WEB0;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_WEB1;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WellCover;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_WFLAG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WindStone;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_Window;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WoodPendulum;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WoodStatue;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_WoodenSword;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_YBAG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_YSTONE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ZoraCloth;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ZDoor;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_zrTurara;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_zrTuraraRc;
+DUSK_GAME_EXTERN process_profile_definition g_profile_ZRA_MARK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_OBJ_ZRAFREEZE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Obj_ZraRock;
+DUSK_GAME_EXTERN process_profile_definition g_profile_PASSER_MNG;
+DUSK_GAME_EXTERN process_profile_definition g_profile_PERU;
+DUSK_GAME_EXTERN process_profile_definition g_profile_PPolamp;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SKIP2D;
+DUSK_GAME_EXTERN process_profile_definition g_profile_START_AND_GOAL;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SwBall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SwLBall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_SwTime;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv6Gate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv7Gate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv8Gate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_TWGate;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Arena;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Assist;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_BTLITM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_ChgRestart;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_CSW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Escape;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_FWall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_GRA;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_GUARD;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Instruction;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_KagoFall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_LightBall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_LV5SOUP;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Lv6CstaSw;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Mmsg;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Mwait;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_MYNA2;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_MNLIGHT;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_PATI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_poFire;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_QS;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_RetRoom;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_RiverBack;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_RmbitSw;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Schedule;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_SetBall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Restart;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_SHOPCAM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_SHOPITM;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_SmkEmt;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Spinner;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Sppath;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_SSDRINK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Stream;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_TheBHint;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_WaraHowl;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_WatchGe;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_WaterFall;
+DUSK_GAME_EXTERN process_profile_definition g_profile_Tag_Wljump;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TAG_YAMI;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TALK;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TBOX_SW;
+DUSK_GAME_EXTERN process_profile_definition g_profile_TITLE;
+DUSK_GAME_EXTERN process_profile_definition g_profile_WarpBug;
 #else
-extern actor_process_profile_definition DUSK_CONST g_profile_ALINK;
-extern actor_process_profile_definition DUSK_CONST g_profile_NO_CHG_ROOM;
-extern actor_process_profile_definition DUSK_CONST g_profile_ITEM;
-extern camera_process_profile_definition DUSK_CONST g_profile_CAMERA;
-extern camera_process_profile_definition DUSK_CONST g_profile_CAMERA2;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_ENVSE;
-extern msg_process_profile_definition DUSK_CONST g_profile_GAMEOVER;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_KANKYO;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_KYEFF;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_KYEFF2;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_KY_THUNDER;
-extern msg_process_profile_definition DUSK_CONST g_profile_MENUWINDOW;
-extern msg_process_profile_definition DUSK_CONST g_profile_METER2;
-extern msg_process_profile_definition DUSK_CONST g_profile_MSG_OBJECT;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP0;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP1;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP6;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP7;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP8;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP9;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP10;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP11;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP2;
-extern overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP3;
-extern scene_process_profile_definition DUSK_CONST g_profile_LOGO_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_MENU_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_NAME_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_NAMEEX_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_PLAY_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_OPENING_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_ROOM_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_WARNING_SCENE;
-extern scene_process_profile_definition DUSK_CONST g_profile_WARNING2_SCENE;
-extern msg_process_profile_definition DUSK_CONST g_profile_TIMER;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_WMARK;
-extern kankyo_process_profile_definition DUSK_CONST g_profile_WPILLAR;
-extern actor_process_profile_definition DUSK_CONST g_profile_ANDSW;
-extern actor_process_profile_definition2 DUSK_CONST g_profile_BG;
-extern actor_process_profile_definition DUSK_CONST g_profile_BG_OBJ;
-extern actor_process_profile_definition DUSK_CONST g_profile_DMIDNA;
-extern actor_process_profile_definition DUSK_CONST g_profile_DBDOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_KNOB20;
-extern actor_process_profile_definition DUSK_CONST g_profile_DOOR20;
-extern actor_process_profile_definition DUSK_CONST g_profile_SPIRAL_DOOR;
-extern actor_process_profile_definition2 DUSK_CONST g_profile_DSHUTTER;
-extern actor_process_profile_definition DUSK_CONST g_profile_EP;
-extern actor_process_profile_definition DUSK_CONST g_profile_HITOBJ;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG00;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG04;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG17;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_BEF;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BurnBox;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Carry;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_ITO;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Movebox;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpush;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Timer;
-extern actor_process_profile_definition2 DUSK_CONST g_profile_PATH_LINE;
-extern actor_process_profile_definition2 DUSK_CONST g_profile_SCENE_EXIT;
-extern actor_process_profile_definition DUSK_CONST g_profile_SET_BG_OBJ;
-extern actor_process_profile_definition DUSK_CONST g_profile_SWHIT0;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_ALLMATO;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_CAMERA;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_CHKPOINT;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_EVENT;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_EVT;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_EVTAREA;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_EVTMSG;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_HOWL;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_KMSG;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_LANTERN;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Mist;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_MSG;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_PUSH;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_TELOP;
-extern actor_process_profile_definition DUSK_CONST g_profile_TBOX;
-extern actor_process_profile_definition DUSK_CONST g_profile_TBOX2;
-extern actor_process_profile_definition DUSK_CONST g_profile_VRBOX;
-extern actor_process_profile_definition DUSK_CONST g_profile_VRBOX2;
-extern actor_process_profile_definition DUSK_CONST g_profile_ARROW;
-extern actor_process_profile_definition DUSK_CONST g_profile_BOOMERANG;
-extern actor_process_profile_definition DUSK_CONST g_profile_CROD;
-extern actor_process_profile_definition DUSK_CONST g_profile_DEMO00;
-extern actor_process_profile_definition DUSK_CONST g_profile_DISAPPEAR;
-extern actor_process_profile_definition DUSK_CONST g_profile_MG_ROD;
-extern actor_process_profile_definition DUSK_CONST g_profile_MIDNA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NBOMB;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_LifeContainer;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Yousei;
-extern actor_process_profile_definition DUSK_CONST g_profile_SPINNER;
-extern actor_process_profile_definition DUSK_CONST g_profile_SUSPEND;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Attp;
-extern actor_process_profile_definition DUSK_CONST g_profile_ALLDIE;
-extern actor_process_profile_definition DUSK_CONST g_profile_ANDSW2;
-extern actor_process_profile_definition DUSK_CONST g_profile_BD;
-extern actor_process_profile_definition DUSK_CONST g_profile_CANOE;
-extern actor_process_profile_definition DUSK_CONST g_profile_CSTAF;
-extern actor_process_profile_definition DUSK_CONST g_profile_Demo_Item;
-extern actor_process_profile_definition DUSK_CONST g_profile_L1BOSS_DOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DN;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_FM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GA;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_HB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_NEST;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_RD;
-extern actor_process_profile_definition DUSK_CONST g_profile_ECONT;
-extern actor_process_profile_definition DUSK_CONST g_profile_FR;
-extern actor_process_profile_definition DUSK_CONST g_profile_GRASS;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG05;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG10;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG11;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG14;
-extern actor_process_profile_definition DUSK_CONST g_profile_MG_FISH;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_BESU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_FAIRY_SEIREI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_FISH;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_HENNA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KAKASHI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KKRI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KOLIN;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_MARO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TARO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TKJ;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BHASHI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BkDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BossWarp;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Cboard;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Digpl;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Eff;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_FMOBJ;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GpTaru;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_HHASHI;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KANBAN2;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KBACKET;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KkrGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KLift00;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_KtOnFire;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ladder;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv2Candle;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MagneArm;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MetalBox;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_NamePlate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_OnCloth;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RopeBridge;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwallShutter;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_STICK;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_StoneMark;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpropeller;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpush5;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Yobikusa;
-extern actor_process_profile_definition DUSK_CONST g_profile_SCENE_EXIT2;
-extern actor_process_profile_definition DUSK_CONST g_profile_ShopItem;
-extern actor_process_profile_definition DUSK_CONST g_profile_SQ;
-extern actor_process_profile_definition DUSK_CONST g_profile_SWC00;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_CstaSw;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_AJnot;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_AttackItem;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Gstart;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Hinit;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Hjump;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Hstop;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv2PrChk;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Magne;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Mhint;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Mstop;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Spring;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Statue;
-extern actor_process_profile_definition DUSK_CONST g_profile_Ykgr;
-extern actor_process_profile_definition DUSK_CONST g_profile_DR;
-extern actor_process_profile_definition DUSK_CONST g_profile_L7lowDr;
-extern actor_process_profile_definition DUSK_CONST g_profile_L7ODR;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_BH;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_BQ;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_DR;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_DRE;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_DS;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_GG;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_GM;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_GND;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_GO;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_GOS;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_MGN;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_OB;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_OH;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_OH2;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_TN;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_YO;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_YOI;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_ZANT;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_ZANTM;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_ZANTZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_B_ZANTS;
-extern actor_process_profile_definition DUSK_CONST g_profile_BALLOON2D;
-extern actor_process_profile_definition DUSK_CONST g_profile_BULLET;
-extern actor_process_profile_definition DUSK_CONST g_profile_COACH2D;
-extern actor_process_profile_definition DUSK_CONST g_profile_COACH_FIRE;
-extern actor_process_profile_definition DUSK_CONST g_profile_COW;
-extern actor_process_profile_definition DUSK_CONST g_profile_CSTATUE;
-extern actor_process_profile_definition DUSK_CONST g_profile_DO;
-extern actor_process_profile_definition DUSK_CONST g_profile_BOSS_DOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_L5BOSS_DOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_L1MBOSS_DOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_PushDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_AI;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_ARROW;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BA;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BEE;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BI;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BI_LEAF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BS;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BU;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_BUG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_CR;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_CR_EGG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DB_LEAF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DD;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DK;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_DT;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_FB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_FK;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_FS;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_FZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GE;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GI;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GOB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_GS;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_HB_LEAF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_HM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_HP;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_HZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_HZELDA;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_IS;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_KG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_KK;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_KR;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MD;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MK;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MK_BO;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MM_MT;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_MS;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_NZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_OC;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_OctBg;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_OT;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_PH;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_PM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_PO;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_PZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_RB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_RDB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_RDY;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_S1;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SH;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SM2;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_ST;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_ST_LINE;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_SW;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_TH;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_TH_BALL;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_TK;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_TK2;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_TK_BALL;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_TT;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_VT;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_WAP;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_WB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_WS;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_WW;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YC;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YD;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YD_LEAF;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YH;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YK;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YM_TAG;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YMB;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_YR;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_ZH;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_ZM;
-extern actor_process_profile_definition DUSK_CONST g_profile_E_ZS;
-extern actor_process_profile_definition DUSK_CONST g_profile_FORMATION_MNG;
-extern actor_process_profile_definition DUSK_CONST g_profile_GUARD_MNG;
-extern actor_process_profile_definition DUSK_CONST g_profile_HORSE;
-extern actor_process_profile_definition DUSK_CONST g_profile_HOZELDA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Izumi_Gate;
-extern actor_process_profile_definition DUSK_CONST g_profile_KAGO;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG01;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG02;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG03;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG06;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG07;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG08;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG09;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG12;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG13;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG15;
-extern actor_process_profile_definition DUSK_CONST g_profile_KYTAG16;
-extern actor_process_profile_definition DUSK_CONST g_profile_MANT;
-extern actor_process_profile_definition DUSK_CONST g_profile_FSHOP;
-extern actor_process_profile_definition DUSK_CONST g_profile_MIRROR;
-extern actor_process_profile_definition DUSK_CONST g_profile_MOVIE_PLAYER;
-extern actor_process_profile_definition DUSK_CONST g_profile_MYNA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ARU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ASH;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ASHB;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_BANS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_BLUENS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_BOU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_BOU_S;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_CD3;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_CHAT;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_CHIN;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_CLERKA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_CLERKB;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_CLERKT;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_COACH;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_DF;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_DOC;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_DOORBOY;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_DRSOL;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_DU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_FAIRY;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_FGUARD;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GND;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRC;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRD;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRM;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRMC;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRR;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GRZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GUARD;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_GWOLF;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_HANJO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_HENNA0;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_HOZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_IMPAL;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_INKO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_INS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_JAGAR;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KASIHANA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KASIKYU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KASIMICH;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KDK;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KN;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KNJ;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KOLINB;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_KYURY;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_LEN;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_LF;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_LUD;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_MIDP;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_MK;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_MOI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_MOIR;
-extern actor_process_profile_definition DUSK_CONST g_profile_MYNA2;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_NE;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_P2;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_PACHI_BESU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_PACHI_MARO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_PACHI_TARO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_PASSER;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_PASSER2;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_POST;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_POUYA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_PRAYER;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_RACA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_RAFREL;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SARU;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIB;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIC;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SEID;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIRA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SERA2;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIREI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SHAD;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SHAMAN;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SHOE;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SHOP0;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SMARO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SOLA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SOLDIERa;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SOLDIERb;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_SQ;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_THE;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_THEB;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TK;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TKC;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TKJ2;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TKS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TOBY;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_TR;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_URI;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_WORM;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_WRESTLER;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_YAMID;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_YAMIS;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_YAMIT;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_YELIA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_YKM;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_YKW;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZANB;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZANT;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZELR;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZELRO;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZELDA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZRA;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZRC;
-extern actor_process_profile_definition DUSK_CONST g_profile_NPC_ZRZ;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv5Key;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Turara;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TvCdlst;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ytaihou;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_AmiShutter;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ari;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_AUTOMATA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Avalanche;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_BALLOON;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BarDesk;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Batta;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BBox;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_BED;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Bemos;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Bhbridge;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BkLeaf;
-extern actor_process_profile_definition DUSK_CONST g_profile_BkyRock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BmWindow;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BoomShutter;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Bombf;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_BOUMATO;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_BRG;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_BsGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_awaPlar;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CatDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_CB;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ChainBlock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Cdoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Chandelier;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Chest;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Cho;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Cowdoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Crope;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVFENCE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVGATE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVHAHEN;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVLH_DW;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVLH_UP;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVSTEEL;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Crystal;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ChainWall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_DamCps;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Dan;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Digholl;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_DigSnow;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Elevator;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Drop;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_DUST;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_E_CREATE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_FallObj;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Fan;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Fchain;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_FireWood;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_FireWood2;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_FirePillar;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_FirePillar2;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Flag;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Flag2;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Flag3;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_FOOD;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_FW;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_GADGET;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GanonWall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GanonWall2;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_GB;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Geyser;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_glowSphere;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_GM;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GoGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GOMIKABE;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_GRA;
-extern actor_process_profile_definition DUSK_CONST g_profile_GRA_WALL;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GraRock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GraveStone;
-extern actor_process_profile_definition DUSK_CONST g_profile_GRDWATER;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_GrzRock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_H_Saku;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_HBarrel;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_HFtr;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MHasu;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Hata;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_HB;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_HBombkoya;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_HeavySw;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Hfuta;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_HsTarget;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ice_l;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ice_s;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_IceBlock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_IceLeaf;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_IHASI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ikada;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_InoBone;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ITA;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_ITAMATO;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kabuto;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kag;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KAGE;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KAGO;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kaisou;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kam;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kantera;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kat;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KazeNeko;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KBOX;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KEY;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KEYHOLE;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KiPot;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_KITA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KJgjs;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KKanban;
-extern actor_process_profile_definition DUSK_CONST g_profile_KN_BULLET;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kshutter;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Kuw;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KWheel00;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KWheel01;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KznkArm;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Laundry;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_LndRope;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_LBOX;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_LP;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv1Cdl00;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv1Cdl01;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3Candle;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3Water;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3Water2;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_LV3WATERB;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3R10Saka;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WaterEff;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv4CandleDm;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv4Candle;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4EdShutter;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Gate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4HsTarget;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4PoGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4RailWall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4SlideWall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Bridge;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Chan;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4DigSand;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Floor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Gear;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_PRElvtr;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4PRwall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Sand;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv5FBoard;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_IceWall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv5SwIce;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ychndlr;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_YIblltray;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6ChgGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6FuriTrap;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6Lblock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6SwGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6SzGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6Tenbin;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6TogeRoll;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6TogeTrap;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6bemos;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6bemos2;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6EGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6ElevtA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6SwTurn;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv7BsGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv7PropY;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv7Bridge;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8KekkaiTrap;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8Lift;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8OptiLift;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8UdFloor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv9SwShutter;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MagLift;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MagLiftRot;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_MAKI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MasterSword;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Mato;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MHole;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_MIE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Mirror6Pole;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorChain;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorSand;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorScrew;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorTable;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_MSIMA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_MvStair;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_MYOGAN;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Nagaisu;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Nan;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_NDOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_NOUGU;
-extern actor_process_profile_definition DUSK_CONST g_profile_OCTHASHI;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_OILTUBO;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Onsen;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_ONSEN_FIRE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_OnsenTaru;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_PushDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_PDtile;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_PDwall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Picture;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Pillar;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_PLEAF;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_poCandle;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_poFire;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_poTbox;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Prop;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_PUMPKIN;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RCircle;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RfHole;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RiderGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RIVERROCK;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_ROCK;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RotBridge;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RotTrap;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_ROTEN;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_RotStair;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_RW;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Saidan;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Sakuita;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ItaRope;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SCannon;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SCannonCrs;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SCannonTen;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SEKIDOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SEKIZO;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SEKIZOA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Shield;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SM_DOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SmallKey;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SmgDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Smoke;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SMTILE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SmWStone;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_SnowEff;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SnowSoup;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SO;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SpinLift;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SSDRINK;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SSITEM;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_StairBlock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Stone;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Stopper;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Stopper2;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SUISYA;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_SW;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwBallA;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwBallB;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwBallC;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwLight;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwChain;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwHang;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Sword;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpush2;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwSpinner;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SwTurn;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SyRock;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_SZbridge;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TaFence;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Table;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TakaraDai;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_TATIGI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Ten;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TestCube;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Gake;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ALINK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NO_CHG_ROOM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ITEM;
+DUSK_GAME_EXTERN camera_process_profile_definition DUSK_CONST g_profile_CAMERA;
+DUSK_GAME_EXTERN camera_process_profile_definition DUSK_CONST g_profile_CAMERA2;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_ENVSE;
+DUSK_GAME_EXTERN msg_process_profile_definition DUSK_CONST g_profile_GAMEOVER;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_KANKYO;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_KYEFF;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_KYEFF2;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_KY_THUNDER;
+DUSK_GAME_EXTERN msg_process_profile_definition DUSK_CONST g_profile_MENUWINDOW;
+DUSK_GAME_EXTERN msg_process_profile_definition DUSK_CONST g_profile_METER2;
+DUSK_GAME_EXTERN msg_process_profile_definition DUSK_CONST g_profile_MSG_OBJECT;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP0;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP1;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP6;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP7;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP8;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP9;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP10;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP11;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP2;
+DUSK_GAME_EXTERN overlap_process_profile_definition DUSK_CONST g_profile_OVERLAP3;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_LOGO_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_MENU_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_NAME_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_NAMEEX_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_PLAY_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_OPENING_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_ROOM_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_WARNING_SCENE;
+DUSK_GAME_EXTERN scene_process_profile_definition DUSK_CONST g_profile_WARNING2_SCENE;
+DUSK_GAME_EXTERN msg_process_profile_definition DUSK_CONST g_profile_TIMER;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_WMARK;
+DUSK_GAME_EXTERN kankyo_process_profile_definition DUSK_CONST g_profile_WPILLAR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ANDSW;
+DUSK_GAME_EXTERN actor_process_profile_definition2 DUSK_CONST g_profile_BG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BG_OBJ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DMIDNA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DBDOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KNOB20;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DOOR20;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SPIRAL_DOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition2 DUSK_CONST g_profile_DSHUTTER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_EP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_HITOBJ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG00;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG04;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG17;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_BEF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BurnBox;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Carry;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_ITO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Movebox;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpush;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Timer;
+DUSK_GAME_EXTERN actor_process_profile_definition2 DUSK_CONST g_profile_PATH_LINE;
+DUSK_GAME_EXTERN actor_process_profile_definition2 DUSK_CONST g_profile_SCENE_EXIT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SET_BG_OBJ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SWHIT0;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_ALLMATO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_CAMERA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_CHKPOINT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_EVENT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_EVT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_EVTAREA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_EVTMSG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_HOWL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_KMSG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_LANTERN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Mist;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_MSG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_PUSH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_TELOP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TBOX;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TBOX2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_VRBOX;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_VRBOX2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ARROW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BOOMERANG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_CROD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DEMO00;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DISAPPEAR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MG_ROD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MIDNA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NBOMB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_LifeContainer;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Yousei;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SPINNER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SUSPEND;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Attp;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ALLDIE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ANDSW2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_CANOE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_CSTAF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Demo_Item;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_L1BOSS_DOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_FM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_HB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_NEST;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_RD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ECONT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_FR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_GRASS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG05;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG10;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG11;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG14;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MG_FISH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_BESU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_FAIRY_SEIREI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_FISH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_HENNA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KAKASHI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KKRI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KOLIN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_MARO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TARO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TKJ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BHASHI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BkDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BossWarp;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Cboard;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Digpl;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Eff;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_FMOBJ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GpTaru;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_HHASHI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KANBAN2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KBACKET;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KkrGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KLift00;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_KtOnFire;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ladder;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv2Candle;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MagneArm;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MetalBox;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_NamePlate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_OnCloth;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RopeBridge;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwallShutter;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_STICK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_StoneMark;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpropeller;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpush5;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Yobikusa;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SCENE_EXIT2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ShopItem;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SQ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SWC00;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_CstaSw;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_AJnot;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_AttackItem;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Gstart;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Hinit;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Hjump;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Hstop;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv2PrChk;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Magne;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Mhint;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Mstop;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Spring;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Statue;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Ykgr;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_L7lowDr;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_L7ODR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_BH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_BQ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_DR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_DRE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_DS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_GG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_GM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_GND;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_GO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_GOS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_MGN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_OB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_OH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_OH2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_TN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_YO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_YOI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_ZANT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_ZANTM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_ZANTZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_B_ZANTS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BALLOON2D;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BULLET;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_COACH2D;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_COACH_FIRE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_COW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_CSTATUE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_DO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BOSS_DOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_L5BOSS_DOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_L1MBOSS_DOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_PushDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_AI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_ARROW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BEE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BI_LEAF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_BUG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_CR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_CR_EGG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DB_LEAF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_DT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_FB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_FK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_FS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_FZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GOB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_GS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_HB_LEAF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_HM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_HP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_HZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_HZELDA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_IS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_KG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_KK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_KR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MK_BO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MM_MT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_MS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_NZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_OC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_OctBg;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_OT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_PH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_PM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_PO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_PZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_RB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_RDB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_RDY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_S1;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SM2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_ST;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_ST_LINE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_SW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_TH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_TH_BALL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_TK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_TK2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_TK_BALL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_TT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_VT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_WAP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_WB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_WS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_WW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YD_LEAF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YM_TAG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YMB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_YR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_ZH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_ZM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_E_ZS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_FORMATION_MNG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_GUARD_MNG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_HORSE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_HOZELDA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Izumi_Gate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KAGO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG01;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG02;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG03;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG06;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG07;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG08;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG09;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG12;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG13;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG15;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KYTAG16;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MANT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_FSHOP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MIRROR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MOVIE_PLAYER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MYNA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ARU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ASH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ASHB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_BANS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_BLUENS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_BOU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_BOU_S;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_CD3;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_CHAT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_CHIN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_CLERKA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_CLERKB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_CLERKT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_COACH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_DF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_DOC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_DOORBOY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_DRSOL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_DU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_FAIRY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_FGUARD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GND;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRMC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GRZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GUARD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_GWOLF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_HANJO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_HENNA0;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_HOZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_IMPAL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_INKO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_INS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_JAGAR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KASIHANA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KASIKYU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KASIMICH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KDK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KNJ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KOLINB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_KYURY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_LEN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_LF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_LUD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_MIDP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_MK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_MOI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_MOIR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_MYNA2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_NE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_P2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_PACHI_BESU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_PACHI_MARO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_PACHI_TARO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_PASSER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_PASSER2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_POST;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_POUYA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_PRAYER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_RACA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_RAFREL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SARU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SEID;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIRA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SERA2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SEIREI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SHAD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SHAMAN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SHOE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SHOP0;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SMARO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SOLA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SOLDIERa;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SOLDIERb;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_SQ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_THE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_THEB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TKC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TKJ2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TKS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TOBY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_TR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_URI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_WORM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_WRESTLER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_YAMID;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_YAMIS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_YAMIT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_YELIA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_YKM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_YKW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZANB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZANT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZELR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZELRO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZELDA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZRA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZRC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_NPC_ZRZ;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv5Key;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Turara;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TvCdlst;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ytaihou;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_AmiShutter;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ari;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_AUTOMATA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Avalanche;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_BALLOON;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BarDesk;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Batta;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BBox;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_BED;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Bemos;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Bhbridge;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BkLeaf;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_BkyRock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BmWindow;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BoomShutter;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Bombf;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_BOUMATO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_BRG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_BsGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_awaPlar;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CatDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_CB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ChainBlock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Cdoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Chandelier;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Chest;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Cho;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Cowdoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Crope;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVFENCE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVGATE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVHAHEN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVLH_DW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVLH_UP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_CRVSTEEL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Crystal;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ChainWall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_DamCps;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Dan;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Digholl;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_DigSnow;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Elevator;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Drop;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_DUST;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_E_CREATE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_FallObj;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Fan;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Fchain;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_FireWood;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_FireWood2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_FirePillar;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_FirePillar2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Flag;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Flag2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Flag3;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_FOOD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_FW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_GADGET;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GanonWall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GanonWall2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_GB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Geyser;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_glowSphere;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_GM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GoGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GOMIKABE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_GRA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_GRA_WALL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GraRock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GraveStone;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_GRDWATER;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_GrzRock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_H_Saku;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_HBarrel;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_HFtr;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MHasu;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Hata;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_HB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_HBombkoya;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_HeavySw;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Hfuta;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_HsTarget;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ice_l;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ice_s;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_IceBlock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_IceLeaf;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_IHASI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ikada;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_InoBone;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ITA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_ITAMATO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kabuto;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kag;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KAGE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KAGO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kaisou;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kam;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kantera;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kat;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KazeNeko;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KBOX;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KEY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KEYHOLE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KiPot;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_KITA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KJgjs;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KKanban;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_KN_BULLET;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kshutter;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Kuw;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KWheel00;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KWheel01;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KznkArm;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Laundry;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_LndRope;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_LBOX;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_LP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv1Cdl00;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv1Cdl01;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3Candle;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3Water;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3Water2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_LV3WATERB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv3R10Saka;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WaterEff;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv4CandleDm;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv4Candle;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4EdShutter;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Gate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4HsTarget;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4PoGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4RailWall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4SlideWall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Bridge;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Chan;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4DigSand;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Floor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Gear;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_PRElvtr;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4PRwall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv4Sand;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv5FBoard;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_IceWall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv5SwIce;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ychndlr;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_YIblltray;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6ChgGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6FuriTrap;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6Lblock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6SwGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6SzGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6Tenbin;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6TogeRoll;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6TogeTrap;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6bemos;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6bemos2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6EGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6ElevtA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv6SwTurn;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv7BsGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv7PropY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv7Bridge;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8KekkaiTrap;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8Lift;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8OptiLift;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv8UdFloor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Lv9SwShutter;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MagLift;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MagLiftRot;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_MAKI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MasterSword;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Mato;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MHole;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_MIE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Mirror6Pole;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorChain;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorSand;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorScrew;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MirrorTable;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_MSIMA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_MvStair;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_MYOGAN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Nagaisu;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Nan;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_NDOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_NOUGU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OCTHASHI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_OILTUBO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Onsen;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_ONSEN_FIRE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_OnsenTaru;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_PushDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_PDtile;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_PDwall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Picture;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Pillar;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_PLEAF;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_poCandle;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_poFire;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_poTbox;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Prop;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_PUMPKIN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RCircle;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RfHole;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RiderGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RIVERROCK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_ROCK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RotBridge;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RotTrap;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_ROTEN;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_RotStair;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_RW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Saidan;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Sakuita;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ItaRope;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SCannon;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SCannonCrs;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SCannonTen;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SEKIDOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SEKIZO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SEKIZOA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Shield;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SM_DOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SmallKey;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SmgDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Smoke;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SMTILE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SmWStone;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_SnowEff;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SnowSoup;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SO;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SpinLift;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SSDRINK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SSITEM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_StairBlock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Stone;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Stopper;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Stopper2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SUISYA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_SW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwBallA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwBallB;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwBallC;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwLight;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwChain;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwHang;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Sword;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Swpush2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwSpinner;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SwTurn;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SyRock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_SZbridge;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TaFence;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Table;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TakaraDai;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_TATIGI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Ten;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TestCube;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Gake;
 
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_THASHI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TimeFire;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_TKS;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TMoon;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ToaruMaki;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_TOBY;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TobyHouse;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TogeTrap;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Tombo;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Tornado;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Tornado2;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_TP;
-extern actor_process_profile_definition DUSK_CONST g_profile_TREESH;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_TwGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_UDOOR;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_USAKU;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_VolcGnd;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_VolcanicBall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_VolcanicBomb;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_KakarikoBrg;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_OrdinBrg;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WtGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WaterPillar;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WaterFall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Wchain;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WdStick;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_WEB0;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_WEB1;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WellCover;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_WFLAG;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WindStone;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_Window;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WoodPendulum;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WoodStatue;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_WoodenSword;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_YBAG;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_YSTONE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ZoraCloth;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ZDoor;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_zrTurara;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_zrTuraraRc;
-extern actor_process_profile_definition DUSK_CONST g_profile_ZRA_MARK;
-extern actor_process_profile_definition DUSK_CONST g_profile_OBJ_ZRAFREEZE;
-extern actor_process_profile_definition DUSK_CONST g_profile_Obj_ZraRock;
-extern actor_process_profile_definition DUSK_CONST g_profile_PASSER_MNG;
-extern actor_process_profile_definition DUSK_CONST g_profile_PERU;
-extern actor_process_profile_definition DUSK_CONST g_profile_PPolamp;
-extern actor_process_profile_definition DUSK_CONST g_profile_SKIP2D;
-extern actor_process_profile_definition DUSK_CONST g_profile_START_AND_GOAL;
-extern actor_process_profile_definition DUSK_CONST g_profile_SwBall;
-extern actor_process_profile_definition DUSK_CONST g_profile_SwLBall;
-extern actor_process_profile_definition DUSK_CONST g_profile_SwTime;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv6Gate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv7Gate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv8Gate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_TWGate;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Arena;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Assist;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_BTLITM;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_ChgRestart;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_CSW;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Escape;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_FWall;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_GRA;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_GUARD;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Instruction;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_KagoFall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_LightBall;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_LV5SOUP;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv6CstaSw;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Mmsg;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Mwait;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_MYNA2;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_MNLIGHT;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_PATI;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_poFire;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_QS;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_RetRoom;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_RiverBack;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_RmbitSw;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Schedule;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_SetBall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Restart;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_SHOPCAM;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_SHOPITM;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_SmkEmt;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Spinner;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Sppath;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_SSDRINK;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Stream;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_TheBHint;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_WaraHowl;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_WatchGe;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_WaterFall;
-extern actor_process_profile_definition DUSK_CONST g_profile_Tag_Wljump;
-extern actor_process_profile_definition DUSK_CONST g_profile_TAG_YAMI;
-extern actor_process_profile_definition DUSK_CONST g_profile_TALK;
-extern actor_process_profile_definition DUSK_CONST g_profile_TBOX_SW;
-extern actor_process_profile_definition DUSK_CONST g_profile_TITLE;
-extern actor_process_profile_definition DUSK_CONST g_profile_WarpBug;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_THASHI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TimeFire;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_TKS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TMoon;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ToaruMaki;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_TOBY;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TobyHouse;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TogeTrap;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Tombo;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Tornado;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Tornado2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_TP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TREESH;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_TwGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_UDOOR;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_USAKU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_VolcGnd;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_VolcanicBall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_VolcanicBomb;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_KakarikoBrg;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_OrdinBrg;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WtGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WaterPillar;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WaterFall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Wchain;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WdStick;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_WEB0;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_WEB1;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WellCover;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_WFLAG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WindStone;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_Window;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WoodPendulum;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WoodStatue;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_WoodenSword;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_YBAG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_YSTONE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ZoraCloth;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ZDoor;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_zrTurara;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_zrTuraraRc;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_ZRA_MARK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_OBJ_ZRAFREEZE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Obj_ZraRock;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_PASSER_MNG;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_PERU;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_PPolamp;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SKIP2D;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_START_AND_GOAL;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SwBall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SwLBall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_SwTime;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv6Gate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv7Gate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv8Gate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_TWGate;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Arena;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Assist;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_BTLITM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_ChgRestart;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_CSW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Escape;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_FWall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_GRA;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_GUARD;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Instruction;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_KagoFall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_LightBall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_LV5SOUP;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Lv6CstaSw;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Mmsg;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Mwait;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_MYNA2;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_MNLIGHT;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_PATI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_poFire;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_QS;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_RetRoom;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_RiverBack;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_RmbitSw;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Schedule;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_SetBall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Restart;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_SHOPCAM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_SHOPITM;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_SmkEmt;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Spinner;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Sppath;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_SSDRINK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Stream;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_TheBHint;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_WaraHowl;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_WatchGe;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_WaterFall;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_Tag_Wljump;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TAG_YAMI;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TALK;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TBOX_SW;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_TITLE;
+DUSK_GAME_EXTERN actor_process_profile_definition DUSK_CONST g_profile_WarpBug;
 #endif
 
-extern process_profile_definition DUSK_CONST* DUSK_CONST g_fpcPfLst_ProfileList[];
+DUSK_GAME_EXTERN process_profile_definition DUSK_CONST* DUSK_CONST g_fpcPfLst_ProfileList[];
 
 #endif /* F_PC_PROFILE_LST_H_ */
diff --git a/include/global.h b/include/global.h
index 5add912748..c559435fa5 100644
--- a/include/global.h
+++ b/include/global.h
@@ -83,11 +83,15 @@ extern void __dcbf(void*, int);
 extern void __dcbz(void*, int);
 extern void __sync();
 extern int __abs(int);
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define __memcpy memcpy
+#else
 #if defined(__has_builtin) && __has_builtin(__builtin_memcpy)
 #define __memcpy __builtin_memcpy
 #else
 #define __memcpy memcpy
 #endif
+#endif
 #ifdef __cplusplus
 }
 #endif
@@ -114,18 +118,22 @@ inline int __builtin_clz(unsigned int v) {
 
 #endif
 
-// Data symbols exported from the main exe need dllimport on the mod side.
-// DUSK_BUILDING_GAME is defined for the game build so the same headers work in both.
+// Data symbols exported from the main exe need dllimport on the mod side. The game itself
+// exports them through its generated .def, so the annotation is otherwise intentionally empty.
 #if defined(TARGET_PC) && defined(_WIN32) && !defined(DUSK_BUILDING_GAME)
-#define DUSK_GAME_EXTERN extern __declspec(dllimport)
 #define DUSK_GAME_DATA __declspec(dllimport)
-#elif defined(TARGET_PC) && defined(_WIN32) && defined(DUSK_BUILDING_GAME)
-#define DUSK_GAME_EXTERN extern __declspec(dllexport)
-#define DUSK_GAME_DATA __declspec(dllexport)
 #else
-#define DUSK_GAME_EXTERN extern
 #define DUSK_GAME_DATA
 #endif
+#define DUSK_GAME_EXTERN extern DUSK_GAME_DATA
+
+#if defined(_MSC_VER)
+#define DUSK_NOINLINE __declspec(noinline)
+#elif defined(__GNUC__)
+#define DUSK_NOINLINE __attribute__((noinline))
+#else
+#define DUSK_NOINLINE
+#endif
 
 #define FAST_DIV(x, n) (x >> (n / 2))
 
@@ -260,4 +268,23 @@ using std::isnan;
 #define DUSK_CONST IF_DUSK(const)
 #define DUSK_CONSTEXPR IF_DUSK(constexpr)
 
+#if TARGET_PC && defined(DUSK_BUILDING_GAME)
+#include "dusk/mods/item.hpp"
+#define DUSK_ITEM_CHECK(name, item_no, giver)                                                      \
+    (item_no) = ::dusk::mods::item_check_commit(name, (item_no), giver).itemNo
+#define DUSK_ITEM_CHECK_EXPR(name, item_no, giver)                                                 \
+    (::dusk::mods::item_check_commit(name, (item_no), giver).itemNo)
+#define DUSK_ITEM_CHECK_PREVIEW(name, item_no, giver)                                              \
+    (item_no) = ::dusk::mods::item_check(name, (item_no), giver)
+#define DUSK_ITEM_CHECK_PREVIEW_EXPR(name, item_no, giver)                                         \
+    (::dusk::mods::item_check(name, (item_no), giver))
+#define DUSK_GIVE_TAG(name) IF_DUSK_ARG(::dusk::mods::item_give_tag(name))
+#else
+#define DUSK_ITEM_CHECK(name, item_no, giver)
+#define DUSK_ITEM_CHECK_EXPR(name, item_no, giver) (item_no)
+#define DUSK_ITEM_CHECK_PREVIEW(name, item_no, giver)
+#define DUSK_ITEM_CHECK_PREVIEW_EXPR(name, item_no, giver) (item_no)
+#define DUSK_GIVE_TAG(name)
+#endif
+
 #endif
diff --git a/include/helpers/README.md b/include/helpers/README.md
new file mode 100644
index 0000000000..d14f1e1b36
--- /dev/null
+++ b/include/helpers/README.md
@@ -0,0 +1,12 @@
+# Public game helpers
+
+Headers in this directory provide port-specific types and utilities used by ordinary game
+headers. Their corresponding implementations live in `src/helpers/`.
+
+These helpers **must not** depend on internal `src/dusk/` declarations in their public interface.
+Unlike the internal `dusk::` namespace, they are exposed to mods that use the `game` feature
+and therefore must remain ABI stable within `GameService` major versions.
+
+APIs _specifically_ for mod use do not belong here; instead they belong in mod services,
+which are individually versioned, can provide backwards compatibility, and are designed to
+keep track of per-mod runtime state.
diff --git a/src/dusk/batch.hpp b/include/helpers/batch.hpp
similarity index 90%
rename from src/dusk/batch.hpp
rename to include/helpers/batch.hpp
index 2569f27761..0eaeb17a2c 100644
--- a/src/dusk/batch.hpp
+++ b/include/helpers/batch.hpp
@@ -2,7 +2,7 @@
 
 #include <dolphin/types.h>
 
-namespace dusk::batch {
+namespace batch {
 
 struct LeafTemplate {
     static constexpr u32 kMaxVtx = 192;
@@ -22,4 +22,4 @@ struct LeafTemplate {
 
 void decode_leaf_template(const u8* dl, u32 size, LeafTemplate& out);
 
-}  // namespace dusk
+}  // namespace batch
diff --git a/include/helpers/bits.hpp b/include/helpers/bits.hpp
new file mode 100644
index 0000000000..73442d337b
--- /dev/null
+++ b/include/helpers/bits.hpp
@@ -0,0 +1,178 @@
+#pragma once
+
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+
+namespace dusk {
+namespace detail {
+
+template <size_t Size>
+struct uint_of_size;
+
+template <>
+struct uint_of_size<1> {
+    using type = uint8_t;
+};
+
+template <>
+struct uint_of_size<2> {
+    using type = uint16_t;
+};
+
+template <>
+struct uint_of_size<4> {
+    using type = uint32_t;
+};
+
+template <>
+struct uint_of_size<8> {
+    using type = uint64_t;
+};
+
+template <size_t Size>
+using uint_of_size_t = uint_of_size<Size>::type;
+
+template <typename T>
+    requires(std::is_trivially_copyable_v<T>)
+T unaligned_load(const void* source) noexcept {
+    T value;
+    std::memcpy(&value, source, sizeof(value));
+    return value;
+}
+
+template <typename T>
+    requires(std::is_trivially_copyable_v<T>)
+void unaligned_store(void* destination, T value) noexcept {
+    std::memcpy(destination, &value, sizeof(value));
+}
+
+}  // namespace detail
+
+template <typename T>
+    requires(std::is_unsigned_v<T>)
+constexpr T bswap(T value) noexcept {
+    if constexpr (sizeof(T) == 1) {
+        return value;
+    } else if constexpr (sizeof(T) == 2) {
+        return static_cast<T>((value << 8) | (value >> 8));
+    } else if constexpr (sizeof(T) == 4) {
+        return static_cast<T>(((value & 0x000000ffU) << 24) | ((value & 0x0000ff00U) << 8) |
+                              ((value & 0x00ff0000U) >> 8) | ((value & 0xff000000U) >> 24));
+    } else {
+        static_assert(sizeof(T) == 8);
+        return static_cast<T>(
+            ((value & 0x00000000000000ffULL) << 56) | ((value & 0x000000000000ff00ULL) << 40) |
+            ((value & 0x0000000000ff0000ULL) << 24) | ((value & 0x00000000ff000000ULL) << 8) |
+            ((value & 0x000000ff00000000ULL) >> 8) | ((value & 0x0000ff0000000000ULL) >> 24) |
+            ((value & 0x00ff000000000000ULL) >> 40) | ((value & 0xff00000000000000ULL) >> 56));
+    }
+}
+
+/// Reads an unaligned integral value in the specified byte order.
+template <typename T>
+    requires(std::is_integral_v<T> && !std::is_same_v<T, bool>)
+T read_bits(const void* source, std::endian endian = std::endian::big) noexcept {
+    using Bits = std::make_unsigned_t<T>;
+    Bits value = detail::unaligned_load<Bits>(source);
+    if constexpr (sizeof(Bits) > 1) {
+        if (endian != std::endian::native) {
+            value = bswap(value);
+        }
+    }
+    return std::bit_cast<T>(value);
+}
+
+template <typename T>
+    requires(std::is_integral_v<T> && !std::is_same_v<T, bool>)
+constexpr T read_bits(const uint8_t* source, std::endian endian = std::endian::big) noexcept {
+    if (!std::is_constant_evaluated()) {
+        return read_bits<T>(static_cast<const void*>(source), endian);
+    }
+    using Bits = std::make_unsigned_t<T>;
+    Bits value{};
+    if (endian == std::endian::big) {
+        for (size_t i = 0; i < sizeof(Bits); ++i) {
+            value = static_cast<Bits>((value << 8) | source[i]);
+        }
+    } else {
+        for (size_t i = 0; i < sizeof(Bits); ++i) {
+            value |= static_cast<Bits>(source[i]) << (i * 8);
+        }
+    }
+    return std::bit_cast<T>(value);
+}
+
+/// Reads an unaligned floating-point value in the specified byte order.
+template <typename T>
+    requires(
+        std::is_floating_point_v<T> && requires { typename detail::uint_of_size_t<sizeof(T)>; })
+T read_bits(const void* source, std::endian endian = std::endian::big) noexcept {
+    using Bits = detail::uint_of_size_t<sizeof(T)>;
+    return std::bit_cast<T>(read_bits<Bits>(source, endian));
+}
+
+template <typename T>
+    requires(
+        std::is_floating_point_v<T> && requires { typename detail::uint_of_size_t<sizeof(T)>; })
+constexpr T read_bits(const uint8_t* source, std::endian endian = std::endian::big) noexcept {
+    using Bits = detail::uint_of_size_t<sizeof(T)>;
+    return std::bit_cast<T>(read_bits<Bits>(source, endian));
+}
+
+/// Writes an unaligned integral value in the specified byte order.
+template <typename T>
+    requires(std::is_integral_v<T> && !std::is_same_v<T, bool>)
+void write_bits(void* destination, T value, std::endian endian = std::endian::big) noexcept {
+    using Bits = std::make_unsigned_t<T>;
+    Bits bits = std::bit_cast<Bits>(value);
+    if constexpr (sizeof(Bits) > 1) {
+        if (endian != std::endian::native) {
+            bits = bswap(bits);
+        }
+    }
+    detail::unaligned_store(destination, bits);
+}
+
+template <typename T>
+    requires(std::is_integral_v<T> && !std::is_same_v<T, bool>)
+constexpr void write_bits(
+    uint8_t* destination, T value, std::endian endian = std::endian::big) noexcept {
+    if (!std::is_constant_evaluated()) {
+        write_bits(static_cast<void*>(destination), value, endian);
+        return;
+    }
+    using Bits = std::make_unsigned_t<T>;
+    const Bits bits = std::bit_cast<Bits>(value);
+    if (endian == std::endian::big) {
+        for (size_t i = 0; i < sizeof(Bits); ++i) {
+            destination[sizeof(Bits) - i - 1] = static_cast<uint8_t>(bits >> (i * 8));
+        }
+    } else {
+        for (size_t i = 0; i < sizeof(Bits); ++i) {
+            destination[i] = static_cast<uint8_t>(bits >> (i * 8));
+        }
+    }
+}
+
+/// Writes an unaligned floating-point value in the specified byte order.
+template <typename T>
+    requires(
+        std::is_floating_point_v<T> && requires { typename detail::uint_of_size_t<sizeof(T)>; })
+void write_bits(void* destination, T value, std::endian endian = std::endian::big) noexcept {
+    using Bits = detail::uint_of_size_t<sizeof(T)>;
+    write_bits(destination, std::bit_cast<Bits>(value), endian);
+}
+
+template <typename T>
+    requires(
+        std::is_floating_point_v<T> && requires { typename detail::uint_of_size_t<sizeof(T)>; })
+constexpr void write_bits(
+    uint8_t* destination, T value, std::endian endian = std::endian::big) noexcept {
+    using Bits = detail::uint_of_size_t<sizeof(T)>;
+    write_bits(destination, std::bit_cast<Bits>(value), endian);
+}
+
+}  // namespace dusk
diff --git a/include/dusk/endian.h b/include/helpers/endian.h
similarity index 98%
rename from include/dusk/endian.h
rename to include/helpers/endian.h
index d16d0aa80c..689f9f0dab 100644
--- a/include/dusk/endian.h
+++ b/include/helpers/endian.h
@@ -1,5 +1,4 @@
-#ifndef DOLPHIN_ENDIAN_H
-#define DOLPHIN_ENDIAN_H
+#pragma once
 
 #include <bit>
 
@@ -292,6 +291,3 @@ inline void be_swap(Mtx& val) {
 #define BE(T) T
 #define BE_HOST(T) (T)
 #endif
-
-
-#endif // DOLPHIN_ENDIAN_H
diff --git a/include/dusk/endian_gx.hpp b/include/helpers/endian_gx.hpp
similarity index 100%
rename from include/dusk/endian_gx.hpp
rename to include/helpers/endian_gx.hpp
diff --git a/include/dusk/endian_ssystem.h b/include/helpers/endian_ssystem.h
similarity index 93%
rename from include/dusk/endian_ssystem.h
rename to include/helpers/endian_ssystem.h
index fe9248ffa4..b383ef6e43 100644
--- a/include/dusk/endian_ssystem.h
+++ b/include/helpers/endian_ssystem.h
@@ -1,5 +1,4 @@
-#ifndef _DUSK_ENDIAN_SSYSTEM_H_
-#define _DUSK_ENDIAN_SSYSTEM_H_
+#pragma once
 
 #include "SSystem/SComponent/c_sxyz.h"
 #include "endian.h"
@@ -61,5 +60,3 @@ struct BE<cXyz> {
         };
     }
 };
-
-#endif
\ No newline at end of file
diff --git a/include/dusk/gx_helper.h b/include/helpers/gx_helper.h
similarity index 94%
rename from include/dusk/gx_helper.h
rename to include/helpers/gx_helper.h
index 02a36fc6db..32cf340ed5 100644
--- a/include/dusk/gx_helper.h
+++ b/include/helpers/gx_helper.h
@@ -1,12 +1,17 @@
-#ifndef DUSK_GX_HELPER_H
-#define DUSK_GX_HELPER_H
+#pragma once
 
 #include <cstring>
 
 #include <dolphin/gx/GXAurora.h>
 #include <dolphin/gx/GXExtra.h>
 
-#include "profiling.hpp"
+#if defined(DUSK_BUILDING_GAME)
+#include <tracy/Tracy.hpp>
+#else
+#ifndef ZoneScopedN
+#define ZoneScopedN(name)
+#endif
+#endif
 
 #if DUSK_GFX_DEBUG_GROUPS
 #define GX_DEBUG_GROUP(name, ...) \
@@ -79,5 +84,3 @@ struct GXScopedDebugGroup {
 };
 
 #define GX_AND_TRACY_SCOPED(name) GXScopedDebugGroup scope(name); ZoneScopedN(name);
-
-#endif  // DUSK_GX_HELPER_H
diff --git a/include/dusk/math.h b/include/helpers/math.h
similarity index 84%
rename from include/dusk/math.h
rename to include/helpers/math.h
index 04f1087670..c1e966951a 100644
--- a/include/dusk/math.h
+++ b/include/helpers/math.h
@@ -1,5 +1,4 @@
-#ifndef _SRC_DUSK_MATH_H_
-#define _SRC_DUSK_MATH_H_
+#pragma once
 
 #include <cmath>
 
@@ -17,5 +16,3 @@ inline float i_tanf(float x) { return tan(x); }
 inline float i_acosf(float x) { return acos(x); }
 
 #include <dolphin/ppc_math.h>
-
-#endif // _SRC_DUSK_MATH_H_
diff --git a/include/dusk/offset_ptr.h b/include/helpers/offset_ptr.h
similarity index 89%
rename from include/dusk/offset_ptr.h
rename to include/helpers/offset_ptr.h
index 3a940804c2..924b840659 100644
--- a/include/dusk/offset_ptr.h
+++ b/include/helpers/offset_ptr.h
@@ -1,5 +1,4 @@
-#ifndef DUSK_OFFSET_PTR_H
-#define DUSK_OFFSET_PTR_H
+#pragma once
 
 #if TARGET_PC
 
@@ -47,21 +46,17 @@ struct OffsetPtrT {
     }
 
     operator T*() const {
-        return (T*) value;
-    }
+        return (T*)value; }
 
-    template<typename TOther>
+    template <typename TOther>
     explicit operator TOther*() const {
-        return (TOther*) value;
+        return (TOther*)value;
     }
 };
 
-
 #define OFFSET_PTR(T) OffsetPtrT<T>
 #define OFFSET_PTR_RAW OffsetPtr
 #else
 #define OFFSET_PTR(T) T*
 #define OFFSET_PTR_RAW u32
 #endif
-
-#endif  // DUSK_OFFSET_PTR_H
diff --git a/include/dusk/string.hpp b/include/helpers/string.hpp
similarity index 89%
rename from include/dusk/string.hpp
rename to include/helpers/string.hpp
index af91ff8fe9..b7ba0ef3b7 100644
--- a/include/dusk/string.hpp
+++ b/include/helpers/string.hpp
@@ -1,8 +1,7 @@
-#ifndef DUSK_STRING_HPP
-#define DUSK_STRING_HPP
-#include <cstdarg>
+#pragma once
 
-namespace dusk {
+#include <cstdarg>
+#include <cstddef>
 
 struct TextSpan {
     char* buffer;
@@ -44,7 +43,7 @@ private:
 };
 
 #if TARGET_PC
-#define TEXT_SPAN dusk::TextSpan
+#define TEXT_SPAN TextSpan
 #else
 #define TEXT_SPAN char*
 #endif
@@ -111,11 +110,11 @@ int SafeStringPrintf(char (&buffer)[BufSize], const char* format, ...) {
 }
 
 #if TARGET_PC
-#define SAFE_STRCPY dusk::SafeStringCopy
-#define SAFE_STRCAT dusk::SafeStringCat
-#define SAFE_SPRINTF dusk::SafeStringPrintf
-#define SAFE_STRCPY_BOUNDED dusk::SafeStringCopy
-#define SAFE_STRCAT_BOUNDED dusk::SafeStringCat
+#define SAFE_STRCPY SafeStringCopy
+#define SAFE_STRCAT SafeStringCat
+#define SAFE_SPRINTF SafeStringPrintf
+#define SAFE_STRCPY_BOUNDED SafeStringCopy
+#define SAFE_STRCAT_BOUNDED SafeStringCat
 #else
 #define SAFE_STRCPY strcpy
 #define SAFE_STRCAT strcat
@@ -123,6 +122,3 @@ int SafeStringPrintf(char (&buffer)[BufSize], const char* format, ...) {
 #define SAFE_STRCPY_BOUNDED strcpy
 #define SAFE_STRCPY_BOUNDED strcat
 #endif
-}
-
-#endif  // DUSK_STRING_HPP
diff --git a/include/m_Do/m_Do_MemCard.h b/include/m_Do/m_Do_MemCard.h
index f369bf2f2f..84fc246e09 100644
--- a/include/m_Do/m_Do_MemCard.h
+++ b/include/m_Do/m_Do_MemCard.h
@@ -112,6 +112,11 @@ public:
         mSerialNo = serial_no;
     }
 
+#ifdef TARGET_PC
+    void setFileName(const std::string& fileName);
+    const char* getFileName();
+#endif
+
     /* 0x0000 */ u8 mData[SAVEFILE_SIZE];
     /* 0x1FBC */ u8 mChannel;
     /* 0x1FBD */ u8 mCopyToPos;
@@ -124,13 +129,18 @@ public:
     /* 0x1FEC */ s32 mNandState;
     /* 0x1FF0 */ u64 mSerialNo;
     /* 0x1FF8 */ u32 mDataVersion;
+#ifdef TARGET_PC
+    bool mInitialized;
+    std::string mFileName;
+#endif
+
 };  // Size: 0x2000
 
 STATIC_ASSERT(sizeof(mDoMemCd_Ctrl_c) == 8192);
 
 static int mDoMemCd_main(void*);
 
-extern mDoMemCd_Ctrl_c g_mDoMemCd_control;
+DUSK_GAME_EXTERN mDoMemCd_Ctrl_c g_mDoMemCd_control;
 
 inline bool mDoMemCd_isCardCommNone() {
     return g_mDoMemCd_control.isCardCommNone();
@@ -230,4 +240,14 @@ inline s32 mDoMemCd_checkNANDFile() {
 }
 #endif
 
+#ifdef TARGET_PC
+inline void mDoMemCd_SetFileName(const std::string& fileName) {
+    g_mDoMemCd_control.setFileName(fileName);
+}
+
+inline const char* mDoMemCd_GetFileName() {
+    return g_mDoMemCd_control.getFileName();
+}
+#endif
+
 #endif /* M_DO_M_DO_MEMCARD_H */
diff --git a/include/m_Do/m_Do_Reset.h b/include/m_Do/m_Do_Reset.h
index a426460ba9..85a986263a 100644
--- a/include/m_Do/m_Do_Reset.h
+++ b/include/m_Do/m_Do_Reset.h
@@ -54,9 +54,9 @@ public:
     static mDoRstData* getResetData() { return mResetData; }
     static void setResetData(mDoRstData* rstData) { mResetData = rstData; }
 
-    static mDoRstData* mResetData;
+    static DUSK_GAME_DATA mDoRstData* mResetData;
 };
 
-extern bool mDoDvdErr_initialized;
+DUSK_GAME_EXTERN bool mDoDvdErr_initialized;
 
 #endif /* M_DO_M_DO_RESET_H */
diff --git a/include/m_Do/m_Do_audio.h b/include/m_Do/m_Do_audio.h
index e1e15c1ef1..43d0b81766 100644
--- a/include/m_Do/m_Do_audio.h
+++ b/include/m_Do/m_Do_audio.h
@@ -4,8 +4,12 @@
 #include "Z2AudioLib/Z2AudioMgr.h"
 #include "Z2AudioLib/Z2EnvSeMgr.h"
 #include "Z2AudioLib/Z2LinkMgr.h"
+#if defined(DUSK_BUILDING_GAME)
 #include "dusk/audio.h"
 #include "dusk/settings.h"
+#else
+#define DUSK_AUDIO_SKIP(...)
+#endif
 
 class mDoAud_zelAudio_c : public Z2AudioMgr {
 public:
@@ -33,12 +37,12 @@ public:
     static void onBgmSet() { mBgmSet = true; }
     static void offBgmSet() { mBgmSet = false; }
 
-    static u8 mInitFlag;
-    static u8 mResetFlag;
-    static u8 mBgmSet;
+    static DUSK_GAME_DATA u8 mInitFlag;
+    static DUSK_GAME_DATA u8 mResetFlag;
+    static DUSK_GAME_DATA u8 mBgmSet;
 };
 
-extern JKRSolidHeap* g_mDoAud_audioHeap;
+DUSK_GAME_EXTERN JKRSolidHeap* g_mDoAud_audioHeap;
 
 void mDoAud_Execute();
 void mDoAud_resetProcess();
@@ -134,15 +138,7 @@ inline void mDoAud_seStart(u32 i_sfxID, const Vec* i_sePos, u32 param_2, s8 i_re
 }
 
 #if TARGET_PC
-inline void mDoAud_seStartMenu(u32 i_sfxID) {
-    if (!mDoAud_zelAudio_c::isInitFlag()) {
-        return;
-    }
-    if (!dusk::getSettings().audio.menuSounds.getValue()) {
-        return;
-    }
-    mDoAud_seStart(i_sfxID, nullptr, 0, 0);
-}
+void mDoAud_seStartMenu(u32 i_sfxID);
 #endif
 
 inline void mDoAud_seStartLevel(u32 i_sfxID, const Vec* i_sePos, u32 param_2, s8 i_reverb) {
diff --git a/include/m_Do/m_Do_controller_pad.h b/include/m_Do/m_Do_controller_pad.h
index e187efd17d..f63c1c8d1c 100644
--- a/include/m_Do/m_Do_controller_pad.h
+++ b/include/m_Do/m_Do_controller_pad.h
@@ -3,7 +3,10 @@
 
 #include "JSystem/JUtility/JUTGamePad.h"
 #include "SSystem/SComponent/c_API_controller_pad.h"
+
+#if defined(DUSK_BUILDING_GAME)
 #include "dusk/settings.h"
+#endif
 
 // Controller Ports 1 - 4
 enum { PAD_1, PAD_2, PAD_3, PAD_4 };
@@ -54,29 +57,21 @@ public:
     static f32 getStickValue(u32 pad) { return getCpadInfo(pad).mMainStickValue; }
     static s16 getStickAngle(u32 pad) { return getCpadInfo(pad).mMainStickAngle; }
 
+#if TARGET_PC
+    static s16 getStickAngle3D(u32 pad);
+#else
     static s16 getStickAngle3D(u32 pad) {
-        #if TARGET_PC
-        if (dusk::getSettings().game.enableMirrorMode) {
-            return -getCpadInfo(pad).mMainStickAngle;
-        } else {
-            return getCpadInfo(pad).mMainStickAngle;
-        }
-        #else
         return getCpadInfo(pad).mMainStickAngle;
-        #endif
     }
+#endif
 
+#if TARGET_PC
+    static f32 getSubStickX3D(u32 pad);
+#else
     static f32 getSubStickX3D(u32 pad) {
-        #if TARGET_PC
-        if (dusk::getSettings().game.enableMirrorMode) {
-            return -getCpadInfo(pad).mCStickPosX;
-        } else {
-            return getCpadInfo(pad).mCStickPosX;
-        }
-        #else
         return getCpadInfo(pad).mCStickPosX;
-        #endif
     }
+#endif
 
     static f32 getSubStickX(u32 pad) { return getCpadInfo(pad).mCStickPosX; }
     static f32 getSubStickY(u32 pad) { return getCpadInfo(pad).mCStickPosY; }
@@ -93,9 +88,9 @@ public:
     static void stopMotorHard(u32 pad) { return m_gamePad[pad]->stopMotorHard(); }
     static void stopMotorWaveHard(u32 pad) { return m_gamePad[pad]->stopMotorWaveHard(); }
 
-    static JUTGamePad* m_gamePad[4];
-    static interface_of_controller_pad m_cpadInfo[4];
-    static interface_of_controller_pad m_debugCpadInfo[4];
+    static DUSK_GAME_DATA JUTGamePad* m_gamePad[4];
+    static DUSK_GAME_DATA interface_of_controller_pad m_cpadInfo[4];
+    static DUSK_GAME_DATA interface_of_controller_pad m_debugCpadInfo[4];
 };
 
 inline void mDoCPd_ANALOG_CONV(u8 analog, f32& param_1) {
diff --git a/include/m_Do/m_Do_dvd_thread.h b/include/m_Do/m_Do_dvd_thread.h
index 8af8c520b5..dcb3f2fc65 100644
--- a/include/m_Do/m_Do_dvd_thread.h
+++ b/include/m_Do/m_Do_dvd_thread.h
@@ -130,21 +130,21 @@ private:
 };  // Size = 0x28
 
 struct mDoDvdThdStack {
-    u8 stack[4096];
-} ATTRIBUTE_ALIGN(16);
+    ATTRIBUTE_ALIGN(16) u8 stack[4096];
+};
 
 struct mDoDvdThd {
     static s32 main(void*);
     static void create(s32);
     static void suspend();
 
-    static OSThread l_thread;
-    static mDoDvdThdStack l_threadStack;
-    static mDoDvdThd_param_c l_param;
+    static DUSK_GAME_DATA OSThread l_thread;
+    static DUSK_GAME_DATA mDoDvdThdStack l_threadStack;
+    static DUSK_GAME_DATA mDoDvdThd_param_c l_param;
 
     static u8 verbose;
-    static u8 DVDLogoMode;
-    static bool SyncWidthSound;
+    static DUSK_GAME_DATA u8 DVDLogoMode;
+    static DUSK_GAME_DATA bool SyncWidthSound;
     static u8 Report_DVDRead;
 };
 
diff --git a/include/m_Do/m_Do_ext.h b/include/m_Do/m_Do_ext.h
index 77d046f0de..4c1ceeb997 100644
--- a/include/m_Do/m_Do_ext.h
+++ b/include/m_Do/m_Do_ext.h
@@ -19,9 +19,9 @@ class Z2Creature;
 struct cXy;
 
 namespace mDoExt {
-    extern u8 CurrentHeapAdjustVerbose;
-    extern u8 HeapAdjustVerbose;
-    extern u8 HeapAdjustQuiet;
+    DUSK_GAME_EXTERN u8 CurrentHeapAdjustVerbose;
+    DUSK_GAME_EXTERN u8 HeapAdjustVerbose;
+    DUSK_GAME_EXTERN u8 HeapAdjustQuiet;
 };
 
 class mDoExt_baseAnm {
@@ -542,10 +542,18 @@ public:
     virtual void setMaterial() = 0;
     virtual void draw() = 0;
 #if TARGET_PC
-    virtual void refreshGeometryForPresentationEye(const cXyz& eye) {}
+    virtual void captureInterpPoints() {}
+    virtual void refreshGeometryForPresentation() {}
 #endif
 
     /* 0x4 */ mDoExt_3DlineMat_c* field_0x4;
+
+#if TARGET_PC
+protected:
+    u8 mInterpKind;
+    f32 mInterpWidth;
+    u16 mInterpTaper;
+#endif
 };
 
 class mDoExt_3DlineMat0_c : public mDoExt_3DlineMat_c {
@@ -567,6 +575,10 @@ public:
     virtual int getMaterialID() { return 0; }
     virtual void setMaterial();
     virtual void draw();
+#if TARGET_PC
+    void captureInterpPoints() override;
+    void refreshGeometryForPresentation() override;
+#endif
 
     cXyz* getPos(int param_0) { return field_0x18[param_0].field_0x0; }
     f32* getSize(int param_0) { return field_0x18[param_0].field_0x4; }
@@ -585,18 +597,14 @@ class dKy_tevstr_c;
 class mDoExt_3DlineMat1_c : public mDoExt_3DlineMat_c {
 public:
     int init(u16, u16, ResTIMG*, int);
-#if TARGET_PC
-    void update(int, GXColor&, dKy_tevstr_c*, const cXyz* presentationEye = nullptr);
-    void update(int, f32, GXColor&, u16, dKy_tevstr_c*, const cXyz* presentationEye = nullptr);
-#else
     void update(int, GXColor&, dKy_tevstr_c*);
     void update(int, f32, GXColor&, u16, dKy_tevstr_c*);
-#endif
     int getMaterialID() { return 1; }
     void setMaterial();
     void draw();
 #if TARGET_PC
-    void refreshGeometryForPresentationEye(const cXyz& eye) override;
+    void captureInterpPoints() override;
+    void refreshGeometryForPresentation() override;
 #endif
 
     cXyz* getPos(int i_idx) { return mpLines[i_idx].field_0x0; }
@@ -611,11 +619,6 @@ private:
     /* 0x34 */ u16 field_0x34;
     /* 0x36 */ u8 mIsDrawn;
     /* 0x38 */ mDoExt_3Dline_c* mpLines;
-#if TARGET_PC
-    u8 mInterpLineKind;
-    f32 mInterpLineF;
-    u16 mInterpLineU16;
-#endif
 };
 
 class mDoExt_3DlineMat2_c : public mDoExt_3DlineMat1_c {
@@ -840,7 +843,7 @@ void mDoExt_modelUpdateDL(J3DModel* i_model);
 J3DModel* mDoExt_J3DModel__create(J3DModelData* i_modelData, u32 i_modelFlag,
                                   u32 i_differedDlistFlag);
 
-extern u32 aram_cache_size;
+DUSK_GAME_EXTERN u32 aram_cache_size;
 u32 mDoExt_getAraCacheSize();
 void mDoExt_setAraCacheSize(u32 size);
 
@@ -889,10 +892,10 @@ int DummyCheckHeap_isVirgin();
 
 void DummyCheckHeap_check();
 
-extern JKRExpHeap* zeldaHeap;
-extern JKRExpHeap* gameHeap;
-extern JKRExpHeap* archiveHeap;
-extern JKRExpHeap* commandHeap;
-extern DummyCheckHeap* dch;
+DUSK_GAME_EXTERN JKRExpHeap* zeldaHeap;
+DUSK_GAME_EXTERN JKRExpHeap* gameHeap;
+DUSK_GAME_EXTERN JKRExpHeap* archiveHeap;
+DUSK_GAME_EXTERN JKRExpHeap* commandHeap;
+DUSK_GAME_EXTERN DummyCheckHeap* dch;
 
 #endif /* M_DO_M_DO_EXT_H */
diff --git a/include/m_Do/m_Do_graphic.h b/include/m_Do/m_Do_graphic.h
index 5d29049520..dbda35d9c2 100644
--- a/include/m_Do/m_Do_graphic.h
+++ b/include/m_Do/m_Do_graphic.h
@@ -123,8 +123,8 @@ public:
     static void waitBlanking(int wait) { JFWDisplay::getManager()->waitBlanking(wait); }
 
 #if TARGET_PC
-    static f32 hudAspectScaleDown;
-    static f32 hudAspectScaleUp;
+    static DUSK_GAME_DATA f32 hudAspectScaleDown;
+    static DUSK_GAME_DATA f32 hudAspectScaleUp;
     static void updateSafeAreaBounds();
     static f32 getSafeMinXF() { return m_safeMinXF; }
     static f32 getSafeMinYF() { return m_safeMinYF; }
@@ -302,23 +302,23 @@ public:
     static void updateRenderSize();
     #endif
 
-    static TGXTexObj mFrameBufferTexObj;
-    static TGXTexObj mZbufferTexObj;
-    static bloom_c m_bloom;
-    static Mtx mBlureMtx;
-    static GXColor mBackColor;
-    static GXColor mFadeColor;
-    static JUTFader* mFader;
-    static ResTIMG* mFrameBufferTimg;
-    static void* mFrameBufferTex;
-    static ResTIMG* mZbufferTimg;
-    static void* mZbufferTex;
-    static f32 mFadeRate;
-    static f32 mFadeSpeed;
-    static u8 mBlureFlag;
-    static u8 mBlureRate;
-    static u8 mFade;
-    static bool mAutoForcus;
+    static DUSK_GAME_DATA TGXTexObj mFrameBufferTexObj;
+    static DUSK_GAME_DATA TGXTexObj mZbufferTexObj;
+    static DUSK_GAME_DATA bloom_c m_bloom;
+    static DUSK_GAME_DATA Mtx mBlureMtx;
+    static DUSK_GAME_DATA GXColor mBackColor;
+    static DUSK_GAME_DATA GXColor mFadeColor;
+    static DUSK_GAME_DATA JUTFader* mFader;
+    static DUSK_GAME_DATA ResTIMG* mFrameBufferTimg;
+    static DUSK_GAME_DATA void* mFrameBufferTex;
+    static DUSK_GAME_DATA ResTIMG* mZbufferTimg;
+    static DUSK_GAME_DATA void* mZbufferTex;
+    static DUSK_GAME_DATA f32 mFadeRate;
+    static DUSK_GAME_DATA f32 mFadeSpeed;
+    static DUSK_GAME_DATA u8 mBlureFlag;
+    static DUSK_GAME_DATA u8 mBlureRate;
+    static DUSK_GAME_DATA u8 mFade;
+    static DUSK_GAME_DATA bool mAutoForcus;
 
     #if PLATFORM_SHIELD
     static JKRHeap* getHeap() {
@@ -333,9 +333,9 @@ public:
     #endif
 
 #if PLATFORM_WII || PLATFORM_SHIELD || TARGET_PC
-    static ResTIMG* m_fullFrameBufferTimg;
-    static void* m_fullFrameBufferTex;
-    static TGXTexObj m_fullFrameBufferTexObj;
+    static DUSK_GAME_DATA ResTIMG* m_fullFrameBufferTimg;
+    static DUSK_GAME_DATA void* m_fullFrameBufferTex;
+    static DUSK_GAME_DATA TGXTexObj m_fullFrameBufferTexObj;
 #endif
 
     #if PLATFORM_WII || PLATFORM_SHIELD
@@ -350,35 +350,35 @@ public:
     #endif
 
     #if WIDESCREEN_SUPPORT
-    static u8 mWide;
-    static u8 mWideZoom;
+    static DUSK_GAME_DATA u8 mWide;
+    static DUSK_GAME_DATA u8 mWideZoom;
 
-    static f32 m_aspect;
-    static f32 m_scale;
-    static f32 m_invScale;
+    static DUSK_GAME_DATA f32 m_aspect;
+    static DUSK_GAME_DATA f32 m_scale;
+    static DUSK_GAME_DATA f32 m_invScale;
 
-    static f32 m_minXF;
-    static f32 m_minYF;
-    static int m_minX;
-    static int m_minY;
+    static DUSK_GAME_DATA f32 m_minXF;
+    static DUSK_GAME_DATA f32 m_minYF;
+    static DUSK_GAME_DATA int m_minX;
+    static DUSK_GAME_DATA int m_minY;
 
-    static f32 m_maxXF;
-    static f32 m_maxYF;
-    static int m_maxX;
-    static int m_maxY;
+    static DUSK_GAME_DATA f32 m_maxXF;
+    static DUSK_GAME_DATA f32 m_maxYF;
+    static DUSK_GAME_DATA int m_maxX;
+    static DUSK_GAME_DATA int m_maxY;
 
-    static int m_width;
-    static int m_height;
-    static f32 m_heightF;
-    static f32 m_widthF;
+    static DUSK_GAME_DATA int m_width;
+    static DUSK_GAME_DATA int m_height;
+    static DUSK_GAME_DATA f32 m_heightF;
+    static DUSK_GAME_DATA f32 m_widthF;
 
     #if TARGET_PC
-    static f32 m_safeMinXF;
-    static f32 m_safeMinYF;
-    static f32 m_safeMaxXF;
-    static f32 m_safeMaxYF;
-    static f32 m_safeWidthF;
-    static f32 m_safeHeightF;
+    static DUSK_GAME_DATA f32 m_safeMinXF;
+    static DUSK_GAME_DATA f32 m_safeMinYF;
+    static DUSK_GAME_DATA f32 m_safeMaxXF;
+    static DUSK_GAME_DATA f32 m_safeMaxYF;
+    static DUSK_GAME_DATA f32 m_safeWidthF;
+    static DUSK_GAME_DATA f32 m_safeHeightF;
     #endif
     #endif
 };
diff --git a/include/m_Do/m_Do_lib.h b/include/m_Do/m_Do_lib.h
index f194a4591b..9ceaa9c137 100644
--- a/include/m_Do/m_Do_lib.h
+++ b/include/m_Do/m_Do_lib.h
@@ -2,14 +2,11 @@
 #define M_DO_M_DO_LIB_H
 
 #include "JSystem/J3DU/J3DUClipper.h"
-#include <dolphin/gx/GXStruct.h>
 
 #if TARGET_PC
-#include "JSystem/JGeometry.h"
+#include "helpers/gx_helper.h"
 #endif
 
-#include "dusk/gx_helper.h"
-
 typedef struct Vec Vec;
 struct ResTIMG;
 
@@ -37,9 +34,9 @@ struct mDoLib_clipper {
         mClipper.calcViewFrustum();
     }
 
-    static J3DUClipper mClipper;
-    static f32 mSystemFar;
-    static f32 mFovyRate;
+    static DUSK_GAME_DATA J3DUClipper mClipper;
+    static DUSK_GAME_DATA f32 mSystemFar;
+    static DUSK_GAME_DATA f32 mFovyRate;
 };
 
 void mDoLib_project(Vec* src, Vec* dst);
diff --git a/include/m_Do/m_Do_machine.h b/include/m_Do/m_Do_machine.h
index eeea7e77ce..5469a29b5b 100644
--- a/include/m_Do/m_Do_machine.h
+++ b/include/m_Do/m_Do_machine.h
@@ -19,7 +19,7 @@ int mDoMch_Create();
 void mDoMch_Destroy();
 #endif
 
-extern GXRenderModeObj g_ntscZeldaProg;
+DUSK_GAME_EXTERN GXRenderModeObj g_ntscZeldaProg;
 
 class mDoMch_render_c {
 public:
@@ -30,11 +30,11 @@ public:
 
     static GXRenderModeObj* getRenderModeObj() { return mRenderModeObj; }
 
-    static GXRenderModeObj* mRenderModeObj;
+    static DUSK_GAME_DATA GXRenderModeObj* mRenderModeObj;
 };
 
 namespace mDoMch {
-    extern u8 mDebugFill;
+    DUSK_GAME_EXTERN u8 mDebugFill;
     extern u8 mDebugFillNotUse;
     extern u8 mDebugFillNew;
     extern u8 mDebugFillDelete;
diff --git a/include/m_Do/m_Do_main.h b/include/m_Do/m_Do_main.h
index 9bedc21a39..e3b8f1acf7 100644
--- a/include/m_Do/m_Do_main.h
+++ b/include/m_Do/m_Do_main.h
@@ -6,12 +6,12 @@
 
 class JKRExpHeap;
 
-extern OSThread mainThread;
+DUSK_GAME_EXTERN OSThread mainThread;
 
 void version_check();
 s32 LOAD_COPYDATE(void*);
 
-extern OSThread mainThread;
+DUSK_GAME_EXTERN OSThread mainThread;
 const int HeapCheckTableNum = 8;
 
 class HeapCheck {
@@ -70,11 +70,11 @@ struct mDoMain {
     static u32 archiveHeapSize;
     static u32 gameHeapSize;
 
-    static char COPYDATE_STRING[18];
-    static u32 memMargin;
-    static OSTime sPowerOnTime;
-    static OSTime sHungUpTime;
-    static s8 developmentMode;
+    static DUSK_GAME_DATA char COPYDATE_STRING[18];
+    static DUSK_GAME_DATA u32 memMargin;
+    static DUSK_GAME_DATA OSTime sPowerOnTime;
+    static DUSK_GAME_DATA OSTime sHungUpTime;
+    static DUSK_GAME_DATA s8 developmentMode;
 };
 
 #endif /* M_DO_M_DO_MAIN_H */
diff --git a/include/m_Do/m_Do_mtx.h b/include/m_Do/m_Do_mtx.h
index 23db8b6d94..fdf5b66fed 100644
--- a/include/m_Do/m_Do_mtx.h
+++ b/include/m_Do/m_Do_mtx.h
@@ -5,11 +5,14 @@
 #include "SSystem/SComponent/c_xyz.h"
 #include <mtx.h>
 
+#if TARGET_PC
+#include "helpers/endian.h"
+
 #include "JSystem/JMath/JMath.h"
-#include "dusk/endian.h"
+#endif
 
 extern u8 g_printCurrentHeapDebug;
-extern u8 g_printOtherHeapDebug;
+DUSK_GAME_EXTERN u8 g_printOtherHeapDebug;
 
 void mDoMtx_XYZrotS(Mtx, s16, s16, s16);
 void mDoMtx_XYZrotM(Mtx, s16, s16, s16);
@@ -373,13 +376,13 @@ public:
         PSMTXIdentity(now);
     }
 
-    static Mtx now;
-    static Mtx buffer[16];
-    static Mtx* next;
-    static Mtx* end;
+    static DUSK_GAME_DATA Mtx now;
+    static DUSK_GAME_DATA Mtx buffer[16];
+    static DUSK_GAME_DATA Mtx* next;
+    static DUSK_GAME_DATA Mtx* end;
 };
 
-extern Mtx g_mDoMtx_identity;
+DUSK_GAME_EXTERN Mtx g_mDoMtx_identity;
 
 inline MtxP mDoMtx_getIdentity() {
     return g_mDoMtx_identity;
diff --git a/include/m_Do/m_Do_printf.h b/include/m_Do/m_Do_printf.h
index 527be3d58a..dc30b1c720 100644
--- a/include/m_Do/m_Do_printf.h
+++ b/include/m_Do/m_Do_printf.h
@@ -2,7 +2,6 @@
 #define M_DO_M_DO_PRINTF_H
 
 #include <os.h>
-#include "dusk/endian.h"
 
 void my_PutString(const char*);
 void mDoPrintf_vprintf_Interrupt(char const*, va_list);
diff --git a/include/mods/api.h b/include/mods/api.h
deleted file mode 100644
index 85e2f76545..0000000000
--- a/include/mods/api.h
+++ /dev/null
@@ -1,152 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-#include <cstddef>
-#include <cstdint>
-extern "C" {
-#else
-#include <assert.h>
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-#endif
-
-#if defined(_WIN32)
-#define MOD_EXPORT __declspec(dllexport)
-#else
-#define MOD_EXPORT __attribute__((visibility("default")))
-#endif
-
-#ifdef __cplusplus
-#define MOD_EXTERN_C extern "C"
-#else
-#define MOD_EXTERN_C
-#endif
-
-#define MOD_ABI_VERSION 5u
-#define MOD_ERROR_MESSAGE_SIZE 512u
-
-typedef struct ModContext ModContext;
-
-typedef enum ModResult {
-    MOD_OK = 0,
-    MOD_ERROR = 1,
-    MOD_UNAVAILABLE = 2,
-    MOD_UNSUPPORTED = 3,
-    MOD_CONFLICT = 4,
-    MOD_INVALID_ARGUMENT = 5,
-} ModResult;
-
-static_assert(sizeof(ModResult) == 4, "mod SDK enums must be int-sized; do not build mods with -fshort-enums");
-
-typedef struct ModError {
-    uint32_t struct_size;
-    ModResult code;
-    char message[MOD_ERROR_MESSAGE_SIZE];
-} ModError;
-
-#define MOD_ERROR_INIT {sizeof(ModError), MOD_OK, {0}}
-
-/*
- * Opaque per-mod context, populated by the host before mod_initialize is called.
- * Pass it as the first argument to every service call; it identifies the calling
- * mod for attribution (logging, resource lookup, hook ownership, etc.).
- */
-MOD_EXPORT extern ModContext* mod_ctx;
-
-/*
- * Service versioning contract:
- *
- * A service is a struct of function pointers, beginning with a ServiceHeader.
- * Compatibility is tracked with a major/minor version pair:
- *
- * - A major version bump is a breaking change. Different majors are distinct
- *   services; the registry never matches an import against a different major.
- * - A minor version bump may only append fields to the end of the struct.
- *   Existing fields must keep their offsets and semantics.
- *
- * Providers: exporting minor N means every function pointer introduced at or
- * below N is populated (non-NULL). struct_size reflects the compiled struct.
- *
- * Importers: importing with min_minor_version N guarantees (enforced at load
- * time) that the resolved service is at least minor N, so any field introduced
- * at or below N may be used unconditionally, with no availability checks.
- * Fields newer than the declared min_minor_version must be gated behind
- * SERVICE_HAS plus a NULL check on the pointer itself.
- *
- * Load ordering: a manifest import of another mod's service (required or
- * optional) guarantees that the provider's mod_initialize completed before the
- * importer's runs, and deferred services published during the provider's
- * initialization resolve into import slots just like static exports. If a
- * provider fails to load, mods that required its services fail in turn. Mods
- * whose required imports form a cycle all fail to load; a cycle involving an
- * optional import is broken by dropping the ordering guarantee (not the
- * resolution) of that optional import. Dynamic lookups via
- * HostService::get_service carry no ordering guarantee: they see whatever has
- * been published at call time.
- */
-typedef struct ServiceHeader {
-    uint32_t struct_size;
-    uint16_t major_version;
-    uint16_t minor_version;
-} ServiceHeader;
-
-#define SERVICE_HEADER(service_type, major, minor) {sizeof(service_type), (major), (minor)}
-
-#define SERVICE_HAS(service, service_type, field)                                                  \
-    ((service) != NULL &&                                                                          \
-        (service)->header.struct_size >=                                                           \
-            (uint32_t)(offsetof(service_type, field) + sizeof(((service_type*)0)->field)))
-
-typedef enum ServiceImportFlags {
-    SERVICE_IMPORT_REQUIRED = 0u,
-    SERVICE_IMPORT_OPTIONAL = 1u << 0u,
-} ServiceImportFlags;
-
-typedef enum ServiceExportFlags {
-    SERVICE_EXPORT_STATIC = 0u,
-    SERVICE_EXPORT_DEFERRED = 1u << 0u,
-} ServiceExportFlags;
-
-typedef struct ServiceImport {
-    uint32_t struct_size;
-    const char* service_id;
-    uint16_t major_version;
-    uint16_t min_minor_version;
-    uint32_t flags;
-    void* slot;
-} ServiceImport;
-
-typedef struct ServiceExport {
-    uint32_t struct_size;
-    const char* service_id;
-    uint16_t major_version;
-    uint16_t minor_version;
-    uint32_t flags;
-    const void* service;
-} ServiceExport;
-
-typedef struct ModManifest {
-    uint32_t struct_size;
-    uint32_t abi_version;
-    const ServiceImport* imports;
-    size_t import_count;
-    const ServiceExport* exports;
-    size_t export_count;
-} ModManifest;
-
-typedef const ModManifest* (*ModGetManifestFn)(void);
-
-typedef ModResult (*ModInitializeFn)(ModError* out_error);
-typedef ModResult (*ModUpdateFn)(ModError* out_error);
-typedef ModResult (*ModShutdownFn)(ModError* out_error);
-
-MOD_EXPORT const ModManifest* mod_get_manifest(void);
-
-MOD_EXPORT ModResult mod_initialize(ModError* out_error);
-MOD_EXPORT ModResult mod_update(ModError* out_error);
-MOD_EXPORT ModResult mod_shutdown(ModError* out_error);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/include/mods/hook.hpp b/include/mods/hook.hpp
deleted file mode 100644
index c58bd719c9..0000000000
--- a/include/mods/hook.hpp
+++ /dev/null
@@ -1,464 +0,0 @@
-#pragma once
-
-#include "mods/svc/hook.h"
-
-#include <array>
-#include <cstddef>
-#include <cstring>
-#include <memory>
-#include <string_view>
-#include <type_traits>
-
-namespace dusk::mods {
-
-template <class T>
-T arg(void* argsRaw, int n) noexcept {
-    void** args = static_cast<void**>(argsRaw);
-    return *static_cast<std::add_pointer_t<std::remove_reference_t<T> > >(args[n]);
-}
-
-template <class T>
-std::remove_reference_t<T>& arg_ref(void* argsRaw, int n) noexcept {
-    void** args = static_cast<void**>(argsRaw);
-    return *static_cast<std::add_pointer_t<std::remove_reference_t<T> > >(args[n]);
-}
-
-template <class F>
-void* mfp_addr(F fn) noexcept {
-    void* p = nullptr;
-    static_assert(sizeof(fn) >= sizeof(void*), "unexpected function pointer size");
-    std::memcpy(&p, &fn, sizeof(void*));
-    return p;
-}
-
-/* A string usable as a template argument: carries the hook target's symbol name and
- * makes each NamedHook instantiation's static state unique. */
-template <size_t N>
-struct FixedString {
-    char chars[N]{};
-    constexpr FixedString(const char (&s)[N]) noexcept {
-        for (size_t i = 0; i < N; ++i) {
-            chars[i] = s[i];
-        }
-    }
-};
-
-namespace detail {
-
-template <class T>
-constexpr std::string_view class_name() {
-#if defined(__clang__) || defined(__GNUC__)
-    // "... class_name() [T = daAlink_c]" / "... [with T = daAlink_c; ...]"
-    constexpr std::string_view fn = __PRETTY_FUNCTION__;
-    constexpr size_t start = fn.find("T = ") + 4;
-    return fn.substr(start, fn.find_first_of(";]", start) - start);
-#elif defined(_MSC_VER)
-    // "... class_name<class daAlink_c>(void)"
-    constexpr std::string_view fn = __FUNCSIG__;
-    constexpr size_t start = fn.find("class_name<") + 11;
-    constexpr std::string_view name = fn.substr(start, fn.rfind(">(") - start);
-    if constexpr (name.starts_with("class ")) {
-        return name.substr(6);
-    } else if constexpr (name.starts_with("struct ")) {
-        return name.substr(7);
-    } else {
-        return name;
-    }
-#else
-#error "unsupported compiler"
-#endif
-}
-
-/* The manifest name of C's vtable. Only unscoped, non-template class names are
- * supported (an empty result fails resolution and the install reports it). */
-template <class C>
-constexpr auto vtable_symbol() {
-    constexpr std::string_view name = class_name<C>();
-    constexpr bool simple = name.find_first_of(":<> ") == std::string_view::npos;
-    // "_ZTV" + decimal length + name / "??_7" + name + "@@6B@", NUL-terminated
-    std::array<char, name.size() + 12> out{};
-    if constexpr (!simple) {
-        return out;
-    }
-    size_t n = 0;
-#if defined(_WIN32)
-    for (char c : {'?', '?', '_', '7'}) {
-        out[n++] = c;
-    }
-    for (char c : name) {
-        out[n++] = c;
-    }
-    for (char c : {'@', '@', '6', 'B', '@'}) {
-        out[n++] = c;
-    }
-#else
-    for (char c : {'_', 'Z', 'T', 'V'}) {
-        out[n++] = c;
-    }
-    size_t len = name.size();
-    char digits[8]{};
-    size_t d = 0;
-    while (len != 0) {
-        digits[d++] = static_cast<char>('0' + len % 10);
-        len /= 10;
-    }
-    while (d != 0) {
-        out[n++] = digits[--d];
-    }
-    for (char c : name) {
-        out[n++] = c;
-    }
-#endif
-    return out;
-}
-
-#if defined(_WIN32)
-/* Follow jump stubs, then match the MSVC vcall thunk a virtual mfp points at.
- * Returns the vtable slot's byte offset, or npos when fn is not a vcall thunk. */
-inline size_t vcall_slot_offset(const void*& fn) noexcept {
-    constexpr size_t npos = static_cast<size_t>(-1);
-#if defined(_M_X64) || defined(__x86_64__)
-    const auto* p = static_cast<const uint8_t*>(fn);
-    for (int i = 0; i < 8 && p[0] == 0xE9; ++i) {  // incremental-link stubs
-        int32_t rel;
-        std::memcpy(&rel, p + 1, 4);
-        p += 5 + rel;
-    }
-    fn = p;
-    // The vptr load. Unoptimized clang-cl thunks spill/reload rcx first
-    // (push rax; mov [rsp], rcx; mov rcx, [rsp]), so scan a short window.
-    const uint8_t* q = nullptr;
-    for (int i = 0; i <= 12; ++i) {
-        if (p[i] == 0x48 && p[i + 1] == 0x8B && p[i + 2] == 0x01) {  // mov rax, [rcx]
-            q = p + i + 3;
-            break;
-        }
-    }
-    if (q == nullptr) {
-        return npos;
-    }
-    if (q[0] == 0xFF && q[1] == 0x20) {  // jmp [rax]  (MSVC)
-        return 0;
-    }
-    if (q[0] == 0xFF && q[1] == 0x60) {  // jmp [rax + imm8]
-        return static_cast<int8_t>(q[2]);
-    }
-    if (q[0] == 0xFF && q[1] == 0xA0) {  // jmp [rax + imm32]
-        int32_t off;
-        std::memcpy(&off, q + 2, 4);
-        return off;
-    }
-    // clang-cl: mov rax, [rax + off]; (pop r10;) jmp rax. Requiring the jmp rax
-    // distinguishes the thunk from an ordinary getter that begins the same way.
-    if (q[0] == 0x48 && q[1] == 0x8B && (q[2] == 0x00 || q[2] == 0x40 || q[2] == 0x80)) {
-        size_t off = 0;
-        const uint8_t* r = q + 3;
-        if (q[2] == 0x40) {
-            off = static_cast<int8_t>(q[3]);
-            r = q + 4;
-        } else if (q[2] == 0x80) {
-            int32_t off32;
-            std::memcpy(&off32, q + 3, 4);
-            off = off32;
-            r = q + 7;
-        }
-        for (int i = 0; i <= 8; ++i) {
-            if (r[i] == 0xFF && r[i + 1] == 0xE0) {  // jmp rax (48 REX optional)
-                return off;
-            }
-        }
-    }
-    return npos;
-#elif defined(_M_ARM64) || defined(__aarch64__)
-    const auto* p = static_cast<const uint8_t*>(fn);
-    uint32_t insn[3];
-    for (int i = 0; i < 8; ++i) {  // incremental-link `b` stubs
-        std::memcpy(insn, p, 4);
-        if ((insn[0] & 0xFC000000u) != 0x14000000u) {
-            break;
-        }
-        const auto imm26 = static_cast<int32_t>(insn[0] << 6) >> 6;
-        p += static_cast<intptr_t>(imm26) * 4;
-    }
-    fn = p;
-    std::memcpy(insn, p, 12);
-    // ldr Xt, [x0]; ldr Xs, [Xt, #imm12*8]; br Xs
-    if ((insn[0] & 0xFFFFFFE0u) != 0xF9400000u) {
-        return npos;
-    }
-    const uint32_t t = insn[0] & 0x1Fu;
-    if ((insn[1] & 0xFFC003E0u) != (0xF9400000u | (t << 5))) {
-        return npos;
-    }
-    const uint32_t s = insn[1] & 0x1Fu;
-    if (insn[2] != (0xD61F0000u | (s << 5))) {
-        return npos;
-    }
-    return ((insn[1] >> 10) & 0xFFFu) * 8;
-#else
-    (void)fn;
-    return npos;
-#endif
-}
-#endif
-
-/* Code address of the member function a mfp designates. Virtual mfps don't carry
- * one; recover it from the class's vtable (resolved from the symbol manifest), so
- * Hook works uniformly on virtual and non-virtual members. */
-template <class C, class F>
-ModResult member_target(const HookService* hooks, F mfp, void** out) {
-    *out = nullptr;
-    uintptr_t words[sizeof(F) > sizeof(uintptr_t) ? 2 : 1] = {};
-    std::memcpy(words, &mfp, sizeof(words) < sizeof(F) ? sizeof(words) : sizeof(F));
-
-#if defined(_WIN32)
-    const void* fn = reinterpret_cast<const void*>(words[0]);
-    const size_t slot = vcall_slot_offset(fn);
-    if (slot == static_cast<size_t>(-1)) {  // not a vcall thunk: direct address
-        *out = const_cast<void*>(fn);
-        return MOD_OK;
-    }
-    void* vtable = nullptr;
-    const ModResult resolved = hooks->resolve(mod_ctx, vtable_symbol<C>().data(), &vtable, nullptr);
-    if (resolved != MOD_OK) {
-        return resolved;
-    }
-    // ??_7 points at the first slot.
-    *out = *reinterpret_cast<void**>(static_cast<char*>(vtable) + slot);
-#else
-#if defined(__aarch64__) || defined(__arm__)
-    // AAPCS C++ ABI: the virtual flag is bit 0 of the adjustment word (function
-    // addresses can't spare their low bit), and ptr holds the slot offset directly.
-    const bool isVirtual = (words[1] & 1) != 0;
-    const uintptr_t thisAdjust = words[1] >> 1;
-    const uintptr_t slotOffset = words[0];
-#else
-    // Itanium C++ ABI: virtual mfps set bit 0 of ptr; the slot offset is ptr - 1.
-    const bool isVirtual = (words[0] & 1) != 0;
-    const uintptr_t thisAdjust = words[1];
-    const uintptr_t slotOffset = words[0] - 1;
-#endif
-    if (!isVirtual) {  // non-virtual: the address itself
-        *out = reinterpret_cast<void*>(words[0]);
-        return MOD_OK;
-    }
-    if (thisAdjust != 0) {
-        // this-adjusting mfp (member of a secondary base): the slot offset is
-        // relative to a vtable we can't locate. Hook the overrider by name instead.
-        return MOD_UNSUPPORTED;
-    }
-    void* vtable = nullptr;
-    const ModResult resolved = hooks->resolve(mod_ctx, vtable_symbol<C>().data(), &vtable, nullptr);
-    if (resolved != MOD_OK) {
-        return resolved;
-    }
-    // _ZTV points at the offset-to-top slot; the address point mfps index from is
-    // two pointers in (past offset-to-top and the typeinfo pointer).
-    *out = *reinterpret_cast<void**>(static_cast<char*>(vtable) + 2 * sizeof(void*) + slotOffset);
-#endif
-    return *out != nullptr ? MOD_OK : MOD_UNAVAILABLE;
-}
-
-}  // namespace detail
-
-/* Trampoline generator + per-target state shared by Hook and NamedHook. Tag makes
- * each hooked target's statics distinct; the target address is filled in at install. */
-template <class Tag, class R, class... A>
-struct HookImpl {
-    static inline R (*g_orig)(A...) = nullptr;
-    static inline const HookService* hooks = nullptr;
-    static inline void* target = nullptr;
-
-    static bool dispatch_pre(void* args, void* retval) {
-        if (hooks == nullptr) {
-            return false;
-        }
-
-        int skipOriginal = 0;
-        const ModResult result = hooks->dispatch_pre(mod_ctx, target, args, retval, &skipOriginal);
-        return result == MOD_OK && skipOriginal != 0;
-    }
-
-    static void dispatch_post(void* args, void* retval) {
-        if (hooks != nullptr) {
-            hooks->dispatch_post(mod_ctx, target, args, retval);
-        }
-    }
-
-    static R trampoline(A... args) {
-        if constexpr (sizeof...(A) == 0) {
-            if constexpr (std::is_void_v<R>) {
-                const bool skipOriginal = dispatch_pre(nullptr, nullptr);
-                if (!skipOriginal) {
-                    g_orig(args...);
-                }
-                dispatch_post(nullptr, nullptr);
-            } else {
-                R result{};
-                const bool skipOriginal =
-                    dispatch_pre(nullptr, static_cast<void*>(std::addressof(result)));
-                if (!skipOriginal) {
-                    result = g_orig(args...);
-                }
-                dispatch_post(nullptr, static_cast<void*>(std::addressof(result)));
-                return result;
-            }
-        } else {
-            void* ptrs[] = {static_cast<void*>(std::addressof(args))...};
-            if constexpr (std::is_void_v<R>) {
-                const bool skipOriginal = dispatch_pre(static_cast<void*>(ptrs), nullptr);
-                if (!skipOriginal) {
-                    g_orig(args...);
-                }
-                dispatch_post(static_cast<void*>(ptrs), nullptr);
-            } else {
-                R result{};
-                const bool skipOriginal = dispatch_pre(
-                    static_cast<void*>(ptrs), static_cast<void*>(std::addressof(result)));
-                if (!skipOriginal) {
-                    result = g_orig(args...);
-                }
-                dispatch_post(static_cast<void*>(ptrs), static_cast<void*>(std::addressof(result)));
-                return result;
-            }
-        }
-    }
-};
-
-namespace detail {
-template <auto Target>
-using TargetTag = std::integral_constant<decltype(Target), Target>;
-template <FixedString Name>
-struct NameTag {};
-}  // namespace detail
-
-/*
- * Typed hook on a function named at compile time (&daAlink_c::execute, &free_fn).
- * Member functions may be virtual: the install decodes the member function pointer and hooks the
- * class's own overrider.
- */
-template <auto Target>
-struct Hook;
-
-template <class C, class R, class... A, R (C::*Target)(A...)>
-struct Hook<Target> : HookImpl<detail::TargetTag<Target>, R, C*, A...> {
-    static ModResult resolve_target(const HookService* hooks, void** out) {
-        return detail::member_target<C>(hooks, Target, out);
-    }
-};
-
-template <class C, class R, class... A, R (C::*Target)(A...) const>
-struct Hook<Target> : HookImpl<detail::TargetTag<Target>, R, const C*, A...> {
-    static ModResult resolve_target(const HookService* hooks, void** out) {
-        return detail::member_target<C>(hooks, Target, out);
-    }
-};
-
-template <class R, class... A, R (*Target)(A...)>
-struct Hook<Target> : HookImpl<detail::TargetTag<Target>, R, A...> {
-    static ModResult resolve_target(const HookService*, void** out) {
-        *out = mfp_addr(Target);
-        return MOD_OK;
-    }
-};
-
-/*
- * Typed hook on a function by its symbol name, for targets you can't name in C++: file-local
- * statics, private members, or symbols without a header. The signature is written free-style with
- * the receiver first and is *not* compiler-checked.
- *
- *   using HookshotHit = dusk::mods::NamedHook<
- *       "daAlink_hookshotAtHitCallBack",
- *       void(fopAc_ac_c*, dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*)>;
- *   dusk::mods::hook_add_pre<HookshotHit>(svc_hook, on_hookshot_hit);
- */
-template <FixedString Name, class Sig>
-struct NamedHook;
-
-template <FixedString Name, class R, class... A>
-struct NamedHook<Name, R(A...)> : HookImpl<detail::NameTag<Name>, R, A...> {
-    static ModResult resolve_target(const HookService* hooks, void** out) {
-        HookSymbolFlags flags{};
-        const ModResult resolved = hooks->resolve(mod_ctx, Name.chars, out, &flags);
-        if (resolved == MOD_OK && (flags & HOOK_SYMBOL_CODE) == 0) {
-            *out = nullptr;
-            return MOD_INVALID_ARGUMENT;
-        }
-        return resolved;
-    }
-};
-
-template <class Entry>
-ModResult hook_install(const HookService* hooks) {
-    if (hooks == nullptr) {
-        return MOD_UNAVAILABLE;
-    }
-
-    Entry::hooks = hooks;
-    if (Entry::target == nullptr) {
-        const ModResult resolved = Entry::resolve_target(hooks, &Entry::target);
-        if (resolved != MOD_OK) {
-            return resolved;
-        }
-    }
-    return hooks->install(mod_ctx, Entry::target, reinterpret_cast<void*>(Entry::trampoline),
-        reinterpret_cast<void**>(&Entry::g_orig));
-}
-
-template <auto Target>
-ModResult hook_install(const HookService* hooks) {
-    return hook_install<Hook<Target> >(hooks);
-}
-
-template <class Entry>
-ModResult hook_add_pre(
-    const HookService* hooks, HookPreFn callback, const HookOptions* options = nullptr) {
-    const ModResult installed = hook_install<Entry>(hooks);
-    if (installed != MOD_OK) {
-        return installed;
-    }
-
-    return hooks->add_pre(mod_ctx, Entry::target, callback, options);
-}
-
-template <auto Target>
-ModResult hook_add_pre(
-    const HookService* hooks, HookPreFn callback, const HookOptions* options = nullptr) {
-    return hook_add_pre<Hook<Target> >(hooks, callback, options);
-}
-
-template <class Entry>
-ModResult hook_add_post(
-    const HookService* hooks, HookPostFn callback, const HookOptions* options = nullptr) {
-    const ModResult installed = hook_install<Entry>(hooks);
-    if (installed != MOD_OK) {
-        return installed;
-    }
-
-    return hooks->add_post(mod_ctx, Entry::target, callback, options);
-}
-
-template <auto Target>
-ModResult hook_add_post(
-    const HookService* hooks, HookPostFn callback, const HookOptions* options = nullptr) {
-    return hook_add_post<Hook<Target> >(hooks, callback, options);
-}
-
-template <class Entry>
-ModResult hook_replace(
-    const HookService* hooks, HookReplaceFn callback, const HookOptions* options = nullptr) {
-    const ModResult installed = hook_install<Entry>(hooks);
-    if (installed != MOD_OK) {
-        return installed;
-    }
-
-    return hooks->replace(mod_ctx, Entry::target, callback, options);
-}
-
-template <auto Target>
-ModResult hook_replace(
-    const HookService* hooks, HookReplaceFn callback, const HookOptions* options = nullptr) {
-    return hook_replace<Hook<Target> >(hooks, callback, options);
-}
-
-}  // namespace dusk::mods
diff --git a/include/mods/service.hpp b/include/mods/service.hpp
deleted file mode 100644
index d79b53f24d..0000000000
--- a/include/mods/service.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#pragma once
-
-#include "mods/api.h"
-
-#include <cstdint>
-#include <cstdio>
-#include <type_traits>
-#include <vector>
-
-namespace dusk::mods {
-
-template <class Service>
-struct ServiceTraits;
-
-namespace detail {
-
-inline std::vector<ServiceImport>& imports() {
-    static std::vector<ServiceImport> entries;
-    return entries;
-}
-
-inline std::vector<ServiceExport>& exports() {
-    static std::vector<ServiceExport> entries;
-    return entries;
-}
-
-inline int register_import(ServiceImport entry) {
-    imports().push_back(entry);
-    return 0;
-}
-
-inline int register_export(ServiceExport entry) {
-    exports().push_back(entry);
-    return 0;
-}
-
-inline const ModManifest* manifest() {
-    static ModManifest manifest{
-        sizeof(ModManifest),
-        MOD_ABI_VERSION,
-        nullptr,
-        0,
-        nullptr,
-        0,
-    };
-
-    auto& importEntries = imports();
-    auto& exportEntries = exports();
-    manifest.imports = importEntries.data();
-    manifest.import_count = importEntries.size();
-    manifest.exports = exportEntries.data();
-    manifest.export_count = exportEntries.size();
-    return &manifest;
-}
-
-}  // namespace detail
-
-inline ModResult set_error(ModError* outError, ModResult code, const char* message) {
-    if (outError != nullptr && outError->struct_size >= sizeof(ModError)) {
-        outError->code = code;
-        outError->message[0] = '\0';
-        if (message != nullptr) {
-            std::snprintf(outError->message, sizeof(outError->message), "%s", message);
-        }
-    }
-    return code;
-}
-
-}  // namespace dusk::mods
-
-#define DEFINE_MOD()                                                                               \
-    extern "C" {                                                                                   \
-    MOD_EXPORT ModContext* mod_ctx = nullptr;                                                      \
-    MOD_EXPORT const ModManifest* mod_get_manifest(void) {                                         \
-        return ::dusk::mods::detail::manifest();                                                   \
-    }                                                                                              \
-    }
-
-// Declares `static const service_type* variable`, filled in by the host before mod_initialize.
-// Required imports are guaranteed non-null (the mod fails to load otherwise); optional imports
-// must be checked against nullptr before use.
-#define IMPORT_SERVICE_EX(                                                                         \
-    service_type, variable, service_id_value, major_value, min_minor_value, flags_value)           \
-    static const service_type* variable = nullptr;                                                 \
-    [[maybe_unused]] static const int mod_import_registration_##variable =                         \
-        ::dusk::mods::detail::register_import(ServiceImport{                                       \
-            sizeof(ServiceImport),                                                                 \
-            (service_id_value),                                                                    \
-            static_cast<uint16_t>(major_value),                                                    \
-            static_cast<uint16_t>(min_minor_value),                                                \
-            static_cast<uint32_t>(flags_value),                                                    \
-            &(variable),                                                                           \
-        })
-
-#define IMPORT_SERVICE_VERSION(service_type, variable, min_minor_value)                            \
-    IMPORT_SERVICE_EX(service_type, variable, ::dusk::mods::ServiceTraits<service_type>::id,       \
-        ::dusk::mods::ServiceTraits<service_type>::major_version, min_minor_value,                 \
-        SERVICE_IMPORT_REQUIRED)
-
-#define IMPORT_SERVICE(service_type, variable) IMPORT_SERVICE_VERSION(service_type, variable, 0)
-
-#define IMPORT_OPTIONAL_SERVICE_VERSION(service_type, variable, min_minor_value)                   \
-    IMPORT_SERVICE_EX(service_type, variable, ::dusk::mods::ServiceTraits<service_type>::id,       \
-        ::dusk::mods::ServiceTraits<service_type>::major_version, min_minor_value,                 \
-        SERVICE_IMPORT_OPTIONAL)
-
-#define IMPORT_OPTIONAL_SERVICE(service_type, variable)                                            \
-    IMPORT_OPTIONAL_SERVICE_VERSION(service_type, variable, 0)
-
-#define EXPORT_SERVICE_AS(instance, service_id_value)                                              \
-    namespace {                                                                                    \
-    const int mod_export_registration_##instance =                                                 \
-        ::dusk::mods::detail::register_export(ServiceExport{                                       \
-            sizeof(ServiceExport),                                                                 \
-            (service_id_value),                                                                    \
-            (instance).header.major_version,                                                       \
-            (instance).header.minor_version,                                                       \
-            SERVICE_EXPORT_STATIC,                                                                 \
-            &(instance),                                                                           \
-        });                                                                                        \
-    }
-
-#define EXPORT_SERVICE(instance)                                                                   \
-    EXPORT_SERVICE_AS(                                                                             \
-        instance, ::dusk::mods::ServiceTraits<std::remove_cv_t<decltype(instance)> >::id)
-
-#define EXPORT_DEFERRED_SERVICE(token, service_id_value, major_value, minor_value)                 \
-    namespace {                                                                                    \
-    const int mod_deferred_export_registration_##token =                                           \
-        ::dusk::mods::detail::register_export(ServiceExport{                                       \
-            sizeof(ServiceExport),                                                                 \
-            (service_id_value),                                                                    \
-            static_cast<uint16_t>(major_value),                                                    \
-            static_cast<uint16_t>(minor_value),                                                    \
-            SERVICE_EXPORT_DEFERRED,                                                               \
-            nullptr,                                                                               \
-        });                                                                                        \
-    }
diff --git a/include/os_report.h b/include/os_report.h
index 78177a199d..0831e45396 100644
--- a/include/os_report.h
+++ b/include/os_report.h
@@ -25,16 +25,10 @@ DECL_WEAK void OSReportForceEnableOn(void);
 #define OS_PANIC(...)
 #endif
 
-extern u8 __OSReport_disable;
+DUSK_GAME_EXTERN u8 __OSReport_disable;
 extern u8 __OSReport_Error_disable;
 extern u8 __OSReport_Warning_disable;
 extern u8 __OSReport_System_disable;
 extern u8 __OSReport_enable;
 
-#if TARGET_PC
-namespace dusk {
-    extern bool OSReportReallyForceEnable;
-}
-#endif
-
 #endif  // _OS_REPORT_H
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DManage.h b/libs/JSystem/include/JSystem/J2DGraph/J2DManage.h
index 27218d0d0d..3eb1967e2c 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DManage.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DManage.h
@@ -3,6 +3,10 @@
 
 #include <types.h>
 
+#if TARGET_PC
+    #include "helpers/endian.h"
+#endif
+
 class JSUInputStream;
 
 /**
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DMatBlock.h b/libs/JSystem/include/JSystem/J2DGraph/J2DMatBlock.h
index 7a5a3e594a..340f4014ed 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DMatBlock.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DMatBlock.h
@@ -892,7 +892,7 @@ struct J2DBlendInfo {
     /* 0x3 */ u8 mOp;
 };
 
-extern const J2DBlendInfo j2dDefaultBlendInfo;
+DUSK_GAME_EXTERN const J2DBlendInfo j2dDefaultBlendInfo;
 
 /**
  * @ingroup jsystem-j2d
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DMaterialFactory.h b/libs/JSystem/include/JSystem/J2DGraph/J2DMaterialFactory.h
index f82788d57c..1eddcb943a 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DMaterialFactory.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DMaterialFactory.h
@@ -4,7 +4,7 @@
 #include "JSystem/J2DGraph/J2DManage.h"
 #include "JSystem/J2DGraph/J2DMatBlock.h"
 
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-j2d
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DPane.h b/libs/JSystem/include/JSystem/J2DGraph/J2DPane.h
index 60f382f064..a588b4e7f7 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DPane.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DPane.h
@@ -5,7 +5,7 @@
 #include "JSystem/JSupport/JSUList.h"
 #include <gx.h>
 #include <mtx.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J2DAnmBase;
 class J2DAnmColor;
@@ -201,7 +201,7 @@ public:
 
     static s16 J2DCast_F32_to_S16(f32 value, u8 arg2);
 
-    static JGeometry::TBox2<f32> static_mBounds;
+    static DUSK_GAME_DATA JGeometry::TBox2<f32> static_mBounds;
 
 public:
     /* 0x04 */ u16 field_0x4;
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h b/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h
index f738a96dd4..f311e191fa 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DPicture.h
@@ -4,7 +4,7 @@
 #include "JSystem/J2DGraph/J2DPane.h"
 #include "JSystem/JUtility/JUTTexture.h"
 #include "JSystem/JUtility/TColor.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J2DMaterial;
 class JUTPalette;
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DPrint.h b/libs/JSystem/include/JSystem/J2DGraph/J2DPrint.h
index aa0ffbdcf1..64e1b25139 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DPrint.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DPrint.h
@@ -67,8 +67,8 @@ public:
         mFontSizeY = y;
     }
 
-    static char* mStrBuff;
-    static size_t mStrBuffSize;
+    static DUSK_GAME_DATA char* mStrBuff;
+    static DUSK_GAME_DATA size_t mStrBuffSize;
 
 private:
     void private_initiate(JUTFont*, f32, f32, JUtility::TColor, JUtility::TColor,
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DScreen.h b/libs/JSystem/include/JSystem/J2DGraph/J2DScreen.h
index ef83eee36e..ffc7568846 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DScreen.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DScreen.h
@@ -4,7 +4,7 @@
 #include "JSystem/J2DGraph/J2DManage.h"
 #include "JSystem/J2DGraph/J2DPane.h"
 #include "JSystem/JUtility/TColor.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J2DMaterial;
 class JUTNameTab;
@@ -90,7 +90,7 @@ public:
 
     static J2DDataManage* getDataManage() { return mDataManage; }
 
-    static J2DDataManage* mDataManage;
+    static DUSK_GAME_DATA J2DDataManage* mDataManage;
 
     /* 0x100 */ bool mScissor;
     /* 0x102 */ u16 mMaterialNum;
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DTevs.h b/libs/JSystem/include/JSystem/J2DGraph/J2DTevs.h
index ea81bc869f..e515321188 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DTevs.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DTevs.h
@@ -4,7 +4,7 @@
 #include <gx.h>
 #include <mtx.h>
 #include "global.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-j2d
@@ -46,7 +46,7 @@ struct J2DTexMtxInfo {
 
 };  // Size: 0x24
 
-extern J2DTexMtxInfo const j2dDefaultTexMtxInfo;
+DUSK_GAME_EXTERN J2DTexMtxInfo const j2dDefaultTexMtxInfo;
 
 /**
  * @ingroup jsystem-j2d
@@ -86,7 +86,7 @@ struct J2DIndTexOrderInfo {
     GXTexMapID getTexMapID() const { return (GXTexMapID)mTexMapID; }
 };
 
-extern const J2DIndTexOrderInfo j2dDefaultIndTexOrderNull;
+DUSK_GAME_EXTERN const J2DIndTexOrderInfo j2dDefaultIndTexOrderNull;
 
 /**
  * @ingroup jsystem-j2d
@@ -130,7 +130,7 @@ struct J2DIndTexMtxInfo {
     }
 };
 
-extern J2DIndTexMtxInfo const j2dDefaultIndTexMtxInfo;
+DUSK_GAME_EXTERN J2DIndTexMtxInfo const j2dDefaultIndTexMtxInfo;
 
 /**
  * @ingroup jsystem-j2d
@@ -175,7 +175,7 @@ struct J2DIndTexCoordScaleInfo {
     GXIndTexScale getScaleT() const { return (GXIndTexScale)mScaleT; }
 };
 
-extern const J2DIndTexCoordScaleInfo j2dDefaultIndTexCoordScaleInfo;
+DUSK_GAME_EXTERN const J2DIndTexCoordScaleInfo j2dDefaultIndTexCoordScaleInfo;
 
 /**
  * @ingroup jsystem-j2d
@@ -239,7 +239,7 @@ inline u32 J2DCalcIndTevStage(J2DIndTevStageInfo info) {
            (info.mBiasSel << 4)  | (info.mIndFormat << 2)  | (info.mIndStage);
 }
 
-extern const J2DIndTevStageInfo j2dDefaultIndTevStageInfo;
+DUSK_GAME_EXTERN const J2DIndTevStageInfo j2dDefaultIndTevStageInfo;
 
 /**
  * @ingroup jsystem-j2d
@@ -289,7 +289,7 @@ struct J2DTexCoordInfo {
     }
 };
 
-extern J2DTexCoordInfo const j2dDefaultTexCoordInfo[8];
+DUSK_GAME_EXTERN J2DTexCoordInfo const j2dDefaultTexCoordInfo[8];
 
 /**
  * @ingroup jsystem-j2d
@@ -332,7 +332,7 @@ struct J2DTevOrderInfo {
     }
 };
 
-extern const J2DTevOrderInfo j2dDefaultTevOrderInfoNull;
+DUSK_GAME_EXTERN const J2DTevOrderInfo j2dDefaultTevOrderInfoNull;
 
 /**
  * @ingroup jsystem-j2d
@@ -383,7 +383,7 @@ struct J2DTevStageInfo {
     /* 0x13 */ u8 field_0x13;
 };
 
-extern J2DTevStageInfo const j2dDefaultTevStageInfo;
+DUSK_GAME_EXTERN J2DTevStageInfo const j2dDefaultTevStageInfo;
 
 /**
  * @ingroup jsystem-j2d
@@ -396,7 +396,7 @@ struct J2DTevSwapModeInfo {
     /* 0x3 */ u8 field_0x3;
 };
 
-extern const J2DTevSwapModeInfo j2dDefaultTevSwapMode;
+DUSK_GAME_EXTERN const J2DTevSwapModeInfo j2dDefaultTevSwapMode;
 
 /**
  * @ingroup jsystem-j2d
@@ -565,8 +565,8 @@ inline u8 J2DCalcTevSwapTable(u8 param_0, u8 param_1, u8 param_2, u8 param_3) {
     return (param_0 << 6) + (param_1 << 4) + (param_2 << 2) + param_3;
 }
 
-extern const J2DTevSwapModeTableInfo j2dDefaultTevSwapModeTable;
-extern const u8 j2dDefaultTevSwapTableID;
+DUSK_GAME_EXTERN const J2DTevSwapModeTableInfo j2dDefaultTevSwapModeTable;
+DUSK_GAME_EXTERN const u8 j2dDefaultTevSwapTableID;
 
 /**
  * @ingroup jsystem-j2d
@@ -615,7 +615,7 @@ struct J2DColorChanInfo {
 };
 
 inline u16 J2DCalcColorChanID(u8 param_0) { return param_0; }
-extern const J2DColorChanInfo j2dDefaultColorChanInfo;
+DUSK_GAME_EXTERN const J2DColorChanInfo j2dDefaultColorChanInfo;
 
 /**
  * @ingroup jsystem-j2d
@@ -644,12 +644,12 @@ private:
     /* 0x0 */ u16 mColorChan;
 };
 
-extern const GXColor j2dDefaultColInfo;
-extern const GXColorS10 j2dDefaultTevColor;
-extern const GXColor j2dDefaultTevKColor;
-extern const J2DTevOrderInfo j2dDefaultTevOrderInfoNull;
-extern const u8 j2dDefaultPEBlockDither;
-extern const u8 j2dDefaultTevSwapTableID;
-extern const u16 j2dDefaultAlphaCmp;
+DUSK_GAME_EXTERN const GXColor j2dDefaultColInfo;
+DUSK_GAME_EXTERN const GXColorS10 j2dDefaultTevColor;
+DUSK_GAME_EXTERN const GXColor j2dDefaultTevKColor;
+DUSK_GAME_EXTERN const J2DTevOrderInfo j2dDefaultTevOrderInfoNull;
+DUSK_GAME_EXTERN const u8 j2dDefaultPEBlockDither;
+DUSK_GAME_EXTERN const u8 j2dDefaultTevSwapTableID;
+DUSK_GAME_EXTERN const u16 j2dDefaultAlphaCmp;
 
 #endif /* J2DTEVS_H */
diff --git a/libs/JSystem/include/JSystem/J2DGraph/J2DTextBox.h b/libs/JSystem/include/JSystem/J2DGraph/J2DTextBox.h
index 0d875ad652..96a53c5a16 100644
--- a/libs/JSystem/include/JSystem/J2DGraph/J2DTextBox.h
+++ b/libs/JSystem/include/JSystem/J2DGraph/J2DTextBox.h
@@ -3,8 +3,8 @@
 
 #include "JSystem/J2DGraph/J2DMaterial.h"
 #include "JSystem/J2DGraph/J2DPane.h"
-#include "dusk/endian.h"
-#include "dusk/string.hpp"
+#include "helpers/endian.h"
+#include "helpers/string.hpp"
 
 class J2DMaterial;
 class JUTFont;
@@ -100,7 +100,7 @@ public:
                                  J2DTextBoxVBinding);
     void private_readStream(J2DPane*, JSURandomInputStream*, JKRArchive*);
     TEXT_SPAN getStringPtr() const;
-    dusk::TextSpan getSpan() const;
+    TextSpan getSpan() const;
     s32 setString(s16, char const*, ...);
     s32 setString(char const*, ...);
 
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DAnimation.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DAnimation.h
index 3c5133e880..f006183d07 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DAnimation.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DAnimation.h
@@ -6,7 +6,7 @@
 #include <mtx.h>
 #include "global.h"
 
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 #if TARGET_PC
 #define OFFSET_PTR_V0 BE(u32)
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DCluster.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DCluster.h
index 2a71ada3dd..4704fe1ee1 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DCluster.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DCluster.h
@@ -3,7 +3,7 @@
 
 #include "JSystem/J3DAssert.h"
 #include "JSystem/J3DGraphLoader/J3DClusterLoader.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J3DDeformer;
 class J3DClusterKey;
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJoint.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJoint.h
index 0a10f035be..7f57ed877b 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJoint.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJoint.h
@@ -53,8 +53,8 @@ public:
     }
     static void setJoint(J3DJoint* joint) { mJoint = joint; }
 
-    static J3DMtxBuffer* mMtxBuffer;
-    static J3DJoint* mJoint;
+    static DUSK_GAME_DATA J3DMtxBuffer* mMtxBuffer;
+    static DUSK_GAME_DATA J3DJoint* mJoint;
 };  // Size: 0x4
 
 typedef int (*J3DJointCallBack)(J3DJoint*, int);
@@ -100,7 +100,7 @@ public:
     void setMtxType(u8 type) { mKind = (mKind & ~0xf0) | (type << 4); }
     f32 getRadius() const { return mBoundingSphereRadius; }
 
-    static J3DMtxCalc* mCurrentMtxCalc;
+    static DUSK_GAME_DATA J3DMtxCalc* mCurrentMtxCalc;
 
     u8 getKind() const { return mKind & 15; }
 
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJointTree.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJointTree.h
index 92b252fb7a..e4018f1ea2 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJointTree.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DJointTree.h
@@ -3,7 +3,7 @@
 
 #include "JSystem/J3DAssert.h"
 #include "JSystem/J3DGraphBase/J3DTransform.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J3DJoint;
 class J3DMtxBuffer;
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DModel.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DModel.h
index 2e5b3bd38d..a7edb19b70 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DModel.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DModel.h
@@ -3,7 +3,6 @@
 
 #include "JSystem/J3DGraphAnimator/J3DSkinDeform.h"
 #include "JSystem/J3DGraphBase/J3DPacket.h"
-#include "dusk/frame_interpolation.h"
 #include <types.h>
 
 enum J3DMdlFlag {
@@ -80,7 +79,9 @@ public:
     virtual ~J3DModel() {}
 
 #if TARGET_PC
-    static void interp_callback(bool isSimFrame, void* pUserWork);
+    static void interp_callback(void* pUserWork);
+    void calc_presentation_base_mtx();
+    void prepare_presentation_view();
 #endif
 
     J3DModelData* getModelData() { return mModelData; }
@@ -106,12 +107,13 @@ public:
     void setUserArea(uintptr_t area) { mUserArea = area; }
     uintptr_t getUserArea() const { return mUserArea; }
     Vec* getBaseScale() { return &mBaseScale; }
+#if TARGET_PC
+    void setAnmMtx(int jointNo, Mtx m);
+#else
     void setAnmMtx(int jointNo, Mtx m) {
         mMtxBuffer->setAnmMtx(jointNo, m);
-#ifdef TARGET_PC
-        dusk::frame_interp::record_final_mtx(mMtxBuffer->getAnmMtx(jointNo));
-#endif
     }
+#endif
     MtxP getAnmMtx(int jointNo) { return mMtxBuffer->getAnmMtx(jointNo); }
     MtxP getWeightAnmMtx(int i) { return mMtxBuffer->getWeightAnmMtx(i); }
     J3DSkinDeform* getSkinDeform() { return mSkinDeform; }
@@ -133,6 +135,9 @@ public:
     /* 0xD0 */ J3DVtxColorCalc* mVtxColorCalc;
     /* 0xD4 */ J3DUnkCalc1* mUnkCalc1;
     /* 0xD8 */ J3DUnkCalc2* mUnkCalc2;
+#if TARGET_PC
+    Mtx mPresentationBase;
+#endif
 };
 
 #endif /* J3DMODEL_H */
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h
index e61bbbe231..3a9538a58d 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DMtxBuffer.h
@@ -62,10 +62,10 @@ public:
         mpNrmMtxArr[1][mCurrentViewNo] = tmp;
     }
 
-    static Mtx sNoUseDrawMtx;
-    static Mtx33 sNoUseNrmMtx;
-    static Mtx* sNoUseDrawMtxPtr;
-    static Mtx33* sNoUseNrmMtxPtr;
+    static DUSK_GAME_DATA Mtx sNoUseDrawMtx;
+    static DUSK_GAME_DATA Mtx33 sNoUseNrmMtx;
+    static DUSK_GAME_DATA Mtx* sNoUseDrawMtxPtr;
+    static DUSK_GAME_DATA Mtx33* sNoUseNrmMtxPtr;
 
     /* 0x00 */ J3DJointTree* mJointTree;
     /* 0x04 */ u8* mpScaleFlagArr;
diff --git a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h
index e68b3ab02c..3799687f93 100644
--- a/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h
+++ b/libs/JSystem/include/JSystem/J3DGraphAnimator/J3DSkinDeform.h
@@ -59,9 +59,9 @@ public:
     virtual void deform(J3DVertexBuffer*, J3DMtxBuffer*);
     virtual ~J3DSkinDeform();
 
-    static BE(u16)* sWorkArea_WEvlpMixMtx[1024];
-    static BE(f32)* sWorkArea_WEvlpMixWeight[1024];
-    static u16 sWorkArea_MtxReg[1024];
+    static DUSK_GAME_DATA BE(u16)* sWorkArea_WEvlpMixMtx[1024];
+    static DUSK_GAME_DATA BE(f32)* sWorkArea_WEvlpMixWeight[1024];
+    static DUSK_GAME_DATA u16 sWorkArea_MtxReg[1024];
 
 private:
     /* 0x04 */ u16* mPosData;
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DDrawBuffer.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
index 68be132081..a55f9ebcf1 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DDrawBuffer.h
@@ -99,9 +99,9 @@ public:
     /* 0x1C */ MtxP mpZMtx;
     /* 0x20 */ J3DPacket* mpCallBackPacket;
 
-    static sortFunc sortFuncTable[6];
-    static drawFunc drawFuncTable[2];
-    static int entryNum;
+    static DUSK_GAME_DATA sortFunc sortFuncTable[6];
+    static DUSK_GAME_DATA drawFunc drawFuncTable[2];
+    static DUSK_GAME_DATA int entryNum;
 };
 
 #endif /* J3DDRAWBUFFER_H */
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DMatBlock.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DMatBlock.h
index 859bd6943e..dbb3877dc3 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DMatBlock.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DMatBlock.h
@@ -1437,7 +1437,7 @@ inline u16 calcZModeID(u8 param_0, u8 param_1, u8 param_2) {
     return param_1 * 2 + param_0 * 0x10 + param_2;
 }
 
-extern u8 j3dZModeTable[96];
+DUSK_GAME_EXTERN u8 j3dZModeTable[96];
 
 /**
  * @ingroup jsystem-j3d
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DPacket.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DPacket.h
index 4be9fe1f17..992d96b255 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DPacket.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DPacket.h
@@ -125,8 +125,8 @@ public:
     u8* getDisplayList(int idx) { return (u8*)mpDisplayList[idx]; }
     u32 getDisplayListSize() { return mSize; }
 
-    static GDLObj sGDLObj;
-    static s32 sInterruptFlag;
+    static DUSK_GAME_DATA GDLObj sGDLObj;
+    static DUSK_GAME_DATA s32 sInterruptFlag;
 
     /* 0x0 */ void* mpDisplayList[2];
     /* 0x8 */ u32 mSize;
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DShape.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DShape.h
index 5477868596..4ba3cc8023 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DShape.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DShape.h
@@ -4,8 +4,10 @@
 #include "JSystem/J3DGraphBase/J3DShapeDraw.h"
 #include "JSystem/J3DAssert.h"
 #include "JSystem/J3DGraphBase/J3DFifo.h"
+#include "JSystem/JMath/JMath.h"
+#include "global.h"
 #include <mtx.h>
-#include "dusk/endian_gx.hpp"
+#include "helpers/endian_gx.hpp"
 
 class J3DShapeMtx;
 
@@ -78,13 +80,13 @@ public:
     virtual void load() const;
     virtual void calcNBTScale(Vec const&, f32 (*)[3][3], f32 (*)[3][3]);
 
-    static J3DShapeMtx_LoadFunc sMtxLoadPipeline[4];
-    static u16 sMtxLoadCache[10];
-    static u32 sCurrentPipeline;
-    static u8* sCurrentScaleFlag;
-    static bool sNBTFlag;
-    static bool sLODFlag;
-    static u32 sTexMtxLoadType;
+    static DUSK_GAME_DATA J3DShapeMtx_LoadFunc sMtxLoadPipeline[4];
+    static DUSK_GAME_DATA u16 sMtxLoadCache[10];
+    static DUSK_GAME_DATA u32 sCurrentPipeline;
+    static DUSK_GAME_DATA u8* sCurrentScaleFlag;
+    static DUSK_GAME_DATA bool sNBTFlag;
+    static DUSK_GAME_DATA bool sLODFlag;
+    static DUSK_GAME_DATA u32 sTexMtxLoadType;
 
     static void setCurrentPipeline(u32 pipeline) {
         J3D_ASSERT_RANGE(91, pipeline < 4);
@@ -202,8 +204,8 @@ public:
 
     static void resetVcdVatCache() { sOldVcdVatCmd = NULL; }
 
-    static void* sOldVcdVatCmd;
-    static bool sEnvelopeFlag;
+    static DUSK_GAME_DATA void* sOldVcdVatCmd;
+    static DUSK_GAME_DATA bool sEnvelopeFlag;
 
 private:
     friend struct J3DShapeFactory;
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DShapeMtx.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DShapeMtx.h
index 313fa1ef30..2b7ad8ad35 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DShapeMtx.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DShapeMtx.h
@@ -4,7 +4,7 @@
 #include "JSystem/J3DGraphBase/J3DShape.h"
 #include "JSystem/J3DAssert.h"
 #include <mtx.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J3DTexMtx;
 class J3DTexGenBlock;
@@ -22,8 +22,8 @@ public:
             loadExecute(m);
     }
 
-    static J3DTexGenBlock* sTexGenBlock;
-    static J3DTexMtxObj* sTexMtxObj;
+    static DUSK_GAME_DATA J3DTexGenBlock* sTexGenBlock;
+    static DUSK_GAME_DATA J3DTexMtxObj* sTexMtxObj;
 };
 
 class J3DShapeMtxConcatView;
@@ -75,9 +75,9 @@ public:
     void loadMtxConcatView_PNCPU(int, u16) const;
     void loadMtxConcatView_PNGP_LOD(int, u16) const;
 
-    static J3DShapeMtxConcatView_LoadFunc sMtxLoadPipeline[4];
-    static J3DShapeMtxConcatView_LoadFunc sMtxLoadLODPipeline[4];
-    static MtxP sMtxPtrTbl[2];
+    static DUSK_GAME_DATA J3DShapeMtxConcatView_LoadFunc sMtxLoadPipeline[4];
+    static DUSK_GAME_DATA J3DShapeMtxConcatView_LoadFunc sMtxLoadLODPipeline[4];
+    static DUSK_GAME_DATA MtxP sMtxPtrTbl[2];
 };
 
 /**
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DStruct.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DStruct.h
index 05663fd84e..0de93bcaf5 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DStruct.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DStruct.h
@@ -7,7 +7,7 @@
 #include "global.h"
 #include "JSystem/JMath/JMath.h"
 
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-j3d
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DSys.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DSys.h
index 8c4bbd06e3..a4750e5d29 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DSys.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DSys.h
@@ -6,8 +6,8 @@
 
 #include "JSystem/J3DAssert.h"
 #include "JSystem/JMath/JMath.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
+#include "global.h"
 
 enum J3DSysDrawBuf {
     /* 0x0 */ J3DSysDrawBuf_Opa,
@@ -189,25 +189,23 @@ struct J3DSys {
     Mtx& getModelDrawMtx(u16 no) { return mModelDrawMtx[no]; }
     J3DShapePacket* getShapePacket() { return mShapePacket; }
 
+#if TARGET_PC
+    void setViewMtx(const Mtx m);
+#else
     void setViewMtx(const Mtx m) {
-#ifdef TARGET_PC
-        Mtx patched;
-        if (dusk::frame_interp::lookup_replacement(m, patched)) {
-            m = patched;
-        }
-#endif
         MTXCopy(m, mViewMtx);
     }
+#endif
 
     J3DModel* getModel() { return mModel; }
 
-    static Mtx mCurrentMtx;
-    static Vec mCurrentS;
-    static Vec mParentS;
-    static J3DTexCoordScaleInfo sTexCoordScaleTable[8];
+    static DUSK_GAME_DATA Mtx mCurrentMtx;
+    static DUSK_GAME_DATA Vec mCurrentS;
+    static DUSK_GAME_DATA Vec mParentS;
+    static DUSK_GAME_DATA J3DTexCoordScaleInfo sTexCoordScaleTable[8];
 };
 
-extern u32 j3dDefaultViewNo;
-extern J3DSys j3dSys;
+DUSK_GAME_EXTERN u32 j3dDefaultViewNo;
+DUSK_GAME_EXTERN J3DSys j3dSys;
 
 #endif /* J3DSYS_H */
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DTevs.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DTevs.h
index b0e2abfaae..c3d8dde2a4 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DTevs.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DTevs.h
@@ -6,32 +6,32 @@
 #include "JSystem/J3DGraphBase/J3DGD.h"
 #include "JSystem/J3DGraphBase/J3DStruct.h"
 
-extern u8 j3dTevSwapTableTable[1024];
+DUSK_GAME_EXTERN u8 j3dTevSwapTableTable[1024];
 
-extern const J3DLightInfo j3dDefaultLightInfo;
-extern const J3DTexCoordInfo j3dDefaultTexCoordInfo[8];
-extern const J3DTexMtxInfo j3dDefaultTexMtxInfo;
-extern const J3DIndTexMtxInfo j3dDefaultIndTexMtxInfo;
-extern const J3DTevStageInfo j3dDefaultTevStageInfo;
-extern const J3DIndTevStageInfo j3dDefaultIndTevStageInfo;
-extern const J3DFogInfo j3dDefaultFogInfo;
-extern const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
+DUSK_GAME_EXTERN const J3DLightInfo j3dDefaultLightInfo;
+DUSK_GAME_EXTERN const J3DTexCoordInfo j3dDefaultTexCoordInfo[8];
+DUSK_GAME_EXTERN const J3DTexMtxInfo j3dDefaultTexMtxInfo;
+DUSK_GAME_EXTERN const J3DIndTexMtxInfo j3dDefaultIndTexMtxInfo;
+DUSK_GAME_EXTERN const J3DTevStageInfo j3dDefaultTevStageInfo;
+DUSK_GAME_EXTERN const J3DIndTevStageInfo j3dDefaultIndTevStageInfo;
+DUSK_GAME_EXTERN const J3DFogInfo j3dDefaultFogInfo;
+DUSK_GAME_EXTERN const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
 
-extern const GXColor j3dDefaultColInfo;
-extern const GXColor j3dDefaultAmbInfo;
+DUSK_GAME_EXTERN const GXColor j3dDefaultColInfo;
+DUSK_GAME_EXTERN const GXColor j3dDefaultAmbInfo;
 extern const u8 j3dDefaultColorChanNum;
-extern const J3DTevOrderInfo j3dDefaultTevOrderInfoNull;
-extern const J3DIndTexOrderInfo j3dDefaultIndTexOrderNull;
-extern const GXColorS10 j3dDefaultTevColor;
-extern const J3DIndTexCoordScaleInfo j3dDefaultIndTexCoordScaleInfo;
-extern const GXColor j3dDefaultTevKColor;
-extern const J3DTevSwapModeInfo j3dDefaultTevSwapMode;
-extern const J3DTevSwapModeTableInfo j3dDefaultTevSwapModeTable;
-extern const J3DBlendInfo j3dDefaultBlendInfo;
-extern const J3DColorChanInfo j3dDefaultColorChanInfo;
-extern const u8 j3dDefaultTevSwapTableID;
-extern const u16 j3dDefaultAlphaCmpID;
-extern const u16 j3dDefaultZModeID;
+DUSK_GAME_EXTERN const J3DTevOrderInfo j3dDefaultTevOrderInfoNull;
+DUSK_GAME_EXTERN const J3DIndTexOrderInfo j3dDefaultIndTexOrderNull;
+DUSK_GAME_EXTERN const GXColorS10 j3dDefaultTevColor;
+DUSK_GAME_EXTERN const J3DIndTexCoordScaleInfo j3dDefaultIndTexCoordScaleInfo;
+DUSK_GAME_EXTERN const GXColor j3dDefaultTevKColor;
+DUSK_GAME_EXTERN const J3DTevSwapModeInfo j3dDefaultTevSwapMode;
+DUSK_GAME_EXTERN const J3DTevSwapModeTableInfo j3dDefaultTevSwapModeTable;
+DUSK_GAME_EXTERN const J3DBlendInfo j3dDefaultBlendInfo;
+DUSK_GAME_EXTERN const J3DColorChanInfo j3dDefaultColorChanInfo;
+DUSK_GAME_EXTERN const u8 j3dDefaultTevSwapTableID;
+DUSK_GAME_EXTERN const u16 j3dDefaultAlphaCmpID;
+DUSK_GAME_EXTERN const u16 j3dDefaultZModeID;
 
 /**
  * @ingroup jsystem-j3d
@@ -191,7 +191,7 @@ struct J3DIndTevStage {
     /* 0x0 */ u32 mInfo;
 };
 
-extern const J3DTevOrderInfo j3dDefaultTevOrderInfoNull;
+DUSK_GAME_EXTERN const J3DTevOrderInfo j3dDefaultTevOrderInfoNull;
 
 /**
  * @ingroup jsystem-j3d
@@ -209,8 +209,8 @@ struct J3DTevOrder : public J3DTevOrderInfo {
     u8 getTexMap() const { return mTexMap; }
 };
 
-extern u8 j3dTevSwapTableTable[1024];
-extern u8 const j3dDefaultTevSwapTableID;
+DUSK_GAME_EXTERN u8 j3dTevSwapTableTable[1024];
+DUSK_GAME_EXTERN u8 const j3dDefaultTevSwapTableID;
 
 inline u8 calcTevSwapTableID(u8 param_0, u8 param_1, u8 param_2, u8 param_3) {
     return 0x40 * (u8)param_0 + 0x10 * (u8)param_1 + 4 * (u8)param_2 + param_3;
@@ -263,7 +263,7 @@ public:
     /* 0x34 */ GXLightObj mLightObj;
 };  // Size = 0x74
 
-extern const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
+DUSK_GAME_EXTERN const J3DNBTScaleInfo j3dDefaultNBTScaleInfo;
 
 /**
  * @ingroup jsystem-j3d
@@ -287,12 +287,12 @@ struct J3DNBTScale : public J3DNBTScaleInfo {
     BE(Vec)* getScale() { return &mScale; }
 };
 
-extern const GXColor j3dDefaultColInfo;
-extern const GXColor j3dDefaultAmbInfo;
-extern const GXColorS10 j3dDefaultTevColor;
-extern const GXColor j3dDefaultTevKColor;
-extern u8 j3dAlphaCmpTable[768];
-extern const u8 j3dDefaultNumChans;
+DUSK_GAME_EXTERN const GXColor j3dDefaultColInfo;
+DUSK_GAME_EXTERN const GXColor j3dDefaultAmbInfo;
+DUSK_GAME_EXTERN const GXColorS10 j3dDefaultTevColor;
+DUSK_GAME_EXTERN const GXColor j3dDefaultTevKColor;
+DUSK_GAME_EXTERN u8 j3dAlphaCmpTable[768];
+DUSK_GAME_EXTERN const u8 j3dDefaultNumChans;
 
 struct J3DNBTScale;
 struct J3DTexCoord;
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DTexture.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DTexture.h
index e407db84b4..516ddac887 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DTexture.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DTexture.h
@@ -7,7 +7,7 @@
 #include "global.h"
 #include <stdint.h>
 
-#include "dusk/gx_helper.h"
+#include "helpers/gx_helper.h"
 
 /**
  * @ingroup jsystem-j3d
@@ -20,7 +20,7 @@ private:
     /* 0x4 */ ResTIMG* mpRes;
 
 #if TARGET_PC
-    GXTlutObj* mpTlutObj;
+    TGXTlutObj* mpTlutObj;
     TGXTexObj* mpTexObj;
     u8** mpImgDataPtr;
     u8** mpTlutDataPtr;
@@ -31,20 +31,22 @@ public:
         J3D_ASSERT_NULLPTR(52, res != NULL || num == 0);
 #if TARGET_PC
         mpTexObj = new TGXTexObj[num];
-        mpTlutObj = new GXTlutObj[num];
+        mpTlutObj = new TGXTlutObj[num];
         mpImgDataPtr = new u8*[num];
         mpTlutDataPtr = new u8*[num];
         for (u16 i = 0; i < num; i++) {
             mpImgDataPtr[i] = (u8*)(&mpRes[i]) + mpRes[i].imageOffset;
             mpTlutDataPtr[i] = (u8*)(&mpRes[i]) + mpRes[i].paletteOffset;
-            loadGXTexObj(i);
+            initGXTexObj(i);
         }
 #endif
     }
 
     void loadGX(u16, GXTexMapID) const;
 #if TARGET_PC
-    void loadGXTexObj(u16);
+    void initGXTexObj(u16);
+    TGXTexObj* getTexObj(u16 i) const { return &mpTexObj[i]; }
+    TGXTlutObj* getTlutObj(u16 i) const { return &mpTlutObj[i]; }
 #endif
     void entryNum(u16);
     void addResTIMG(u16, ResTIMG const*);
@@ -77,7 +79,7 @@ public:
 #if TARGET_PC
         mpImgDataPtr[index] = ((u8*)&timg) + timg.imageOffset;
         mpTlutDataPtr[index] = ((u8*)&timg) + timg.paletteOffset;
-        loadGXTexObj(index);
+        initGXTexObj(index);
 #else
         mpRes[index].imageOffset = ((mpRes[index].imageOffset + (uintptr_t)&timg - (uintptr_t)(mpRes + index)));
         mpRes[index].paletteOffset = ((mpRes[index].paletteOffset + (uintptr_t)&timg - (uintptr_t)(mpRes + index)));
@@ -85,7 +87,7 @@ public:
     }
 };
 
-extern J3DTexMtxInfo const j3dDefaultTexMtxInfo;
+DUSK_GAME_EXTERN J3DTexMtxInfo const j3dDefaultTexMtxInfo;
 
 /**
  * @ingroup jsystem-j3d
@@ -117,7 +119,7 @@ private:
     /* 0x64 */ Mtx mMtx;
 };  // Size: 0x94
 
-extern J3DTexCoordInfo const j3dDefaultTexCoordInfo[8];
+DUSK_GAME_EXTERN J3DTexCoordInfo const j3dDefaultTexCoordInfo[8];
 
 /**
  * @ingroup jsystem-j3d
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DTransform.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DTransform.h
index f8f27b26d9..dfe439fbfb 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DTransform.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DTransform.h
@@ -45,10 +45,10 @@ struct J3DTransformInfo {
 #endif
 };  // Size: 0x20
 
-extern J3DTransformInfo const j3dDefaultTransformInfo;
-extern Vec const j3dDefaultScale;
-extern Mtx const j3dDefaultMtx;
-extern f32 const PSMulUnit01[];
+DUSK_GAME_EXTERN J3DTransformInfo const j3dDefaultTransformInfo;
+DUSK_GAME_EXTERN Vec const j3dDefaultScale;
+DUSK_GAME_EXTERN Mtx const j3dDefaultMtx;
+DUSK_GAME_EXTERN f32 const PSMulUnit01[];
 
 void J3DGQRSetup7(u32 param_0, u32 param_1, u32 param_2, u32 param_3);
 void J3DCalcBBoardMtx(f32 (*)[4]);
diff --git a/libs/JSystem/include/JSystem/J3DGraphBase/J3DVertex.h b/libs/JSystem/include/JSystem/J3DGraphBase/J3DVertex.h
index 1638e316e9..f7ad92afb8 100644
--- a/libs/JSystem/include/JSystem/J3DGraphBase/J3DVertex.h
+++ b/libs/JSystem/include/JSystem/J3DGraphBase/J3DVertex.h
@@ -3,7 +3,7 @@
 
 #include <gx.h>
 #include <mtx.h>
-#include "dusk/endian_gx.hpp"
+#include "helpers/endian_gx.hpp"
 
 class J3DModel;
 class J3DAnmVtxColor;
diff --git a/libs/JSystem/include/JSystem/J3DGraphLoader/J3DClusterLoader.h b/libs/JSystem/include/JSystem/J3DGraphLoader/J3DClusterLoader.h
index 2899065150..75ba644be8 100644
--- a/libs/JSystem/include/JSystem/J3DGraphLoader/J3DClusterLoader.h
+++ b/libs/JSystem/include/JSystem/J3DGraphLoader/J3DClusterLoader.h
@@ -4,7 +4,7 @@
 #include "JSystem/J3DGraphAnimator/J3DAnimation.h"
 
 #include "JSystem/J3DGraphAnimator/J3DAnimation.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 #if TARGET_PC
 #define OFFSET_PTR_V0 BE(u32)
diff --git a/libs/JSystem/include/JSystem/J3DGraphLoader/J3DModelLoader.h b/libs/JSystem/include/JSystem/J3DGraphLoader/J3DModelLoader.h
index 6c856f1a3d..a0711fd796 100644
--- a/libs/JSystem/include/JSystem/J3DGraphLoader/J3DModelLoader.h
+++ b/libs/JSystem/include/JSystem/J3DGraphLoader/J3DModelLoader.h
@@ -4,11 +4,12 @@
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include <mtx.h>
 
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class J3DModelData;
 class J3DMaterialTable;
 struct J3DModelHierarchy;
+class J3DVertexData;
 
 #if TARGET_PC
 #define OFFSET_PTR_V0 BE(u32)
diff --git a/libs/JSystem/include/JSystem/JAHostIO/JAHUpdate.h b/libs/JSystem/include/JSystem/JAHostIO/JAHUpdate.h
index 84efd7e539..8ef1c84577 100644
--- a/libs/JSystem/include/JSystem/JAHostIO/JAHUpdate.h
+++ b/libs/JSystem/include/JSystem/JAHostIO/JAHUpdate.h
@@ -8,8 +8,8 @@
 
 namespace JAHUpdate {
 
-extern JAHioNode* spNode;
-extern JORMContext* spMc;
+DUSK_GAME_EXTERN JAHioNode* spNode;
+DUSK_GAME_EXTERN JORMContext* spMc;
 
 inline void startUpdateNode(JAHioNode* param_1) {
     spMc = attachJORMContext(8);
diff --git a/libs/JSystem/include/JSystem/JAHostIO/JAHVirtualNode.h b/libs/JSystem/include/JSystem/JAHostIO/JAHVirtualNode.h
index eee0ed94c0..535c01f881 100644
--- a/libs/JSystem/include/JSystem/JAHostIO/JAHVirtualNode.h
+++ b/libs/JSystem/include/JSystem/JAHostIO/JAHVirtualNode.h
@@ -29,7 +29,7 @@ public:
     JSUTree<JAHVirtualNode>* getVirTree() { return &mTree; }
     static u32 getVirNodeNum() { return smVirNodeNum; }
 
-    static u32 smVirNodeNum;
+    static DUSK_GAME_DATA u32 smVirNodeNum;
 
     /* 0x04 */ JSUTree<JAHVirtualNode> mTree;
     /* 0x20 */ char mName[32];
diff --git a/libs/JSystem/include/JSystem/JAHostIO/JAHioMessage.h b/libs/JSystem/include/JSystem/JAHostIO/JAHioMessage.h
index 5a323dacd0..1b27be95b4 100644
--- a/libs/JSystem/include/JSystem/JAHostIO/JAHioMessage.h
+++ b/libs/JSystem/include/JSystem/JAHostIO/JAHioMessage.h
@@ -38,17 +38,17 @@ public:
     static u32 getIntervalX() { return smIntX; }
     static u32 getNameWidth() { return smNameWidth; }
 
-    static u16 smButtonWidth[];
-    static u16 smCommentWidth[];
-    static u16 smComboWidth[];
-    static u16 smYTop;
-    static u16 smXLeft;
-    static u16 smIndentSize;
-    static u16 smLineHeight;
-    static u16 smContWidth;
-    static u16 smIntX;
-    static u16 smIntY;
-    static u16 smNameWidth;
+    static DUSK_GAME_DATA u16 smButtonWidth[];
+    static DUSK_GAME_DATA u16 smCommentWidth[];
+    static DUSK_GAME_DATA u16 smComboWidth[];
+    static DUSK_GAME_DATA u16 smYTop;
+    static DUSK_GAME_DATA u16 smXLeft;
+    static DUSK_GAME_DATA u16 smIndentSize;
+    static DUSK_GAME_DATA u16 smLineHeight;
+    static DUSK_GAME_DATA u16 smContWidth;
+    static DUSK_GAME_DATA u16 smIntX;
+    static DUSK_GAME_DATA u16 smIntY;
+    static DUSK_GAME_DATA u16 smNameWidth;
 
     u16 getX() { return mX; }
     u16 getY() { return mY; }
diff --git a/libs/JSystem/include/JSystem/JAHostIO/JAHioNode.h b/libs/JSystem/include/JSystem/JAHostIO/JAHioNode.h
index 70fb1d07b5..d0e294a959 100644
--- a/libs/JSystem/include/JSystem/JAHostIO/JAHioNode.h
+++ b/libs/JSystem/include/JSystem/JAHostIO/JAHioNode.h
@@ -41,7 +41,7 @@ public:
 
     static JAHioNode* getCurrentNode() { return smCurrentNode; }
 
-    static JAHioNode* smCurrentNode;
+    static DUSK_GAME_DATA JAHioNode* smCurrentNode;
 
     JSUTree<JAHioNode>* getTree() { return &mTree; }
     char* getNodeName() { return mName; }
diff --git a/libs/JSystem/include/JSystem/JAHostIO/JAHioUtil.h b/libs/JSystem/include/JSystem/JAHostIO/JAHioUtil.h
index 08522c8ba1..2342f030ec 100644
--- a/libs/JSystem/include/JSystem/JAHostIO/JAHioUtil.h
+++ b/libs/JSystem/include/JSystem/JAHostIO/JAHioUtil.h
@@ -4,7 +4,7 @@
 namespace JAHioUtil {
     char* getString(const char* msg, ...);
 
-    extern char mStringBuffer[];
+    DUSK_GAME_EXTERN char mStringBuffer[];
 }
 
 #endif /* JAHIOUTIL_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAISound.h b/libs/JSystem/include/JSystem/JAudio2/JAISound.h
index e96053fc9f..fa262a7426 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAISound.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAISound.h
@@ -5,7 +5,7 @@
 #include "JSystem/JAudio2/JAIAudible.h"
 #include "JSystem/JUtility/JUTAssert.h"
 #include "global.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 #include <cstdint>
 
 class JAISound;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASAiCtrl.h b/libs/JSystem/include/JSystem/JAudio2/JASAiCtrl.h
index 5bba1b94ee..2ae0f82c0a 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASAiCtrl.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASAiCtrl.h
@@ -41,21 +41,21 @@ namespace JASDriver {
     void subframeCallback();
     void DSPSyncCallback();
 
-    extern const MixFunc sMixFuncs[4];
-    extern s16* sDmaDacBuffer[3];
-    extern JASMixMode sMixMode;
-    extern f32 sDacRate;
-    extern u32 sSubFrames;
-    extern s16** sDspDacBuffer;
-    extern s32 sDspDacWriteBuffer;
-    extern s32 sDspDacReadBuffer;
-    extern s32 sDspStatus;
-    extern DSPBufCallback sDspDacCallback;
-    extern s16* lastRspMadep;
-    extern void (*dacCallbackFunc)(s16*, u32);
-    extern MixCallback extMixCallback;
-    extern u32 sOutputRate;
-    extern u32 sSubFrameCounter;
+    DUSK_GAME_EXTERN const MixFunc sMixFuncs[4];
+    DUSK_GAME_EXTERN s16* sDmaDacBuffer[3];
+    DUSK_GAME_EXTERN JASMixMode sMixMode;
+    DUSK_GAME_EXTERN f32 sDacRate;
+    DUSK_GAME_EXTERN u32 sSubFrames;
+    DUSK_GAME_EXTERN s16** sDspDacBuffer;
+    DUSK_GAME_EXTERN s32 sDspDacWriteBuffer;
+    DUSK_GAME_EXTERN s32 sDspDacReadBuffer;
+    DUSK_GAME_EXTERN s32 sDspStatus;
+    DUSK_GAME_EXTERN DSPBufCallback sDspDacCallback;
+    DUSK_GAME_EXTERN s16* lastRspMadep;
+    DUSK_GAME_EXTERN void (*dacCallbackFunc)(s16*, u32);
+    DUSK_GAME_EXTERN MixCallback extMixCallback;
+    DUSK_GAME_EXTERN u32 sOutputRate;
+    DUSK_GAME_EXTERN u32 sSubFrameCounter;
 };
 
 #endif /* JASAICTRL_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h b/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h
index dcfcebd30a..46a30d2616 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASAramStream.h
@@ -4,7 +4,7 @@
 #include "JSystem/JAudio2/JASTaskThread.h"
 #include "JSystem/JUtility/JUTAssert.h"
 #include <dvd.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class JASChannel;
 
@@ -256,24 +256,24 @@ public:
      * Thread that will be sent DVD load commands.
      * This is the JASDvd thread in practice.
      */
-    static JASTaskThread* sLoadThread;
+    static DUSK_GAME_DATA JASTaskThread* sLoadThread;
 
     /**
      * Buffer used to read DVD data. Can store the size of an entire streamed audio block.
      */
-    static u8* sReadBuffer;
+    static DUSK_GAME_DATA u8* sReadBuffer;
 
     /**
      * Block size used by all streamed music in the game.
      * This is 0x2760 for TP.
      */
-    static u32 sBlockSize;
+    static DUSK_GAME_DATA u32 sBlockSize;
 
     /**
      * Maximum amount of output channels for all streamed music in the game.
      * This is 2 for TP (stereo).
      */
-    static u32 sChannelMax;
+    static DUSK_GAME_DATA u32 sChannelMax;
 };
 
 #endif /* JASARAMSTREAM_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASAudioThread.h b/libs/JSystem/include/JSystem/JAudio2/JASAudioThread.h
index dd9fed2183..f633d58708 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASAudioThread.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASAudioThread.h
@@ -30,7 +30,7 @@ struct JASAudioThread : public JKRThread, public JASGlobalInstance<JASAudioThrea
 	/* 0x7c */ OSThreadQueue sThreadQueue;
 	/* 0x84 */ bool sbPauseFlag;        // type unsure
 	
-    static volatile int snIntCount; // type unsure
+    static DUSK_GAME_DATA volatile int snIntCount; // type unsure
 
 };
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h b/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h
index 7d466734c0..2bf733ec69 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASBNKParser.h
@@ -137,7 +137,7 @@ namespace JASBNKParser {
         return ptr[2];
     }
 
-    extern u32 sUsedHeapSize;
+    DUSK_GAME_EXTERN u32 sUsedHeapSize;
 };
 
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASBasicWaveBank.h b/libs/JSystem/include/JSystem/JAudio2/JASBasicWaveBank.h
index 849e63dbcf..f6a10fa0c7 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASBasicWaveBank.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASBasicWaveBank.h
@@ -62,7 +62,7 @@ struct JASBasicWaveBank : public JASWaveBank {
     /* 0x24 */ u16 mHandleCount;
     /* 0x26 */ u16 mGroupCount;
 
-    static u32 mNoLoad;
+    static DUSK_GAME_DATA u32 mNoLoad;
 };
 
 #endif /* JASBASICWAVEBANK_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASCalc.h b/libs/JSystem/include/JSystem/JAudio2/JASCalc.h
index 19560be367..0dde666d33 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASCalc.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASCalc.h
@@ -2,6 +2,7 @@
 #define JASCALC_H
 
 #include <types.h>
+#include <cstring>
 #include <limits>
 
 /**
@@ -10,16 +11,31 @@
  */
 struct JASCalc {
     static void imixcopy(const s16*, const s16*, s16*, u32);
-    static void bcopyfast(const void* src, void* dest, u32 size);
+#if TARGET_PC
+    static void bcopyfast(const void* src, void* dest, u32 size) {
+        std::memcpy(dest, src, size);
+    }
 #if TARGET_ANDROID
-    static void _bcopy(const void* src, void* dest, u32 size);
+    static void _bcopy(const void* src, void* dest, u32 size) {
 #else
-    static void bcopy(const void* src, void* dest, u32 size);
+    static void bcopy(const void* src, void* dest, u32 size) {
 #endif
-    static void bzerofast(void* dest, u32 size);
+        std::memcpy(dest, src, size);
+    }
+    static void bzerofast(void* dest, u32 size) {
+        std::memset(dest, 0, size);
+    }
 #if TARGET_ANDROID
-    static void _bzero(void* dest, u32 size);
+    static void _bzero(void* dest, u32 size) {
 #else
+    static void bzero(void* dest, u32 size) {
+#endif
+        std::memset(dest, 0, size);
+    }
+#else
+    static void bcopyfast(const void* src, void* dest, u32 size);
+    static void bcopy(const void* src, void* dest, u32 size);
+    static void bzerofast(void* dest, u32 size);
     static void bzero(void* dest, u32 size);
 #endif
     static f32 pow2(f32);
@@ -42,7 +58,7 @@ struct JASCalc {
     f32 fake3();
 
 #if AVOID_UB
-    static const s16 CUTOFF_TO_IIR_TABLE[129][4];
+    static DUSK_GAME_DATA const s16 CUTOFF_TO_IIR_TABLE[129][4];
 #else
     static const s16 CUTOFF_TO_IIR_TABLE[128][4];
 #endif
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASChannel.h b/libs/JSystem/include/JSystem/JAudio2/JASChannel.h
index ce9b0b20de..af922638da 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASChannel.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASChannel.h
@@ -166,10 +166,10 @@ public:
         u32 field_0x104;
     };
 
-    static OSMessageQueue sBankDisposeMsgQ;
-    static OSMessage sBankDisposeMsg[16];
-    static OSMessage sBankDisposeList[16];
-    static int sBankDisposeListSize;
+    static DUSK_GAME_DATA OSMessageQueue sBankDisposeMsgQ;
+    static DUSK_GAME_DATA OSMessage sBankDisposeMsg[16];
+    static DUSK_GAME_DATA OSMessage sBankDisposeList[16];
+    static DUSK_GAME_DATA int sBankDisposeListSize;
 };
 
 #endif /* JASCHANNEL_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASCmdStack.h b/libs/JSystem/include/JSystem/JAudio2/JASCmdStack.h
index 2ad327362b..7765b6aee0 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASCmdStack.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASCmdStack.h
@@ -52,8 +52,8 @@ struct JASPortCmd : JSULink<JASPortCmd> {
     Command mFunc;
 	JASPortArgs* mArgs;
 
-    static TPortHead sCommandListOnce;
-    static TPortHead sCommandListStay;
+    static DUSK_GAME_DATA TPortHead sCommandListOnce;
+    static DUSK_GAME_DATA TPortHead sCommandListStay;
 };
 
 #endif /* JASCMDSTACK_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h b/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h
index 8204ab0838..f2ee2c3e49 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDSPChannel.h
@@ -63,7 +63,7 @@ struct JASDSPChannel {
     static u32 getNumFree();
     static u32 getNumBreak();
 
-    static JASDSPChannel* sDspChannels;
+    static DUSK_GAME_DATA JASDSPChannel* sDspChannels;
 
     /* 0x00 */ s32 mStatus;
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h b/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h
index a9a9b2d11e..b413052da7 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDSPInterface.h
@@ -196,15 +196,15 @@ namespace JASDsp {
     int setFXLine(u8, s16*, JASDsp::FxlineConfig_*);
     BOOL changeFXLineParam(u8, u8, uintptr_t);
 
-    extern u8 const DSPADPCM_FILTER[64];
-    extern u32 const DSPRES_FILTER[320];
-    extern u16 SEND_TABLE[];
-    extern TChannel* CH_BUF;
-    extern FxBuf* FX_BUF;
-    extern f32 sDSPVolume;
+    DUSK_GAME_EXTERN u8 const DSPADPCM_FILTER[64];
+    DUSK_GAME_EXTERN u32 const DSPRES_FILTER[320];
+    DUSK_GAME_EXTERN u16 SEND_TABLE[];
+    DUSK_GAME_EXTERN TChannel* CH_BUF;
+    DUSK_GAME_EXTERN FxBuf* FX_BUF;
+    DUSK_GAME_EXTERN f32 sDSPVolume;
 
     #if DEBUG
-    extern s32 dspMutex;
+    DUSK_GAME_EXTERN s32 dspMutex;
     #endif
 };
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h b/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h
index 5cddc38596..6401c0783a 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDriverIF.h
@@ -24,11 +24,11 @@ namespace JASDriver {
     void DSPSyncCallback();
     void updateDacCallback();
 
-    extern JASCallbackMgr sDspSyncCallback;
-    extern JASCallbackMgr sSubFrameCallback;
-    extern JASCallbackMgr sUpdateDacCallback;
-    extern u16 MAX_MIXERLEVEL;
-    extern u32 JAS_SYSTEM_OUTPUT_MODE;
+    DUSK_GAME_EXTERN JASCallbackMgr sDspSyncCallback;
+    DUSK_GAME_EXTERN JASCallbackMgr sSubFrameCallback;
+    DUSK_GAME_EXTERN JASCallbackMgr sUpdateDacCallback;
+    DUSK_GAME_EXTERN u16 MAX_MIXERLEVEL;
+    DUSK_GAME_EXTERN u32 JAS_SYSTEM_OUTPUT_MODE;
 };
 
 inline void JAISetOutputMode(u32 mode) {
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASDvdThread.h b/libs/JSystem/include/JSystem/JAudio2/JASDvdThread.h
index 553dffb7ca..c238413f8d 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASDvdThread.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASDvdThread.h
@@ -14,7 +14,7 @@ public:
     static JASTaskThread* getThreadPointer();
     static bool createThread(s32 priority, int msgCount, u32 stackSize);
 
-    static JASTaskThread* sThread;
+    static DUSK_GAME_DATA JASTaskThread* sThread;
 };
 
 #endif /* JASDVDTHREAD_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASHeapCtrl.h b/libs/JSystem/include/JSystem/JAudio2/JASHeapCtrl.h
index 996fef6fef..353e0c4315 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASHeapCtrl.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASHeapCtrl.h
@@ -273,10 +273,10 @@ namespace JASKernel {
     u32 getAramFreeSize();
     u32 getAramSize();
 
-    extern JASHeap audioAramHeap;
-    extern uintptr_t sAramBase;
-    extern JKRHeap* sSystemHeap;
-    extern JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable>* sCommandHeap;
+    DUSK_GAME_EXTERN JASHeap audioAramHeap;
+    DUSK_GAME_EXTERN uintptr_t sAramBase;
+    DUSK_GAME_EXTERN JKRHeap* sSystemHeap;
+    DUSK_GAME_EXTERN JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable>* sCommandHeap;
 };
 
 /**
@@ -452,6 +452,6 @@ private:
 template <typename T> JASMemPool_MultiThreaded<T> JASPoolAllocObject_MultiThreaded<T>::memPool_;
 #endif
 
-extern JKRSolidHeap* JASDram;
+DUSK_GAME_EXTERN JKRSolidHeap* JASDram;
 
 #endif /* JASHEAPCTRL_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASLfo.h b/libs/JSystem/include/JSystem/JAudio2/JASLfo.h
index adc27a8325..5177a40f97 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASLfo.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASLfo.h
@@ -19,7 +19,7 @@ struct JASLfo {
 
     static void updateFreeRun(f32 param_0) { sFreeRunLfo.incCounter(param_0); }
 
-    static JASLfo sFreeRunLfo;
+    static DUSK_GAME_DATA JASLfo sFreeRunLfo;
 
     /* 0x00 */ u32 field_0x0;
     /* 0x04 */ u32 field_0x4;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h b/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h
index e811e890ab..8ac20ce1ca 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASOscillator.h
@@ -2,7 +2,7 @@
 #define JASOSCILLATOR_H
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-jaudio
@@ -92,10 +92,10 @@ struct JASOscillator {
 	/* 0x1A */ u16 _1A;
 	/* 0x1C */ int _1C;
 
-    static const f32 sCurveTableLinear[17];
-    static const f32 sCurveTableSampleCell[17];
-	static const f32 sCurveTableSqRoot[17];
-	static const f32 sCurveTableSquare[17];
+    static DUSK_GAME_DATA const f32 sCurveTableLinear[17];
+    static DUSK_GAME_DATA const f32 sCurveTableSampleCell[17];
+	static DUSK_GAME_DATA const f32 sCurveTableSqRoot[17];
+	static DUSK_GAME_DATA const f32 sCurveTableSquare[17];
 };
 
 #endif /* JASOSCILLATOR_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASProbe.h b/libs/JSystem/include/JSystem/JAudio2/JASProbe.h
index 03337adce7..1aacf96b4a 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASProbe.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASProbe.h
@@ -13,7 +13,7 @@ struct JASProbe {
     void stop();
     static void stop(s32);
 
-    static JASProbe* sProbeTable[16];
+    static DUSK_GAME_DATA JASProbe* sProbeTable[16];
 
     /* 0x000 */ char const* mName;
 	/* 0x004 */ s32 mStartTime;
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASSeqCtrl.h b/libs/JSystem/include/JSystem/JAudio2/JASSeqCtrl.h
index d481192d6f..ce184e400d 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASSeqCtrl.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASSeqCtrl.h
@@ -73,7 +73,7 @@ public:
     /* 0x52 */ u16 field_0x52;
     /* 0x54 */ u32 field_0x54;
     /* 0x58 */ u32 field_0x58;
-    static JASSeqParser sDefaultParser;
+    static DUSK_GAME_DATA JASSeqParser sDefaultParser;
 };
 
 #endif /* JASSEQCTRL_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h b/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h
index 51db04ba26..8040e07228 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASSeqParser.h
@@ -92,9 +92,9 @@ public:
 
     static void registerSeqCallback(u16 (*param_0)(JASTrack*, u16)) { sCallBackFunc = param_0; }
 
-    static CmdInfo sCmdInfo[96];
-    static CmdInfo sExtCmdInfo[255];
-    static u16 (*sCallBackFunc)(JASTrack*, u16);
+    static DUSK_GAME_DATA CmdInfo sCmdInfo[96];
+    static DUSK_GAME_DATA CmdInfo sExtCmdInfo[255];
+    static DUSK_GAME_DATA u16 (*sCallBackFunc)(JASTrack*, u16);
 };
 
 #endif /* JASSEQPARSER_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASTrack.h b/libs/JSystem/include/JSystem/JAudio2/JASTrack.h
index b54a98aa77..eb8010be52 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASTrack.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASTrack.h
@@ -14,7 +14,7 @@ struct JASSoundParams;
 namespace JASDsp {
     struct TChannel;
 
-    extern const u32 FILTER_MODE_IIR;
+    DUSK_GAME_EXTERN const u32 FILTER_MODE_IIR;
 };
 
 #if !BIT_64
@@ -136,12 +136,12 @@ struct JASTrack : public JASPoolAllocObject_MultiThreaded<JASTrack> {
 
     static void channelUpdateCallback(u32, JASChannel*, JASDsp::TChannel*, void*);
 
-    static JASOscillator::Point const sAdsTable[4];
-    static JASOscillator::Data const sEnvOsc;
-    static JASOscillator::Data const sPitchEnvOsc;
+    static DUSK_GAME_DATA JASOscillator::Point const sAdsTable[4];
+    static DUSK_GAME_DATA JASOscillator::Data const sEnvOsc;
+    static DUSK_GAME_DATA JASOscillator::Data const sPitchEnvOsc;
 
-    static JASDefaultBankTable sDefaultBankTable;
-    static TList sTrackList;
+    static DUSK_GAME_DATA JASDefaultBankTable sDefaultBankTable;
+    static DUSK_GAME_DATA TList sTrackList;
 
     static const int MAX_CHILDREN = 16;
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASVoiceBank.h b/libs/JSystem/include/JSystem/JAudio2/JASVoiceBank.h
index f54273e962..ee40ea1074 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASVoiceBank.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASVoiceBank.h
@@ -14,8 +14,8 @@ public:
     virtual ~JASVoiceBank();
     virtual u32 getType() const;
 
-    static const JASOscillator::Data sOscData;
-    static JASOscillator::Data* sOscTable;
+    static DUSK_GAME_DATA const JASOscillator::Data sOscData;
+    static DUSK_GAME_DATA JASOscillator::Data* sOscTable;
 };
 
 #endif /* JASVOICEBANK_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h b/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h
index 68d91006ba..9fe201308c 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASWSParser.h
@@ -89,7 +89,7 @@ public:
     static JASBasicWaveBank* createBasicWaveBank(void const*, JKRHeap*);
     static JASSimpleWaveBank* createSimpleWaveBank(void const*, JKRHeap*);
 
-    static u32 sUsedHeapSize;
+    static DUSK_GAME_DATA u32 sUsedHeapSize;
 };
 
 #endif /* JASWSPARSER_H */
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASWaveArcLoader.h b/libs/JSystem/include/JSystem/JAudio2/JASWaveArcLoader.h
index eea3eddac3..0ad4e044c8 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASWaveArcLoader.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASWaveArcLoader.h
@@ -28,8 +28,8 @@ struct JASWaveArcLoader {
     static void setCurrentDir(char const*);
     static char* getCurrentDir();
 
-    static char sCurrentDir[DIR_MAX];
-    static JASHeap* sAramHeap;
+    static DUSK_GAME_DATA char sCurrentDir[DIR_MAX];
+    static DUSK_GAME_DATA JASHeap* sAramHeap;
 };
 
 /**
diff --git a/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h b/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h
index cac518836e..04bd541204 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JASWaveInfo.h
@@ -33,7 +33,7 @@ struct JASWaveInfo {
     /* 0x1E */ s16 mpPenult;
     /* 0x20 */ const u32* field_0x20;
 
-    static u32 one;
+    static DUSK_GAME_DATA u32 one;
 };
 
 /**
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUAudibleParam.h b/libs/JSystem/include/JSystem/JAudio2/JAUAudibleParam.h
index 44d4137d9b..cc5653fe25 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUAudibleParam.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUAudibleParam.h
@@ -2,7 +2,7 @@
 #define JAUAUDIBLEPARAM_H
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-jaudio
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUAudioArcInterpreter.h b/libs/JSystem/include/JSystem/JAudio2/JAUAudioArcInterpreter.h
index c36ad44b22..33a31adb9f 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUAudioArcInterpreter.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUAudioArcInterpreter.h
@@ -2,7 +2,7 @@
 #define JAUAUDIOARCINTERPRETER_H
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-jaudio
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUSoundAnimator.h b/libs/JSystem/include/JSystem/JAudio2/JAUSoundAnimator.h
index e81cd70ee4..f590815af5 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUSoundAnimator.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUSoundAnimator.h
@@ -2,7 +2,7 @@
 #define JAUSOUNDANIMATOR_H
 
 #include "JSystem/JAudio2/JAISound.h"
-#include "dusk/offset_ptr.h"
+#include "helpers/offset_ptr.h"
 
 class JAUSoundAnimation;
 
diff --git a/libs/JSystem/include/JSystem/JAudio2/JAUSoundTable.h b/libs/JSystem/include/JSystem/JAudio2/JAUSoundTable.h
index 4cc48f2a0b..fbd3427649 100644
--- a/libs/JSystem/include/JSystem/JAudio2/JAUSoundTable.h
+++ b/libs/JSystem/include/JSystem/JAudio2/JAUSoundTable.h
@@ -3,7 +3,7 @@
 
 #include "JSystem/JAudio2/JAISound.h"
 #include "JSystem/JAudio2/JASGadget.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-jaudio
diff --git a/libs/JSystem/include/JSystem/JFramework/JFWDisplay.h b/libs/JSystem/include/JSystem/JFramework/JFWDisplay.h
index 28967cc0a2..c9fc602b29 100644
--- a/libs/JSystem/include/JSystem/JFramework/JFWDisplay.h
+++ b/libs/JSystem/include/JSystem/JFramework/JFWDisplay.h
@@ -27,7 +27,7 @@ public:
     OSThread* getThread() const { return mThread; }
     void setThread(OSThread* thread) { mThread = thread; }
 
-    static JSUList<JFWAlarm> sList;
+    static DUSK_GAME_DATA JSUList<JFWAlarm> sList;
 
 public:
     /* 0x28 */ OSThread* mThread;
@@ -108,7 +108,7 @@ public:
     int getEfbHeight() const { return JUTVideo::getManager()->getEfbHeight(); }
     JUTXfb* getXfbManager() const { return mXfbManager; }
 
-    static JFWDisplay* sManager;
+    static DUSK_GAME_DATA JFWDisplay* sManager;
 
 private:
     /* 0x04 */ JUTFader* mFader;
diff --git a/libs/JSystem/include/JSystem/JFramework/JFWSystem.h b/libs/JSystem/include/JSystem/JFramework/JFWSystem.h
index 288b5f03d8..c8d3940331 100644
--- a/libs/JSystem/include/JSystem/JFramework/JFWSystem.h
+++ b/libs/JSystem/include/JSystem/JFramework/JFWSystem.h
@@ -18,17 +18,17 @@ struct ResFONT;
  */
 struct JFWSystem {
     struct CSetUpParam {
-        static s32 maxStdHeaps;
-        static u32 sysHeapSize;
-        static u32 fifoBufSize;
-        static u32 aramAudioBufSize;
-        static u32 aramGraphBufSize;
-        static s32 streamPriority;
-        static s32 decompPriority;
-        static s32 aPiecePriority;
-        static ResFONT* systemFontRes;
-        static const GXRenderModeObj* renderMode;
-        static u32 exConsoleBufferSize;
+        static DUSK_GAME_DATA s32 maxStdHeaps;
+        static DUSK_GAME_DATA u32 sysHeapSize;
+        static DUSK_GAME_DATA u32 fifoBufSize;
+        static DUSK_GAME_DATA u32 aramAudioBufSize;
+        static DUSK_GAME_DATA u32 aramGraphBufSize;
+        static DUSK_GAME_DATA s32 streamPriority;
+        static DUSK_GAME_DATA s32 decompPriority;
+        static DUSK_GAME_DATA s32 aPiecePriority;
+        static DUSK_GAME_DATA ResFONT* systemFontRes;
+        static DUSK_GAME_DATA const GXRenderModeObj* renderMode;
+        static DUSK_GAME_DATA u32 exConsoleBufferSize;
     };
 
     static void firstInit();
@@ -67,14 +67,14 @@ struct JFWSystem {
         CSetUpParam::renderMode = p_modeObj;
     }
 
-    static JKRExpHeap* rootHeap;
-    static JKRExpHeap* systemHeap;
-    static JKRThread* mainThread;
-    static JUTDbPrint* debugPrint;
-    static JUTResFont* systemFont;
-    static JUTConsoleManager* systemConsoleManager;
-    static JUTConsole* systemConsole;
-    static bool sInitCalled;
+    static DUSK_GAME_DATA JKRExpHeap* rootHeap;
+    static DUSK_GAME_DATA JKRExpHeap* systemHeap;
+    static DUSK_GAME_DATA JKRThread* mainThread;
+    static DUSK_GAME_DATA JUTDbPrint* debugPrint;
+    static DUSK_GAME_DATA JUTResFont* systemFont;
+    static DUSK_GAME_DATA JUTConsoleManager* systemConsoleManager;
+    static DUSK_GAME_DATA JUTConsole* systemConsole;
+    static DUSK_GAME_DATA bool sInitCalled;
 };
 
 #endif /* JFWSYSTEM_H */
diff --git a/libs/JSystem/include/JSystem/JGadget/binary.h b/libs/JSystem/include/JSystem/JGadget/binary.h
index f93e548f88..eb0ddfb1d0 100644
--- a/libs/JSystem/include/JSystem/JGadget/binary.h
+++ b/libs/JSystem/include/JSystem/JGadget/binary.h
@@ -3,7 +3,7 @@
 
 #include "JSystem/JUtility/JUTAssert.h"
 #include "JSystem/JGadget/search.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 namespace JGadget {
 namespace binary {
diff --git a/libs/JSystem/include/JSystem/JHostIO/JHICommonMem.h b/libs/JSystem/include/JSystem/JHostIO/JHICommonMem.h
index 3d8c452c72..e5a3e11553 100644
--- a/libs/JSystem/include/JSystem/JHostIO/JHICommonMem.h
+++ b/libs/JSystem/include/JSystem/JHostIO/JHICommonMem.h
@@ -2,7 +2,7 @@
 #define JHICOMMONMEM_H
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 inline u32 JHIhtonl(u32 v) {
     return BSWAP32(v);
diff --git a/libs/JSystem/include/JSystem/JHostIO/JHIMccBuf.h b/libs/JSystem/include/JSystem/JHostIO/JHIMccBuf.h
index 7343b88376..a7b4544980 100644
--- a/libs/JSystem/include/JSystem/JHostIO/JHIMccBuf.h
+++ b/libs/JSystem/include/JSystem/JHostIO/JHIMccBuf.h
@@ -27,8 +27,8 @@ public:
     virtual void disablePort() { mPortEnabled = false; }
     virtual bool isPort() { return mPortEnabled; }
 
-    static u8* mTempBuf;
-    static u16 mRefCount;
+    static DUSK_GAME_DATA u8* mTempBuf;
+    static DUSK_GAME_DATA u16 mRefCount;
 
     /* 0x04 */ u32 mTag;
     /* 0x08 */ u16 field_0x8;
diff --git a/libs/JSystem/include/JSystem/JHostIO/JORServer.h b/libs/JSystem/include/JSystem/JHostIO/JORServer.h
index 53f3283f6c..ecb6225650 100644
--- a/libs/JSystem/include/JSystem/JHostIO/JORServer.h
+++ b/libs/JSystem/include/JSystem/JHostIO/JORServer.h
@@ -120,7 +120,7 @@ public:
     CallbackLinkList* referEventCallbackList() { return &m_eventCallbackList; }
 
     static JORServer* getInstance() { return instance; }
-    static JORServer* instance;
+    static DUSK_GAME_DATA JORServer* instance;
 
     /* 0x0000C */ JORMContext m_context;
     /* 0x10020 */ JORReflexible* mp_rootObj;
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRAram.h b/libs/JSystem/include/JSystem/JKernel/JKRAram.h
index dd3bf54f9c..c934820b13 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRAram.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRAram.h
@@ -65,13 +65,13 @@ public:
     static u32 getSZSBufferSize() { return sSZSBufferSize; }
     static void setSZSBufferSize(u32 size) { sSZSBufferSize = size; }
 
-    static OSMessageQueue sMessageQueue;
+    static DUSK_GAME_DATA OSMessageQueue sMessageQueue;
 
 private:
-    static JKRAram* sAramObject;
-    static u32 sSZSBufferSize;
-    static OSMessage sMessageBuffer[4];
-    static JSUList<JKRAMCommand> sAramCommandList;
+    static DUSK_GAME_DATA JKRAram* sAramObject;
+    static DUSK_GAME_DATA u32 sSZSBufferSize;
+    static DUSK_GAME_DATA OSMessage sMessageBuffer[4];
+    static DUSK_GAME_DATA JSUList<JKRAMCommand> sAramCommandList;
 };
 
 inline JKRAramBlock* JKRAllocFromAram(u32 size, JKRAramHeap::EAllocMode allocMode) {
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRAramHeap.h b/libs/JSystem/include/JSystem/JKernel/JKRAramHeap.h
index 0d7734f6f4..b502e21aa7 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRAramHeap.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRAramHeap.h
@@ -19,7 +19,7 @@ public:
     };
 
 public:
-    static JSUList<JKRAramBlock> sAramList;
+    static DUSK_GAME_DATA JSUList<JKRAramBlock> sAramList;
 
     JKRAramHeap(u32, u32);
     virtual ~JKRAramHeap();
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRAramPiece.h b/libs/JSystem/include/JSystem/JKernel/JKRAramPiece.h
index 51eeef27e9..f701afd08f 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRAramPiece.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRAramPiece.h
@@ -62,9 +62,9 @@ struct JKRAramCommand {
  */
 class JKRAramPiece {
 public:
-    static OSMutex mMutex;
+    static DUSK_GAME_DATA OSMutex mMutex;
     // TODO: fix type
-    static JSUList<JKRAMCommand> sAramPieceCommandList;
+    static DUSK_GAME_DATA JSUList<JKRAMCommand> sAramPieceCommandList;
 
 public:
     static JKRAMCommand* prepareCommand(int, uintptr_t, uintptr_t, u32, JKRAramBlock*,
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRAramStream.h b/libs/JSystem/include/JSystem/JKernel/JKRAramStream.h
index 47d9257229..9ea3fb4eb6 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRAramStream.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRAramStream.h
@@ -60,13 +60,13 @@ public:
     static void setTransBuffer(u8*, u32, JKRHeap*);
 
 private:
-    static JKRAramStream* sAramStreamObject;
-    static OSMessage sMessageBuffer[4];
-    static OSMessageQueue sMessageQueue;
+    static DUSK_GAME_DATA JKRAramStream* sAramStreamObject;
+    static DUSK_GAME_DATA OSMessage sMessageBuffer[4];
+    static DUSK_GAME_DATA OSMessageQueue sMessageQueue;
 
-    static u8* transBuffer;
-    static u32 transSize;
-    static JKRHeap* transHeap;
+    static DUSK_GAME_DATA u8* transBuffer;
+    static DUSK_GAME_DATA u32 transSize;
+    static DUSK_GAME_DATA JKRHeap* transHeap;
 };
 
 inline JKRAramStream* JKRCreateAramStreamManager(s32 priority) {
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRArchive.h b/libs/JSystem/include/JSystem/JKernel/JKRArchive.h
index 89f3835364..bcedc7834e 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRArchive.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRArchive.h
@@ -4,13 +4,19 @@
 #include "JSystem/JKernel/JKRCompression.h"
 #include "JSystem/JKernel/JKRFileLoader.h"
 #include "global.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
+
+#if TARGET_PC
+#include <atomic>
+#include <string>
+#include <unordered_map>
+#endif
 
 class JKRHeap;
 
 /**
  * @ingroup jsystem-jkernel
- * 
+ *
  */
 struct SArcHeader {
     /* 0x00 */ BE(u32) signature;
@@ -25,7 +31,7 @@ struct SArcHeader {
 
 /**
  * @ingroup jsystem-jkernel
- * 
+ *
  */
 struct SArcDataInfo {
     /* 0x00 */ BE(u32) num_nodes;
@@ -59,7 +65,7 @@ extern u32 sCurrentDirID__10JKRArchive;  // JKRArchive::sCurrentDirID
 
 /**
  * @ingroup jsystem-jkernel
- * 
+ *
  */
 class JKRArchive : public JKRFileLoader {
 public:
@@ -192,9 +198,7 @@ public:
     u32 countFile() const { return mArcInfoBlock->num_file_entries; }
     s32 countDirectory() const { return mArcInfoBlock->num_nodes; }
     u8 getMountMode() const { return mMountMode; }
-    bool isFileEntry(u32 param_0) const {
-        return getFileAttribute(param_0) & 1;
-    }
+    bool isFileEntry(u32 param_0) const { return getFileAttribute(param_0) & 1; }
 
 public:
     /* 0x00 */  // vtable
@@ -210,7 +214,36 @@ public:
     /* 0x54 */ const char* mStringTable;
 
 #if TARGET_PC
+    u32 getFileSize(SDIFileEntry* entry) const;
+    void* getOverlayData(SDIFileEntry* entry, u32* outSize);
+    bool getOverlayFileSize(SDIFileEntry* entry, u32* outSize) const;
+    static void notifyOverlayFilesChanged();
+
+protected:
     void** mFileData;
+
+    struct ArcOverlayResource {
+        u32 entryIndex;
+        u32 size;
+        u64 generation;
+    };
+
+    // Resource pointers remain valid until removed through the JKR resource APIs.
+    // That way, any pointers to old overlay data remain valid even when the overlay changed.
+    std::unordered_map<void*, ArcOverlayResource> mArcOverlayResources;
+    mutable std::unordered_map<u32, void*> mActiveArcOverlayResources;
+    mutable std::string mArcOverlaysPath;
+    mutable std::unordered_map<u32, std::string> mIdxToPathMap;
+    mutable bool mArcOverlaysPathResolved = false;
+
+    bool buildArcOverlaysPath() const;
+    void buildIndexToPathMap(u32 dirIndex, const std::string& currentPath) const;
+    bool getOverlayPath(SDIFileEntry* entry, std::string& path) const;
+    void* getActiveOverlayData(SDIFileEntry* entry, u32* outSize) const;
+    bool copyOverlayData(void* buffer, u32 bufferSize, SDIFileEntry* entry, u32* outSize);
+    bool getOverlayResourceSize(const void* data, u32* outSize) const;
+    bool removeOverlayResource(void* resource, bool freeResource);
+    void removeAllOverlayResources();
 #endif
 
 protected:
@@ -234,7 +267,7 @@ public:
         } else if (attr & JKRARCHIVE_ATTR_YAZ0) {
             return COMPRESSION_YAZ0;
         } else {
-           return COMPRESSION_YAY0;
+            return COMPRESSION_YAY0;
         }
     }
 
@@ -242,7 +275,10 @@ public:
     static void setCurrentDirID(u32 dirID) { sCurrentDirID = dirID; }
 
 protected:
-    static u32 sCurrentDirID;
+    static DUSK_GAME_DATA u32 sCurrentDirID;
+#if TARGET_PC
+    static std::atomic<u64> sArcOverlayGeneration;
+#endif
 };
 
 inline JKRCompression JKRConvertAttrToCompressionType(int attr) {
@@ -261,8 +297,8 @@ inline bool JKRRemoveResource(void* resource, JKRFileLoader* fileLoader) {
     return JKRFileLoader::removeResource(resource, fileLoader);
 }
 
-inline JKRArchive* JKRMountArchive(void* ptr, JKRHeap* heap,
-                                   JKRArchive::EMountDirection mountDirection) {
+inline JKRArchive* JKRMountArchive(
+    void* ptr, JKRHeap* heap, JKRArchive::EMountDirection mountDirection) {
     return JKRArchive::mount(ptr, heap, mountDirection);
 }
 
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRDecomp.h b/libs/JSystem/include/JSystem/JKernel/JKRDecomp.h
index 2e7ce0ef1c..f7b4581993 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRDecomp.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRDecomp.h
@@ -61,9 +61,9 @@ public:
     static void decodeSZS(u8*, u8*, u32, u32);
     static JKRCompression checkCompressed(u8*);
 
-    static JKRDecomp* sDecompObject;
-    static OSMessage sMessageBuffer[8];
-    static OSMessageQueue sMessageQueue;
+    static DUSK_GAME_DATA JKRDecomp* sDecompObject;
+    static DUSK_GAME_DATA OSMessage sMessageBuffer[8];
+    static DUSK_GAME_DATA OSMessageQueue sMessageQueue;
 };
 
 inline void JKRDecompress(u8* srcBuffer, u8* dstBuffer, u32 srcLength, u32 dstLength) {
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRDvdAramRipper.h b/libs/JSystem/include/JSystem/JKernel/JKRDvdAramRipper.h
index 110827dc0b..20e8001e50 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRDvdAramRipper.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRDvdAramRipper.h
@@ -55,9 +55,9 @@ public:
     static bool isErrorRetry() { return errorRetry; }
 
     // TODO: fix type
-    static JSUList<JKRADCommand> sDvdAramAsyncList;
-    static u32 sSZSBufferSize;
-    static bool errorRetry;
+    static DUSK_GAME_DATA JSUList<JKRADCommand> sDvdAramAsyncList;
+    static DUSK_GAME_DATA u32 sSZSBufferSize;
+    static DUSK_GAME_DATA bool errorRetry;
 };
 
 inline JKRAramBlock *JKRDvdToAram(s32 entrynum, u32 p2, JKRExpandSwitch expSwitch, u32 p4, u32 p5, u32 *p6) {
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRDvdFile.h b/libs/JSystem/include/JSystem/JKernel/JKRDvdFile.h
index f32c8c6778..d5d439d363 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRDvdFile.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRDvdFile.h
@@ -62,7 +62,7 @@ public:
     static JSUList<JKRDvdFile>& getDvdList() { return sDvdList; }
 
 private:
-    static JSUList<JKRDvdFile> sDvdList;
+    static DUSK_GAME_DATA JSUList<JKRDvdFile> sDvdList;
 };
 
 #endif /* JKRDVDFILE_H */
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRDvdRipper.h b/libs/JSystem/include/JSystem/JKernel/JKRDvdRipper.h
index 0720605efb..aafecf063b 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRDvdRipper.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRDvdRipper.h
@@ -33,11 +33,11 @@ class JKRDvdFile;
  */
 class JKRDvdRipper {
 public:
-    static JSUList<JKRDMCommand> sDvdAsyncList;
-    static u32 sSZSBufferSize;
-    static bool errorRetry;
+    static DUSK_GAME_DATA JSUList<JKRDMCommand> sDvdAsyncList;
+    static DUSK_GAME_DATA u32 sSZSBufferSize;
+    static DUSK_GAME_DATA bool errorRetry;
 #if TARGET_PC
-    static JKRHeap* sHeap;
+    static DUSK_GAME_DATA JKRHeap* sHeap;
 #endif
 
     enum EAllocDirection {
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRFileLoader.h b/libs/JSystem/include/JSystem/JKernel/JKRFileLoader.h
index 7e3e4cd1c5..cd1483ed1f 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRFileLoader.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRFileLoader.h
@@ -53,8 +53,8 @@ public:
     static void setCurrentVolume(JKRFileLoader* fileLoader) { sCurrentVolume = fileLoader; }
     static JSUList<JKRFileLoader>& getVolumeList() { return sVolumeList; }
 
-    static JKRFileLoader* sCurrentVolume;
-    static JSUList<JKRFileLoader> sVolumeList;
+    static DUSK_GAME_DATA JKRFileLoader* sCurrentVolume;
+    static DUSK_GAME_DATA JSUList<JKRFileLoader> sVolumeList;
 };
 
 inline bool JKRDetachResource(void* resource, JKRFileLoader* fileLoader) {
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRHeap.h b/libs/JSystem/include/JSystem/JKernel/JKRHeap.h
index d1b27a0fd0..e23dca3c02 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRHeap.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRHeap.h
@@ -7,16 +7,17 @@
 #include <new>
 #include <utility>
 #include <cstdint>
+#include <type_traits>
 
 class JKRHeap;
 typedef void (*JKRErrorHandler)(void*, u32, int);
 
-extern u8 JKRValue_DEBUGFILL_NOTUSE;
-extern u8 JKRValue_DEBUGFILL_NEW;
-extern u8 JKRValue_DEBUGFILL_DELETE;
+DUSK_GAME_EXTERN u8 JKRValue_DEBUGFILL_NOTUSE;
+DUSK_GAME_EXTERN u8 JKRValue_DEBUGFILL_NEW;
+DUSK_GAME_EXTERN u8 JKRValue_DEBUGFILL_DELETE;
 
-extern s32 fillcheck_dispcount;
-extern bool data_8074A8D0_debug;
+DUSK_GAME_EXTERN s32 fillcheck_dispcount;
+DUSK_GAME_EXTERN bool data_8074A8D0_debug;
 
 #if BIT_64
 #define MEM_BLOCK_SIZE 0x20
@@ -194,26 +195,26 @@ public:
     }
     static void* getState_buf_(TState* state) { return &state->mBuf; }
 
-    static void* mCodeStart;
-    static void* mCodeEnd;
-    static void* mUserRamStart;
-    static void* mUserRamEnd;
-    static u32 mMemorySize;
-    static JKRAllocCallback sAllocCallback;
-    static JKRFreeCallback sFreeCallback;
+    static DUSK_GAME_DATA void* mCodeStart;
+    static DUSK_GAME_DATA void* mCodeEnd;
+    static DUSK_GAME_DATA void* mUserRamStart;
+    static DUSK_GAME_DATA void* mUserRamEnd;
+    static DUSK_GAME_DATA u32 mMemorySize;
+    static DUSK_GAME_DATA JKRAllocCallback sAllocCallback;
+    static DUSK_GAME_DATA JKRFreeCallback sFreeCallback;
 
-    static bool sDefaultFillFlag;
+    static DUSK_GAME_DATA bool sDefaultFillFlag;
 
-    static JKRHeap* sRootHeap;
+    static DUSK_GAME_DATA JKRHeap* sRootHeap;
 
-    static JKRHeap* sRootHeap2;
+    static DUSK_GAME_DATA JKRHeap* sRootHeap2;
 
-    static JKRHeap* sSystemHeap;
+    static DUSK_GAME_DATA JKRHeap* sSystemHeap;
 #if !TARGET_PC // Hide sCurrentHeap, we need to make it thread local.
     static JKRHeap* sCurrentHeap;
 #endif
 
-    static JKRErrorHandler mErrorHandler;
+    static DUSK_GAME_DATA JKRErrorHandler mErrorHandler;
 
 #if TARGET_PC
     void setName(const char* name);
diff --git a/libs/JSystem/include/JSystem/JKernel/JKRThread.h b/libs/JSystem/include/JSystem/JKernel/JKRThread.h
index 79217f3675..b77b40c74e 100644
--- a/libs/JSystem/include/JSystem/JKernel/JKRThread.h
+++ b/libs/JSystem/include/JSystem/JKernel/JKRThread.h
@@ -141,7 +141,7 @@ public:
     static JKRThread* searchThread(OSThread* thread);
     static JSUList<JKRThread>& getList() { return (JSUList<JKRThread>&)sThreadList; }
 
-    static JSUList<JKRThread> sThreadList;
+    static DUSK_GAME_DATA JSUList<JKRThread> sThreadList;
     // static u8 sThreadList[12];
 
 #if TARGET_PC
@@ -155,7 +155,7 @@ public:
     virtual ~JKRIdleThread() { sThread = NULL; }
     virtual void* run() { while (true); }
 
-    static void* sThread;
+    static DUSK_GAME_DATA void* sThread;
 };
 
 typedef void (*JKRThreadSwitch_PreCallback)(OSThread* current, OSThread* next);
@@ -181,11 +181,11 @@ public:
     static u32 getTotalCount() { return sTotalCount; }
 
 private:
-    static JKRThreadSwitch* sManager;
-    static u32 sTotalCount;
-    static u64 sTotalStart;
-    static JKRThreadSwitch_PreCallback mUserPreCallback;
-    static JKRThreadSwitch_PostCallback mUserPostCallback;
+    static DUSK_GAME_DATA JKRThreadSwitch* sManager;
+    static DUSK_GAME_DATA u32 sTotalCount;
+    static DUSK_GAME_DATA u64 sTotalStart;
+    static DUSK_GAME_DATA JKRThreadSwitch_PreCallback mUserPreCallback;
+    static DUSK_GAME_DATA JKRThreadSwitch_PostCallback mUserPostCallback;
 
 private:
     /* 0x00 */  // vtable
@@ -207,8 +207,8 @@ public:
 
     int check();
 
-    static JSUList<JKRTask> sTaskList;
-    static u8 sEndMesgQueue[32];
+    static DUSK_GAME_DATA JSUList<JKRTask> sTaskList;
+    static DUSK_GAME_DATA u8 sEndMesgQueue[32];
 
     /* 0x7C */ JSULink<JKRTask> mTaskLink;
     /* 0x8C */ u8 field_0x8c[0x94 - 0x8C];
diff --git a/libs/JSystem/include/JSystem/JMath/JMATrigonometric.h b/libs/JSystem/include/JSystem/JMath/JMATrigonometric.h
index e51296ba3b..520f18810d 100644
--- a/libs/JSystem/include/JSystem/JMath/JMATrigonometric.h
+++ b/libs/JSystem/include/JSystem/JMath/JMATrigonometric.h
@@ -141,9 +141,9 @@ struct TAsinAcosTable {
     }
 };
 
-extern TSinCosTable<13, f32> sincosTable_;
-extern TAtanTable<1024, f32> atanTable_;
-extern TAsinAcosTable<1024, f32> asinAcosTable_;
+DUSK_GAME_EXTERN TSinCosTable<13, f32> sincosTable_;
+DUSK_GAME_EXTERN TAtanTable<1024, f32> atanTable_;
+DUSK_GAME_EXTERN TAsinAcosTable<1024, f32> asinAcosTable_;
 
 inline f32 acosDegree(f32 x) {
     return asinAcosTable_.acosDegree(x);
diff --git a/libs/JSystem/include/JSystem/JMath/JMath.h b/libs/JSystem/include/JSystem/JMath/JMath.h
index 5d0263d669..8a7efc3f32 100644
--- a/libs/JSystem/include/JSystem/JMath/JMath.h
+++ b/libs/JSystem/include/JSystem/JMath/JMath.h
@@ -4,7 +4,7 @@
 #include <mtx.h>
 #include <cmath>
 
-#include "dusk/math.h"
+#include "helpers/math.h"
 
 typedef f32 Mtx33[3][3];
 typedef f32 Mtx23[2][3];
diff --git a/libs/JSystem/include/JSystem/JMessage/JMessage.h b/libs/JSystem/include/JSystem/JMessage/JMessage.h
index 0b3d1c64c8..7218c7f4a9 100644
--- a/libs/JSystem/include/JSystem/JMessage/JMessage.h
+++ b/libs/JSystem/include/JSystem/JMessage/JMessage.h
@@ -6,7 +6,7 @@
 #else
 #include <dolphin.h>
 #endif
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 // Struct definitions might be wrong
 typedef struct bmg_header_t {
diff --git a/libs/JSystem/include/JSystem/JMessage/data.h b/libs/JSystem/include/JSystem/JMessage/data.h
index 0f7e4fda95..bfb3303056 100644
--- a/libs/JSystem/include/JSystem/JMessage/data.h
+++ b/libs/JSystem/include/JSystem/JMessage/data.h
@@ -81,8 +81,8 @@ struct data {
     static unsigned int getTagCode(u32 tag) { return tag & 0xFFFF; }
     static u8 getTagGroup(u32 tag) { return tag >> 0x10; }
 
-    static const BE(u32) ga4cSignature;
-    static const BE(u32) ga4cSignature_color;
+    static DUSK_GAME_DATA const BE(u32) ga4cSignature;
+    static DUSK_GAME_DATA const BE(u32) ga4cSignature_color;
 
     static const int gcTagBegin = '\x1A';  // All text Control Tags will begin with this character
 
diff --git a/libs/JSystem/include/JSystem/JMessage/processor.h b/libs/JSystem/include/JSystem/JMessage/processor.h
index cfb20c2c46..efd4c3629e 100644
--- a/libs/JSystem/include/JSystem/JMessage/processor.h
+++ b/libs/JSystem/include/JSystem/JMessage/processor.h
@@ -174,10 +174,14 @@ struct TProcessor {
     }
     void on_character(int iCharacter) { do_character(iCharacter); }
 
+#if TARGET_PC
+    const char* on_message_limited(u16 u16Index) const;
+#else
     const char* on_message_limited(u16 u16Index) const {
         JUT_ASSERT(482, pResourceCache_!=NULL);
         return pResourceCache_->getMessageText_messageIndex(u16Index);
     }
+#endif
 
     bool on_setBegin_isReady_() const { return do_setBegin_isReady_(); }
 
@@ -195,6 +199,10 @@ struct TProcessor {
         return 1;
     }
 
+#if TARGET_PC
+    void* getMessageEntry_messageCode(u16 u16Code, u16 u16Index) const;
+    const char* getMessageText_messageCode(u16 u16Code, u16 u16Index) const;
+#else
     void* getMessageEntry_messageCode(u16 u16Code, u16 u16Index) const {
         const TResource* pResource = getResource_groupID(u16Code);
 
@@ -214,6 +222,7 @@ struct TProcessor {
 
         return pResourceCache_->getMessageText_messageEntry(pEntry);
     }
+#endif
 
     void stack_pushCurrent_(const char* pszText) {
         oStack_.push(getCurrent());
diff --git a/libs/JSystem/include/JSystem/JMessage/resource.h b/libs/JSystem/include/JSystem/JMessage/resource.h
index 6e4acdd6a7..cecfe9dbbb 100644
--- a/libs/JSystem/include/JSystem/JMessage/resource.h
+++ b/libs/JSystem/include/JSystem/JMessage/resource.h
@@ -144,7 +144,7 @@ struct TResourceContainer {
         destroyResource_color();
     }
 
-    static JMessage::locale::parseCharacter_function sapfnParseCharacter_[5];
+    static DUSK_GAME_DATA JMessage::locale::parseCharacter_function sapfnParseCharacter_[5];
 
     /* 0x00 */ u8 encodingType_;
     /* 0x04 */ JMessage::locale::parseCharacter_function pfnParseCharacter_;
diff --git a/libs/JSystem/include/JSystem/JParticle/JPABaseShape.h b/libs/JSystem/include/JSystem/JParticle/JPABaseShape.h
index ec15c0430a..84fc657387 100644
--- a/libs/JSystem/include/JSystem/JParticle/JPABaseShape.h
+++ b/libs/JSystem/include/JSystem/JParticle/JPABaseShape.h
@@ -63,13 +63,13 @@ public:
     JPABaseShape(u8 const*, JKRHeap*);
     void setGX(JPAEmitterWorkData*) const;
 
-    static GXBlendMode st_bm[3];
-    static GXBlendFactor st_bf[10];
-    static GXLogicOp st_lo[16];
-    static GXCompare st_c[8];
-    static GXAlphaOp st_ao[4];
-    static GXTevColorArg st_ca[6][4];
-    static GXTevAlphaArg st_aa[2][4];
+    static DUSK_GAME_DATA GXBlendMode st_bm[3];
+    static DUSK_GAME_DATA GXBlendFactor st_bf[10];
+    static DUSK_GAME_DATA GXLogicOp st_lo[16];
+    static DUSK_GAME_DATA GXCompare st_c[8];
+    static DUSK_GAME_DATA GXAlphaOp st_ao[4];
+    static DUSK_GAME_DATA GXTevColorArg st_ca[6][4];
+    static DUSK_GAME_DATA GXTevAlphaArg st_aa[2][4];
 
     GXBlendMode getBlendMode() const { return st_bm[pBsd->mBlendModeCfg & 0x03]; }
     GXBlendFactor getBlendSrc() const { return st_bf[(pBsd->mBlendModeCfg >> 2) & 0x0F]; }
diff --git a/libs/JSystem/include/JSystem/JParticle/JPADynamicsBlock.h b/libs/JSystem/include/JSystem/JParticle/JPADynamicsBlock.h
index c69ddc07cb..eb08e4ff9f 100644
--- a/libs/JSystem/include/JSystem/JParticle/JPADynamicsBlock.h
+++ b/libs/JSystem/include/JSystem/JParticle/JPADynamicsBlock.h
@@ -4,7 +4,7 @@
 #include "JSystem/JGeometry.h"
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 struct JPAEmitterWorkData;
 
diff --git a/libs/JSystem/include/JSystem/JParticle/JPAResource.h b/libs/JSystem/include/JSystem/JParticle/JPAResource.h
index 07563fa73d..ba52564b95 100644
--- a/libs/JSystem/include/JSystem/JParticle/JPAResource.h
+++ b/libs/JSystem/include/JSystem/JParticle/JPAResource.h
@@ -2,7 +2,7 @@
 #define JPARESOURCE_H
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 class JKRHeap;
 struct JPAEmitterWorkData;
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio/ctb.h b/libs/JSystem/include/JSystem/JStudio/JStudio/ctb.h
index da03389c25..f01a170bde 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio/ctb.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio/ctb.h
@@ -109,7 +109,7 @@ struct data {
         }
     };
 
-    static const u32 ga4cSignature;
+    static DUSK_GAME_DATA const u32 ga4cSignature;
 };
 
 struct TObject_TxyzRy : public TObject {
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio/fvb-data.h b/libs/JSystem/include/JSystem/JStudio/JStudio/fvb-data.h
index 8e82a0c031..e0a337a51a 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio/fvb-data.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio/fvb-data.h
@@ -10,7 +10,7 @@ namespace JStudio {
 namespace fvb {
 namespace data {
 
-extern const char ga4cSignature[4];
+DUSK_GAME_EXTERN const char ga4cSignature[4];
 
 const int PARAGRAPH_DATA = 1;
 
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-data.h b/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-data.h
index 9dc95fae97..4956d1c150 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-data.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-data.h
@@ -4,7 +4,7 @@
 
 namespace JStudio {
 namespace data {
-    extern const char ga8cSignature[8];
+    DUSK_GAME_EXTERN const char ga8cSignature[8];
 }  // namespace data
 }  // namespace JStudio
 
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-math.h b/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-math.h
index a23eed44e9..826e0948c1 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-math.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-math.h
@@ -6,7 +6,7 @@
 
 #define m_PI_D 3.141592653589793
 #ifndef __MWERKS__
-#include "dusk/math.h"
+#include "helpers/math.h"
 #endif
 
 namespace JStudio {
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-object.h b/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-object.h
index 2fe984853f..914ce66397 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-object.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio/jstudio-object.h
@@ -91,7 +91,7 @@ struct TVariableValue {
         pOutput_ = (param_1 != NULL) ? param_1 : &soOutput_none_;
     }
 
-    static TOutput_none_ soOutput_none_;
+    static DUSK_GAME_DATA TOutput_none_ soOutput_none_;
 
     /* 0x00 */ f32 mValue;
     /* 0x04 */ u32 field_0x4;
@@ -249,9 +249,9 @@ struct TAdaptor_actor : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[14];
 
-    static u32 const sauVariableValue_3_TRANSLATION_XYZ[3];
-    static u32 const sauVariableValue_3_ROTATION_XYZ[3];
-    static u32 const sauVariableValue_3_SCALING_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_TRANSLATION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_ROTATION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_SCALING_XYZ[3];
 };  // Size: 0x128
 
 struct TObject_actor : public TObject {
@@ -267,8 +267,8 @@ struct TAdaptor_ambientLight : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[4];
 
-    static u32 const sauVariableValue_3_COLOR_RGB[3];
-    static u32 const sauVariableValue_4_COLOR_RGBA[4];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_COLOR_RGB[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_4_COLOR_RGBA[4];
 };
 
 struct TObject_ambientLight : public TObject {
@@ -299,9 +299,9 @@ struct TAdaptor_camera : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[12];
 
-    static u32 const sauVariableValue_3_POSITION_XYZ[3];
-    static u32 const sauVariableValue_3_TARGET_POSITION_XYZ[3];
-    static u32 const sauVariableValue_2_DISTANCE_NEAR_FAR[2];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_POSITION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_TARGET_POSITION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_2_DISTANCE_NEAR_FAR[2];
 };
 
 struct TObject_camera : public TObject {
@@ -322,9 +322,9 @@ struct TAdaptor_fog : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[6];
 
-    static u32 const sauVariableValue_3_COLOR_RGB[3];
-    static u32 const sauVariableValue_4_COLOR_RGBA[4];
-    static u32 const sauVariableValue_2_RANGE_BEGIN_END[2];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_COLOR_RGB[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_4_COLOR_RGBA[4];
+    static DUSK_GAME_DATA u32 const sauVariableValue_2_RANGE_BEGIN_END[2];
 };
 
 struct TObject_fog : public TObject {
@@ -351,11 +351,11 @@ struct TAdaptor_light : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[13];
 
-    static u32 const sauVariableValue_3_COLOR_RGB[3];
-    static u32 const sauVariableValue_4_COLOR_RGBA[4];
-    static u32 const sauVariableValue_3_POSITION_XYZ[3];
-    static u32 const sauVariableValue_3_TARGET_POSITION_XYZ[3];
-    static u32 const sauVariableValue_2_DIRECTION_THETA_PHI[2];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_COLOR_RGB[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_4_COLOR_RGBA[4];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_POSITION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_TARGET_POSITION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_2_DIRECTION_THETA_PHI[2];
 };
 
 struct TObject_light : public TObject {
@@ -396,13 +396,13 @@ struct TAdaptor_particle : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[20];
 
-    static u32 const sauVariableValue_3_TRANSLATION_XYZ[3];
-    static u32 const sauVariableValue_3_ROTATION_XYZ[3];
-    static u32 const sauVariableValue_3_SCALING_XYZ[3];
-    static u32 const sauVariableValue_3_COLOR_RGB[3];
-    static u32 const sauVariableValue_4_COLOR_RGBA[4];
-    static u32 const sauVariableValue_3_COLOR1_RGB[3];
-    static u32 const sauVariableValue_4_COLOR1_RGBA[4];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_TRANSLATION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_ROTATION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_SCALING_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_COLOR_RGB[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_4_COLOR_RGBA[4];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_COLOR1_RGB[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_4_COLOR1_RGBA[4];
 };
 
 struct TObject_particle : public TObject {
@@ -440,7 +440,7 @@ struct TAdaptor_sound : public TAdaptor {
 
     /* 0x10 */ TVariableValue mValue[13];
 
-    static u32 const sauVariableValue_3_POSITION_XYZ[3];
+    static DUSK_GAME_DATA u32 const sauVariableValue_3_POSITION_XYZ[3];
 };  // Size: 0x114
 
 struct TObject_sound : public TObject {
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio/stb-data.h b/libs/JSystem/include/JSystem/JStudio/JStudio/stb-data.h
index b7e3cd0f7b..5da61e1575 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio/stb-data.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio/stb-data.h
@@ -21,8 +21,8 @@ const int BLOCK_NONE = -1;
 
 // Used to expand a signed 24 int to a signed 32 int
 const u32 gu32Mask_TSequence_value_signExpansion = 0xFF000000;
-extern const BE(u32) ga4cSignature;  // 'STB/0'
-extern const s32 gauDataSize_TEParagraph_data[8];
+DUSK_GAME_EXTERN const BE(u32) ga4cSignature;  // 'STB/0'
+DUSK_GAME_EXTERN const s32 gauDataSize_TEParagraph_data[8];
 
 inline void toString_block(char* a5c, u32 arg1) {
     // from debug, todo
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio_JAudio2/control.h b/libs/JSystem/include/JSystem/JStudio/JStudio_JAudio2/control.h
index effefaef18..884aeb9da5 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio_JAudio2/control.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio_JAudio2/control.h
@@ -94,7 +94,7 @@ struct TAdaptor_sound : public JStudio::TAdaptor_sound {
 
     void set_bPermit_onExit_notEnd_(bool param_1) { field_0x11c = param_1; }
 
-    static TVVOSetValue_ saoVVOSetValue_[6];
+    static DUSK_GAME_DATA TVVOSetValue_ saoVVOSetValue_[6];
 
     /* 0x114 */ TCreateObject* pCreateObject_;
     /* 0x118 */ JAISoundHandle opJAISoundHandle_;
diff --git a/libs/JSystem/include/JSystem/JStudio/JStudio_JStage/control.h b/libs/JSystem/include/JSystem/JStudio/JStudio_JStage/control.h
index 1e8331206b..050088722e 100644
--- a/libs/JSystem/include/JSystem/JStudio/JStudio_JStage/control.h
+++ b/libs/JSystem/include/JSystem/JStudio/JStudio_JStage/control.h
@@ -131,8 +131,8 @@ struct TAdaptor_actor : public JStudio::TAdaptor_actor, public JStudio_JStage::T
 
     JStage::TActor* get_pJSG_() { return (JStage::TActor*) pJSGObject_; }
 
-    static const TVVOutputObject saoVVOutput_[];
-    static const TVVOutput_ANIMATION_FRAME_  saoVVOutput_ANIMATION_FRAME_[];
+    static DUSK_GAME_DATA const TVVOutputObject saoVVOutput_[];
+    static DUSK_GAME_DATA const TVVOutput_ANIMATION_FRAME_  saoVVOutput_ANIMATION_FRAME_[];
 
     /* 0x130 */ u32 field_0x130;
     /* 0x134 */ u32 field_0x134;
@@ -187,7 +187,7 @@ struct TAdaptor_camera : public JStudio::TAdaptor_camera, public TAdaptor_object
 
     JStage::TCamera* get_pJSG_() { return (JStage::TCamera*)pJSGObject_; }
 
-    static TVVOutput saoVVOutput_[];
+    static DUSK_GAME_DATA TVVOutput saoVVOutput_[];
 
     /* 0x108 */ int field_0x108;
     /* 0x10C */ JStage::TObject* field_0x10c;
@@ -211,7 +211,7 @@ struct TAdaptor_fog : public JStudio::TAdaptor_fog, public TAdaptor_object_ {
 
     JStage::TFog* get_pJSG_() { return (JStage::TFog*)pJSGObject_; }
 
-    static TVariableValueOutput_object_<TAdaptor_fog, JStage::TFog> saoVVOutput_[];
+    static DUSK_GAME_DATA TVariableValueOutput_object_<TAdaptor_fog, JStage::TFog> saoVVOutput_[];
 };
 
 template<class TAdaptor, class TStageObject>
@@ -285,7 +285,7 @@ struct TAdaptor_light : public JStudio::TAdaptor_light, public TAdaptor_object_
 
     int field_0x11c;
 
-    static TVVOutput_direction_ saoVVOutput_direction_[6];
+    static DUSK_GAME_DATA TVVOutput_direction_ saoVVOutput_direction_[6];
 };
 
 bool
diff --git a/libs/JSystem/include/JSystem/JSupport/JSUInputStream.h b/libs/JSystem/include/JSystem/JSupport/JSUInputStream.h
index 77c27d0530..07d5a29b69 100644
--- a/libs/JSystem/include/JSystem/JSupport/JSUInputStream.h
+++ b/libs/JSystem/include/JSystem/JSupport/JSUInputStream.h
@@ -2,7 +2,7 @@
 #define JSUINPUTSTREAM_H
 
 #include "JSystem/JSupport/JSUIosBase.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
  * @ingroup jsystem-jsupport
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTCacheFont.h b/libs/JSystem/include/JSystem/JUtility/JUTCacheFont.h
index 2e089b7cc4..dabb561aa1 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTCacheFont.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTCacheFont.h
@@ -55,12 +55,16 @@ public:
     void prepend(JUTCacheFont::TGlyphCacheInfo*);
 
     virtual ~JUTCacheFont();
+#if TARGET_PC
+    virtual void loadImage(int, GXTexMapID FONT_DRAW_CTX);
+#else
     virtual void loadImage(int, GXTexMapID);
+#endif
     virtual void setBlock();
 
     void setPagingType(EPagingType type) { mPagingType = type; }
 
-    static u32 calcCacheSize(u32 param_0, int param_1) { return (ALIGN_NEXT(param_0, 0x20) + 0x40) * param_1; }
+    static u32 calcCacheSize(u32 param_0, int param_1) { return (ALIGN_NEXT(param_0, 0x20) + sizeof(TCachePage)) * param_1; }
     TGXTexObj* getTexObj(void* buffer) const { return &((TCachePage*)buffer)->mTexObj; }
     void delete_and_initialize() { deleteMemBlocks_CacheFont(); initialize_state(); }
 
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTConsole.h b/libs/JSystem/include/JSystem/JUtility/JUTConsole.h
index 0f95feb2a1..1bc56f0d6d 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTConsole.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTConsole.h
@@ -152,7 +152,7 @@ public:
 
     static JUTConsoleManager* const getManager() { return sManager; }
 
-    static JUTConsoleManager* sManager;
+    static DUSK_GAME_DATA JUTConsoleManager* sManager;
 
 #ifdef __MWERKS__
     typedef JGadget::TLinkList<JUTConsole, -offsetof(JUTConsole, mListNode)> ConsoleList;
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTDbPrint.h b/libs/JSystem/include/JSystem/JUtility/JUTDbPrint.h
index 14714df16e..67c7f8e89c 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTDbPrint.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTDbPrint.h
@@ -40,7 +40,7 @@ public:
 
     void setCharColor(JUtility::TColor color) { mColor = color; };
 
-    static JUTDbPrint* sDebugPrint;
+    static DUSK_GAME_DATA JUTDbPrint* sDebugPrint;
 
 private:
     /* 0x00 */ unk_print* mFirst;
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTDirectPrint.h b/libs/JSystem/include/JSystem/JUtility/JUTDirectPrint.h
index 14ed2c28b8..a1dd45efe2 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTDirectPrint.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTDirectPrint.h
@@ -33,10 +33,10 @@ public:
     static JUTDirectPrint* getManager() { return sDirectPrint; }
 
 private:
-    static u8 sAsciiTable[128];
-    static u32 sFontData[64];
-    static u32 sFontData2[77];
-    static JUTDirectPrint* sDirectPrint;
+    static DUSK_GAME_DATA u8 sAsciiTable[128];
+    static DUSK_GAME_DATA u32 sFontData[64];
+    static DUSK_GAME_DATA u32 sFontData2[77];
+    static DUSK_GAME_DATA JUTDirectPrint* sDirectPrint;
     static u8 sDirectPrint_padding[4 /* padding */];
 
 private:
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTException.h b/libs/JSystem/include/JSystem/JUtility/JUTException.h
index 698a02ed44..b4504e68c0 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTException.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTException.h
@@ -117,18 +117,18 @@ public:
     }
 
 private:
-    static OSMessageQueue sMessageQueue;
-    static const char* sCpuExpName[17];
-    static JSUList<JUTException::JUTExMapFile> sMapFileList;
-    static OSMessage sMessageBuffer[1];
-    static JUTException* sErrorManager;
-    static JUTExceptionUserCallback sPreUserCallback;
-    static JUTExceptionUserCallback sPostUserCallback;
-    static void* sConsoleBuffer;
-    static u32 sConsoleBufferSize;
-    static JUTConsole* sConsole;
-    static u32 msr;
-    static u32 fpscr;
+    static DUSK_GAME_DATA OSMessageQueue sMessageQueue;
+    static DUSK_GAME_DATA const char* sCpuExpName[17];
+    static DUSK_GAME_DATA JSUList<JUTException::JUTExMapFile> sMapFileList;
+    static DUSK_GAME_DATA OSMessage sMessageBuffer[1];
+    static DUSK_GAME_DATA JUTException* sErrorManager;
+    static DUSK_GAME_DATA JUTExceptionUserCallback sPreUserCallback;
+    static DUSK_GAME_DATA JUTExceptionUserCallback sPostUserCallback;
+    static DUSK_GAME_DATA void* sConsoleBuffer;
+    static DUSK_GAME_DATA u32 sConsoleBufferSize;
+    static DUSK_GAME_DATA JUTConsole* sConsole;
+    static DUSK_GAME_DATA u32 msr;
+    static DUSK_GAME_DATA u32 fpscr;
 
 private:
     /* 0x7C */ JUTExternalFB* mFrameMemory;
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTFont.h b/libs/JSystem/include/JSystem/JUtility/JUTFont.h
index 3c1cd0bf1f..0b262c0ac4 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTFont.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTFont.h
@@ -3,7 +3,7 @@
 
 #include "JSystem/JUtility/TColor.h"
 #include <cstring>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 #if TARGET_PC
 struct FontDrawContext {
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTGamePad.h b/libs/JSystem/include/JSystem/JUtility/JUTGamePad.h
index 45e7227fe3..76e0780d9b 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTGamePad.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTGamePad.h
@@ -151,21 +151,21 @@ public:
     struct C3ButtonReset {
         C3ButtonReset() { mReset = false; }
 
-        static u32 sResetPattern;
-        static u32 sResetMaskPattern;
-        static callbackFn sCallback;
-        static void* sCallbackArg;
-        static OSTime sThreshold;
-        static s32 sResetOccurredPort;
-        static bool sResetOccurred;
-        static bool sResetSwitchPushing;
+        static DUSK_GAME_DATA u32 sResetPattern;
+        static DUSK_GAME_DATA u32 sResetMaskPattern;
+        static DUSK_GAME_DATA callbackFn sCallback;
+        static DUSK_GAME_DATA void* sCallbackArg;
+        static DUSK_GAME_DATA OSTime sThreshold;
+        static DUSK_GAME_DATA s32 sResetOccurredPort;
+        static DUSK_GAME_DATA bool sResetOccurred;
+        static DUSK_GAME_DATA bool sResetSwitchPushing;
 
         /* 0x0 */ bool mReset;
     };  // Size: 0x4
 
     struct CStick {
-        static f32 sPressPoint;
-        static f32 sReleasePoint;
+        static DUSK_GAME_DATA f32 sPressPoint;
+        static DUSK_GAME_DATA f32 sReleasePoint;
 
         CStick() { clear(); }
         void clear();
@@ -187,9 +187,9 @@ public:
     struct CRumble {
         CRumble(JUTGamePad* pad) { clear(pad); }
 
-        static u32 sChannelMask[4];
-        static u8 mStatus[4];
-        static u32 mEnabled;
+        static DUSK_GAME_DATA u32 sChannelMask[4];
+        static DUSK_GAME_DATA u8 mStatus[4];
+        static DUSK_GAME_DATA u32 mEnabled;
 
         enum ERumble {
             VAL_0 = 0,
@@ -237,18 +237,18 @@ public:
         mRumble.startPatternedRumble(data, rumble, length);
     }
 
-    static JSUList<JUTGamePad> mPadList;
-    static bool mListInitialized;
-    static PADStatus mPadStatus[4];
-    static CButton mPadButton[4];
-    static CStick mPadMStick[4];
-    static CStick mPadSStick[4];
-    static EStickMode sStickMode;
-    static int sClampMode;
-    static u8 mPadAssign[4];
-    static u32 sSuppressPadReset;
-    static s32 sAnalogMode;
-    static u32 sRumbleSupported;
+    static DUSK_GAME_DATA JSUList<JUTGamePad> mPadList;
+    static DUSK_GAME_DATA bool mListInitialized;
+    static DUSK_GAME_DATA PADStatus mPadStatus[4];
+    static DUSK_GAME_DATA CButton mPadButton[4];
+    static DUSK_GAME_DATA CStick mPadMStick[4];
+    static DUSK_GAME_DATA CStick mPadSStick[4];
+    static DUSK_GAME_DATA EStickMode sStickMode;
+    static DUSK_GAME_DATA int sClampMode;
+    static DUSK_GAME_DATA u8 mPadAssign[4];
+    static DUSK_GAME_DATA u32 sSuppressPadReset;
+    static DUSK_GAME_DATA s32 sAnalogMode;
+    static DUSK_GAME_DATA u32 sRumbleSupported;
 
     /* 0x18 */ CButton mButton;
     /* 0x48 */ CStick mMainStick;
@@ -273,7 +273,7 @@ public:
 * 
 */
 struct JUTGamePadLongPress {
-    static JSUList<JUTGamePadLongPress> sPatternList;
+    static DUSK_GAME_DATA JSUList<JUTGamePadLongPress> sPatternList;
     void checkCallback(int port, u32 hold_time);
 
     u32 getMaskPattern() const { return mMaskPattern; }
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTGraphFifo.h b/libs/JSystem/include/JSystem/JUtility/JUTGraphFifo.h
index 3ea6d2ec97..ababb1b83d 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTGraphFifo.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTGraphFifo.h
@@ -32,8 +32,8 @@ public:
 #endif
     }
 
-    static JUTGraphFifo* sCurrentFifo;
-    static bool mGpStatus[5];
+    static DUSK_GAME_DATA JUTGraphFifo* sCurrentFifo;
+    static DUSK_GAME_DATA bool mGpStatus[5];
 
 private:
     /* 0x04 */ GXFifoObj* mFifo;
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTNameTab.h b/libs/JSystem/include/JSystem/JUtility/JUTNameTab.h
index 6affae8ecb..6d4994d3f3 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTNameTab.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTNameTab.h
@@ -2,7 +2,7 @@
 #define JUTNAMETAB_H
 
 #include <types.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 /**
 * @ingroup jsystem-jutility
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTPalette.h b/libs/JSystem/include/JSystem/JUtility/JUTPalette.h
index 5d29005a92..8987c28f13 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTPalette.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTPalette.h
@@ -3,7 +3,7 @@
 
 #include <gx.h>
 
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 enum JUTTransparency { UNK0, UNK1 };
 
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTProcBar.h b/libs/JSystem/include/JSystem/JUtility/JUTProcBar.h
index c491641218..13f249213a 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTProcBar.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTProcBar.h
@@ -102,7 +102,7 @@ public:
 
     static JUTProcBar* getManager() { return sManager; }
 
-    static JUTProcBar* sManager;
+    static DUSK_GAME_DATA JUTProcBar* sManager;
 
 private:
     /* 0x000 */ CTime mIdle;
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTResFont.h b/libs/JSystem/include/JSystem/JUtility/JUTResFont.h
index 29d8a77b92..5e1cfa0011 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTResFont.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTResFont.h
@@ -2,7 +2,7 @@
 #define JUTRESFONT_H
 
 #include "JSystem/JUtility/JUTFont.h"
-#include "dusk/gx_helper.h"
+#include "helpers/gx_helper.h"
 
 class JKRHeap;
 
@@ -64,7 +64,7 @@ public:
     }
 
     static const int suAboutEncoding_ = 3;
-    static IsLeadByte_func const saoAboutEncoding_[suAboutEncoding_];
+    static DUSK_GAME_DATA IsLeadByte_func const saoAboutEncoding_[suAboutEncoding_];
 
     // some types uncertain, may need to be fixed
     /* 0x1C */ int mWidth;
@@ -95,7 +95,7 @@ public:
 #endif
 };
 
-extern u8 const JUTResFONT_Ascfont_fix12[];
+DUSK_GAME_EXTERN u8 const JUTResFONT_Ascfont_fix12[];
 extern u8 const JUTResFONT_Ascfont_fix16[];
 
 #endif /* JUTRESFONT_H */
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTTexture.h b/libs/JSystem/include/JSystem/JUtility/JUTTexture.h
index 6a7a8f9a0e..c4356b0bf9 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTTexture.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTTexture.h
@@ -3,8 +3,8 @@
 
 #include <gx.h>
 #include <stdint.h>
-#include "dusk/endian.h"
-#include "dusk/gx_helper.h"
+#include "helpers/endian.h"
+#include "helpers/gx_helper.h"
 
 class JUTPalette;
 
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTVideo.h b/libs/JSystem/include/JSystem/JUtility/JUTVideo.h
index dfc6fd0b6c..6e6edecd19 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTVideo.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTVideo.h
@@ -59,9 +59,9 @@ public:
 #endif
 
 private:
-    static JUTVideo* sManager;
-    static OSTick sVideoLastTick;
-    static OSTick sVideoInterval;
+    static DUSK_GAME_DATA JUTVideo* sManager;
+    static DUSK_GAME_DATA OSTick sVideoLastTick;
+    static DUSK_GAME_DATA OSTick sVideoInterval;
 
 private:
     /* 0x04 */ GXRenderModeObj* mRenderObj;
diff --git a/libs/JSystem/include/JSystem/JUtility/JUTXfb.h b/libs/JSystem/include/JSystem/JUtility/JUTXfb.h
index acc48739fc..358f559b73 100644
--- a/libs/JSystem/include/JSystem/JUtility/JUTXfb.h
+++ b/libs/JSystem/include/JSystem/JUtility/JUTXfb.h
@@ -71,7 +71,7 @@ public:
     static JUTXfb* getManager() { return sManager; }
 
 private:
-    static JUTXfb* sManager;
+    static DUSK_GAME_DATA JUTXfb* sManager;
 
 private:
     /* 0x00 */ u8* mBuffer[3];
diff --git a/libs/JSystem/include/JSystem/JUtility/TColor.h b/libs/JSystem/include/JSystem/JUtility/TColor.h
index d4a615b5b4..5ec7afa42a 100644
--- a/libs/JSystem/include/JSystem/JUtility/TColor.h
+++ b/libs/JSystem/include/JSystem/JUtility/TColor.h
@@ -2,7 +2,7 @@
 #define TCOLOR_H
 
 #include <gx.h>
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 namespace JUtility {
     
diff --git a/libs/JSystem/src/J2DGraph/J2DMaterialFactory.cpp b/libs/JSystem/src/J2DGraph/J2DMaterialFactory.cpp
index 2cede2c49a..34e33bc03d 100644
--- a/libs/JSystem/src/J2DGraph/J2DMaterialFactory.cpp
+++ b/libs/JSystem/src/J2DGraph/J2DMaterialFactory.cpp
@@ -8,7 +8,7 @@
 #include <cstring>
 #include <types.h>
 
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 
 J2DMaterialFactory::J2DMaterialFactory(J2DMaterialBlock const& param_0) {
     mMaterialNum = param_0.field_0x8;
diff --git a/libs/JSystem/src/J2DGraph/J2DPane.cpp b/libs/JSystem/src/J2DGraph/J2DPane.cpp
index 3ba9b6e85c..01ab0e5444 100644
--- a/libs/JSystem/src/J2DGraph/J2DPane.cpp
+++ b/libs/JSystem/src/J2DGraph/J2DPane.cpp
@@ -8,7 +8,7 @@
 #include "JSystem/JSupport/JSURandomInputStream.h"
 #include "JSystem/JUtility/JUTResource.h"
 #ifndef __MWERKS__
-#include "dusk/math.h"
+#include "helpers/math.h"
 #endif
 
 J2DPane::J2DPane() : mBounds(), mGlobalBounds(), mClipRect(), mPaneTree(this) {
@@ -424,7 +424,7 @@ void J2DPane::resize(f32 x, f32 y) {
     place(box);
 }
 
-JGeometry::TBox2<f32> J2DPane::static_mBounds(0, 0, 0, 0);
+DUSK_GAME_DATA JGeometry::TBox2<f32> J2DPane::static_mBounds(0, 0, 0, 0);
 
 JGeometry::TBox2<f32>& J2DPane::getBounds() {
     static_mBounds = mBounds;
diff --git a/libs/JSystem/src/J2DGraph/J2DPrint.cpp b/libs/JSystem/src/J2DGraph/J2DPrint.cpp
index 69d71aa6c5..ac6bfb7099 100644
--- a/libs/JSystem/src/J2DGraph/J2DPrint.cpp
+++ b/libs/JSystem/src/J2DGraph/J2DPrint.cpp
@@ -7,11 +7,11 @@
 #include <cstdlib>
 #include <cstring>
 
-char* J2DPrint::mStrBuff;
+DUSK_GAME_DATA char* J2DPrint::mStrBuff;
 
 static bool sStrBufInitialized;
 
-size_t J2DPrint::mStrBuffSize;
+DUSK_GAME_DATA size_t J2DPrint::mStrBuffSize;
 
 static u8 data_8045158C[4];
 
diff --git a/libs/JSystem/src/J2DGraph/J2DScreen.cpp b/libs/JSystem/src/J2DGraph/J2DScreen.cpp
index c44859046d..603ab512f7 100644
--- a/libs/JSystem/src/J2DGraph/J2DScreen.cpp
+++ b/libs/JSystem/src/J2DGraph/J2DScreen.cpp
@@ -408,7 +408,7 @@ bool J2DScreen::isUsed(ResFONT const* p_font) {
     return J2DPane::isUsed(p_font);
 }
 
-J2DDataManage* J2DScreen::mDataManage;
+DUSK_GAME_DATA J2DDataManage* J2DScreen::mDataManage;
 
 void* J2DScreen::getNameResource(char const* resName) {
     void* res = JKRGetNameResource(resName, NULL);
diff --git a/libs/JSystem/src/J2DGraph/J2DTevs.cpp b/libs/JSystem/src/J2DGraph/J2DTevs.cpp
index 33a65dd273..bda5576cee 100644
--- a/libs/JSystem/src/J2DGraph/J2DTevs.cpp
+++ b/libs/JSystem/src/J2DGraph/J2DTevs.cpp
@@ -9,7 +9,7 @@
 #ifdef __MWERKS__
 #include <cmath>
 #else
-#include <dusk/math.h>
+#include <helpers/math.h>
 #endif
 #include <gx.h>
 
@@ -117,60 +117,60 @@ static void dummyVirtual(J2DMaterial* material) {
     block->getTevSwapModeTable(0);
 }
 
-J2DTexCoordInfo const j2dDefaultTexCoordInfo[8] = {
+DUSK_GAME_DATA J2DTexCoordInfo const j2dDefaultTexCoordInfo[8] = {
     {GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY, 0}, {GX_TG_MTX2x4, GX_TG_TEX1, GX_IDENTITY, 0},
     {GX_TG_MTX2x4, GX_TG_TEX2, GX_IDENTITY, 0}, {GX_TG_MTX2x4, GX_TG_TEX3, GX_IDENTITY, 0},
     {GX_TG_MTX2x4, GX_TG_TEX4, GX_IDENTITY, 0}, {GX_TG_MTX2x4, GX_TG_TEX5, GX_IDENTITY, 0},
     {GX_TG_MTX2x4, GX_TG_TEX6, GX_IDENTITY, 0}, {GX_TG_MTX2x4, GX_TG_TEX7, GX_IDENTITY, 0},
 };
 
-J2DTexMtxInfo const j2dDefaultTexMtxInfo = {1,    1,    255,  255,  {0.5f, 0.5f,
+DUSK_GAME_DATA J2DTexMtxInfo const j2dDefaultTexMtxInfo = {1,    1,    255,  255,  {0.5f, 0.5f,
                                             0.0f}, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f};
 
-J2DIndTexMtxInfo const j2dDefaultIndTexMtxInfo = {{0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f}, 1};
+DUSK_GAME_DATA J2DIndTexMtxInfo const j2dDefaultIndTexMtxInfo = {{0.5f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f}, 1};
 
-J2DTevStageInfo const j2dDefaultTevStageInfo = {
+DUSK_GAME_DATA J2DTevStageInfo const j2dDefaultTevStageInfo = {
     4,          GX_CC_RASC,    GX_CC_ZERO, GX_CC_ZERO, GX_CC_CPREV,   GX_TEV_ADD,
     GX_TB_ZERO, GX_CS_SCALE_1, 1,          GX_TEVPREV, GX_CA_RASA,    GX_CA_ZERO,
     GX_CA_ZERO, GX_CA_APREV,   GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1,
     GX_TEVPREV};
 
-const J2DIndTevStageInfo j2dDefaultIndTevStageInfo = {
+DUSK_GAME_DATA const J2DIndTevStageInfo j2dDefaultIndTevStageInfo = {
     GX_INDTEXSTAGE0, GX_ITB_NONE, GX_ITB_NONE, GX_ITM_OFF,  GX_ITW_OFF,
     GX_ITW_OFF,      0,           0,           GX_ITBA_OFF,
 };
 
-const GXColor j2dDefaultColInfo = {255, 255, 255, 255};
+DUSK_GAME_DATA const GXColor j2dDefaultColInfo = {255, 255, 255, 255};
 
-const J2DTevOrderInfo j2dDefaultTevOrderInfoNull = {
+DUSK_GAME_DATA const J2DTevOrderInfo j2dDefaultTevOrderInfoNull = {
     GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR_NULL, 0};
 
-const J2DIndTexOrderInfo j2dDefaultIndTexOrderNull = {
+DUSK_GAME_DATA const J2DIndTexOrderInfo j2dDefaultIndTexOrderNull = {
     GX_TEXCOORD_NULL,
     GX_TEXMAP_NULL,
 };
 
-const GXColorS10 j2dDefaultTevColor = {255, 255, 255, 255};
+DUSK_GAME_DATA const GXColorS10 j2dDefaultTevColor = {255, 255, 255, 255};
 
-const J2DIndTexCoordScaleInfo j2dDefaultIndTexCoordScaleInfo = {
+DUSK_GAME_DATA const J2DIndTexCoordScaleInfo j2dDefaultIndTexCoordScaleInfo = {
     GX_ITS_1,
     GX_ITS_1,
 };
 
-const GXColor j2dDefaultTevKColor = {255, 255, 255, 255};
+DUSK_GAME_DATA const GXColor j2dDefaultTevKColor = {255, 255, 255, 255};
 
-const J2DTevSwapModeInfo j2dDefaultTevSwapMode = {GX_TEV_SWAP0, GX_TEV_SWAP0, 0, 0};
+DUSK_GAME_DATA const J2DTevSwapModeInfo j2dDefaultTevSwapMode = {GX_TEV_SWAP0, GX_TEV_SWAP0, 0, 0};
 
-const J2DTevSwapModeTableInfo j2dDefaultTevSwapModeTable = {
+DUSK_GAME_DATA const J2DTevSwapModeTableInfo j2dDefaultTevSwapModeTable = {
     GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA};
 
-const J2DBlendInfo j2dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,
+DUSK_GAME_DATA const J2DBlendInfo j2dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,
                                                  GX_LO_NOOP};
 
-const u8 j2dDefaultPEBlockDither = 0;
+DUSK_GAME_DATA const u8 j2dDefaultPEBlockDither = 0;
 
-const J2DColorChanInfo j2dDefaultColorChanInfo = {0, 3, 0, 0};
+DUSK_GAME_DATA const J2DColorChanInfo j2dDefaultColorChanInfo = {0, 3, 0, 0};
 
-const u8 j2dDefaultTevSwapTableID = 0x1B;
+DUSK_GAME_DATA const u8 j2dDefaultTevSwapTableID = 0x1B;
 
-const u16 j2dDefaultAlphaCmp = 0x00E7;
+DUSK_GAME_DATA const u16 j2dDefaultAlphaCmp = 0x00E7;
diff --git a/libs/JSystem/src/J2DGraph/J2DWindowEx.cpp b/libs/JSystem/src/J2DGraph/J2DWindowEx.cpp
index fe4c5df9e6..284d7ea220 100644
--- a/libs/JSystem/src/J2DGraph/J2DWindowEx.cpp
+++ b/libs/JSystem/src/J2DGraph/J2DWindowEx.cpp
@@ -3,7 +3,7 @@
 #include "JSystem/J2DGraph/J2DWindowEx.h"
 #include "JSystem/JUtility/JUTTexture.h"
 #include "JSystem/JSupport/JSURandomInputStream.h"
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 
 struct J2DWindowExDef {
     BE(u32) field_0x0[4];
diff --git a/libs/JSystem/src/J3DGraphAnimator/J3DJoint.cpp b/libs/JSystem/src/J3DGraphAnimator/J3DJoint.cpp
index 4091a3b7a1..a943940d84 100644
--- a/libs/JSystem/src/J3DGraphAnimator/J3DJoint.cpp
+++ b/libs/JSystem/src/J3DGraphAnimator/J3DJoint.cpp
@@ -22,9 +22,9 @@ void J3DMtxCalcJ3DSysInitMaya::init(Vec const& scale, Mtx const& mtx) {
     JMAMTXApplyScale(mtx, J3DSys::mCurrentMtx, scale.x, scale.y, scale.z);
 }
 
-J3DMtxBuffer* J3DMtxCalc::mMtxBuffer;
+DUSK_GAME_DATA J3DMtxBuffer* J3DMtxCalc::mMtxBuffer;
 
-J3DJoint* J3DMtxCalc::mJoint;
+DUSK_GAME_DATA J3DJoint* J3DMtxCalc::mJoint;
 
 void J3DMtxCalcCalcTransformBasic::calcTransform(J3DTransformInfo const& transInfo) {
     J3DJoint* joint = J3DMtxCalc::getJoint();
@@ -189,7 +189,7 @@ void J3DJoint::entryIn() {
     }
 }
 
-J3DMtxCalc* J3DJoint::mCurrentMtxCalc;
+DUSK_GAME_DATA J3DMtxCalc* J3DJoint::mCurrentMtxCalc;
 
 void J3DJoint::recursiveCalc() {
     J3DMtxCalc* prevMtxCalc = NULL;
diff --git a/libs/JSystem/src/J3DGraphAnimator/J3DModel.cpp b/libs/JSystem/src/J3DGraphAnimator/J3DModel.cpp
index 8e111428cc..dfb9050cbd 100644
--- a/libs/JSystem/src/J3DGraphAnimator/J3DModel.cpp
+++ b/libs/JSystem/src/J3DGraphAnimator/J3DModel.cpp
@@ -8,7 +8,10 @@
 #include "JSystem/J3DGraphBase/J3DShapeMtx.h"
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include "JSystem/JKernel/JKRHeap.h"
-#include "dusk/frame_interpolation.h"
+
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 #define J3D_ASSERTMSG(LINE, COND, MSG) JUT_ASSERT_MSG(LINE, (COND) != 0, MSG)
 #define J3D_WARN1(LINE, MSG, ARG1) JUT_WARN(LINE, MSG, ARG1)
@@ -26,6 +29,7 @@ void J3DModel::initialize() {
 
     MTXIdentity(mBaseTransformMtx);
     MTXIdentity(mInternalView);
+    IF_DUSK(MTXIdentity(mPresentationBase));
 
     mMtxBuffer = NULL;
     mMatPacket = NULL;
@@ -98,12 +102,32 @@ s32 J3DModel::entryModelData(J3DModelData* pModelData, u32 mdlFlags, u32 mtxNum)
 }
 
 #if TARGET_PC
-void J3DModel::interp_callback(bool isSimFrame, void* pUserWork) {
+void J3DModel::interp_callback(void* pUserWork) {
     J3DModel* i_this = static_cast<J3DModel*>(pUserWork);
-    if (!isSimFrame) {
-        i_this->calcMaterial();
-        i_this->diff();
+    i_this->calcMaterial();
+    i_this->diff();
+}
+
+void J3DModel::setAnmMtx(int jointNo, Mtx m) {
+    mMtxBuffer->setAnmMtx(jointNo, m);
+    dusk::interp::record_final_mtx(mMtxBuffer->getAnmMtx(jointNo));
+}
+
+void J3DModel::calc_presentation_base_mtx() {
+    Mtx identity;
+    MTXIdentity(identity);
+    J3DCalcViewBaseMtx(identity, mBaseScale, mBaseTransformMtx, mPresentationBase);
+    dusk::interp::record_final_mtx(mPresentationBase);
+    prepare_presentation_view();
+}
+
+void J3DModel::prepare_presentation_view() {
+    Mtx replacement;
+    MtxP presentationBase = mPresentationBase;
+    if (dusk::interp::lookup_replacement(mPresentationBase, replacement)) {
+        presentationBase = replacement;
     }
+    MTXConcat(j3dSys.getViewMtx(), presentationBase, mInternalView);
 }
 #endif
 
@@ -462,11 +486,11 @@ void J3DModel::calc() {
 
 #ifdef TARGET_PC
     for (u16 i = 0; i < mModelData->getJointNum(); ++i) {
-        dusk::frame_interp::record_final_mtx(getAnmMtx(i));
+        dusk::interp::record_final_mtx(getAnmMtx(i));
     }
 
     for (u16 i = 0; i < mModelData->getWEvlpMtxNum(); ++i) {
-        dusk::frame_interp::record_final_mtx(getWeightAnmMtx(i));
+        dusk::interp::record_final_mtx(getWeightAnmMtx(i));
     }
 #endif
 }
@@ -497,8 +521,9 @@ void J3DModel::entry() {
     }
 
 #if TARGET_PC
-    if (mModelData->needsInterpCallBack())
-        dusk::frame_interp::add_interpolation_callback(&J3DModel::interp_callback, this);
+    if (mModelData->needsInterpCallBack()) {
+        dusk::interp::add_interpolation_callback(&J3DModel::interp_callback, this);
+    }
 #endif
 }
 
@@ -508,18 +533,20 @@ void J3DModel::viewCalc() {
 
     if (getModelData()->checkFlag(0x10)) {
         if (getMtxCalcMode() == 2) {
+#if TARGET_PC
+            calc_presentation_base_mtx();
+#else
             J3DCalcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx,
                                (MtxP)&mInternalView);
-#ifdef TARGET_PC
-            dusk::frame_interp::record_final_mtx(mInternalView);
 #endif
         }
     } else if (isCpuSkinningOn()) {
         if (getMtxCalcMode() == 2) {
+#if TARGET_PC
+            calc_presentation_base_mtx();
+#else
             J3DCalcViewBaseMtx(j3dSys.getViewMtx(), mBaseScale, mBaseTransformMtx,
                                (MtxP)&mInternalView);
-#ifdef TARGET_PC
-            dusk::frame_interp::record_final_mtx(mInternalView);
 #endif
         }
     } else if (checkFlag(J3DMdlFlag_SkinPosCpu)) {
@@ -541,15 +568,6 @@ void J3DModel::viewCalc() {
         DCStoreRange(getNrmMtxPtr(), mModelData->getDrawMtxNum() * sizeof(Mtx33));
     }
 
-#ifdef TARGET_PC
-    Mtx* drawMtx = getDrawMtxPtr();
-    if (drawMtx != J3DMtxBuffer::sNoUseDrawMtxPtr) {
-        for (u16 i = 0; i < mModelData->getDrawMtxNum(); ++i) {
-            dusk::frame_interp::record_final_mtx(drawMtx[i]);
-        }
-    }
-#endif
-
     prepareShapePackets();
 }
 
diff --git a/libs/JSystem/src/J3DGraphAnimator/J3DMtxBuffer.cpp b/libs/JSystem/src/J3DGraphAnimator/J3DMtxBuffer.cpp
index a1765acce4..a2c0a7f2d6 100644
--- a/libs/JSystem/src/J3DGraphAnimator/J3DMtxBuffer.cpp
+++ b/libs/JSystem/src/J3DGraphAnimator/J3DMtxBuffer.cpp
@@ -6,13 +6,13 @@
 #include "JSystem/J3DGraphLoader/J3DModelLoader.h"
 #include "JSystem/JKernel/JKRHeap.h"
 
-Mtx J3DMtxBuffer::sNoUseDrawMtx;
+DUSK_GAME_DATA Mtx J3DMtxBuffer::sNoUseDrawMtx;
 
-Mtx33 J3DMtxBuffer::sNoUseNrmMtx;
+DUSK_GAME_DATA Mtx33 J3DMtxBuffer::sNoUseNrmMtx;
 
-Mtx* J3DMtxBuffer::sNoUseDrawMtxPtr = &J3DMtxBuffer::sNoUseDrawMtx;
+DUSK_GAME_DATA Mtx* J3DMtxBuffer::sNoUseDrawMtxPtr = &J3DMtxBuffer::sNoUseDrawMtx;
 
-Mtx33* J3DMtxBuffer::sNoUseNrmMtxPtr = &J3DMtxBuffer::sNoUseNrmMtx;
+DUSK_GAME_DATA Mtx33* J3DMtxBuffer::sNoUseNrmMtxPtr = &J3DMtxBuffer::sNoUseNrmMtx;
 
 // force .sdata2 order
 static f32 dummy1() {
diff --git a/libs/JSystem/src/J3DGraphAnimator/J3DSkinDeform.cpp b/libs/JSystem/src/J3DGraphAnimator/J3DSkinDeform.cpp
index 76002c0a38..e262797a25 100644
--- a/libs/JSystem/src/J3DGraphAnimator/J3DSkinDeform.cpp
+++ b/libs/JSystem/src/J3DGraphAnimator/J3DSkinDeform.cpp
@@ -79,9 +79,9 @@ J3DSkinDeform::J3DSkinDeform() {
     mSkinNList = NULL;
 }
 
-BE(u16)* J3DSkinDeform::sWorkArea_WEvlpMixMtx[1024];
+DUSK_GAME_DATA BE(u16)* J3DSkinDeform::sWorkArea_WEvlpMixMtx[1024];
 
-BE(f32)* J3DSkinDeform::sWorkArea_WEvlpMixWeight[1024];
+DUSK_GAME_DATA BE(f32)* J3DSkinDeform::sWorkArea_WEvlpMixWeight[1024];
 
 void J3DSkinDeform::initSkinInfo(J3DModelData* pModelData) {
     J3D_ASSERT_NULLPTR(322, pModelData != NULL);
@@ -194,7 +194,7 @@ void J3DSkinDeform::initSkinInfo(J3DModelData* pModelData) {
     }
 }
 
-u16 J3DSkinDeform::sWorkArea_MtxReg[1024];
+DUSK_GAME_DATA u16 J3DSkinDeform::sWorkArea_MtxReg[1024];
 
 int J3DSkinDeform::initMtxIndexArray(J3DModelData* pModelData) {
     J3D_ASSERT_NULLPTR(507, pModelData != NULL);
diff --git a/libs/JSystem/src/J3DGraphBase/J3DDrawBuffer.cpp b/libs/JSystem/src/J3DGraphBase/J3DDrawBuffer.cpp
index c533face96..2d175ff871 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DDrawBuffer.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DDrawBuffer.cpp
@@ -8,7 +8,10 @@
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
 #include "JSystem/J3DGraphBase/J3DMaterial.h"
 #include "JSystem/JKernel/JKRHeap.h"
-#include "tracy/Tracy.hpp"
+
+#if TARGET_PC
+#include <tracy/Tracy.hpp>
+#endif
 
 void J3DDrawBuffer::calcZRatio() {
     mZRatio = (mZFar - mZNear) / (f32)mEntryTableSize;
@@ -205,17 +208,17 @@ int J3DDrawBuffer::entryImm(J3DPacket* pPacket, u16 index) {
     return 1;
 }
 
-J3DDrawBuffer::sortFunc J3DDrawBuffer::sortFuncTable[6] = {
+DUSK_GAME_DATA J3DDrawBuffer::sortFunc J3DDrawBuffer::sortFuncTable[6] = {
     &J3DDrawBuffer::entryMatSort,   &J3DDrawBuffer::entryMatAnmSort,  &J3DDrawBuffer::entryZSort,
     &J3DDrawBuffer::entryModelSort, &J3DDrawBuffer::entryInvalidSort, &J3DDrawBuffer::entryNonSort,
 };
 
-J3DDrawBuffer::drawFunc J3DDrawBuffer::drawFuncTable[2] = {
+DUSK_GAME_DATA J3DDrawBuffer::drawFunc J3DDrawBuffer::drawFuncTable[2] = {
     &J3DDrawBuffer::drawHead,
     &J3DDrawBuffer::drawTail,
 };
 
-int J3DDrawBuffer::entryNum;
+DUSK_GAME_DATA int J3DDrawBuffer::entryNum;
 
 void J3DDrawBuffer::draw() const {
     J3D_ASSERT_RANGE(411, mDrawMode < J3DDrawBufDrawMode_MAX);
diff --git a/libs/JSystem/src/J3DGraphBase/J3DGD.cpp b/libs/JSystem/src/J3DGraphBase/J3DGD.cpp
index eb89fc3b81..74e5c2c759 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DGD.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DGD.cpp
@@ -6,7 +6,10 @@
 
 #include "JSystem/J3DGraphBase/J3DGD.h"
 #include "JSystem/J3DGraphBase/J3DFifo.h"
-#include <dusk/logging.h>
+
+#if TARGET_PC
+#include "dusk/logging.h"
+#endif
 
 void J3DGDSetGenMode(u8 nTexGens, u8 nChans, u8 nTevs, u8 nInds,
                      GXCullMode cm) {
diff --git a/libs/JSystem/src/J3DGraphBase/J3DMatBlock.cpp b/libs/JSystem/src/J3DGraphBase/J3DMatBlock.cpp
index f401f16c43..dada6a19e8 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DMatBlock.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DMatBlock.cpp
@@ -246,22 +246,37 @@ s32 J3DTexGenBlockBasic::countDLSize() {
 }
 
 s32 J3DTevBlockPatched::countDLSize() {
+#if TARGET_PC
+    return 2048;
+#endif
     return 560;
 }
 
 s32 J3DTevBlock1::countDLSize() {
+#if TARGET_PC
+    return 256;
+#endif
     return 105;
 }
 
 s32 J3DTevBlock2::countDLSize() {
+#if TARGET_PC
+    return 512;
+#endif
     return 335;
 }
 
 s32 J3DTevBlock4::countDLSize() {
+#if TARGET_PC
+    return 1024;
+#endif
     return 580;
 }
 
 s32 J3DTevBlock16::countDLSize() {
+#if TARGET_PC
+    return 2048;
+#endif
     return 1000;
 }
 
diff --git a/libs/JSystem/src/J3DGraphBase/J3DMaterial.cpp b/libs/JSystem/src/J3DGraphBase/J3DMaterial.cpp
index 48d4731ed9..27043184ee 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DMaterial.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DMaterial.cpp
@@ -218,9 +218,6 @@ void J3DMaterial::makeSharedDisplayList() {
 
 void J3DMaterial::load() {
     j3dSys.setMaterialMode(mMaterialMode);
-#if TARGET_PC
-    mTevBlock->loadTexture();
-#endif
     if (!j3dSys.checkFlag(2)) {
         loadNBTScale(*mTexGenBlock->getNBTScale());
     }
@@ -228,9 +225,6 @@ void J3DMaterial::load() {
 
 void J3DMaterial::loadSharedDL() {
     j3dSys.setMaterialMode(mMaterialMode);
-#if TARGET_PC
-    mTevBlock->loadTexture();
-#endif
     if (!j3dSys.checkFlag(2)) {
         mSharedDLObj->callDL();
         loadNBTScale(*mTexGenBlock->getNBTScale());
@@ -405,9 +399,6 @@ void J3DPatchedMaterial::makeSharedDisplayList() {}
 
 void J3DPatchedMaterial::load() {
     j3dSys.setMaterialMode(mMaterialMode);
-#if TARGET_PC
-    mTevBlock->loadTexture();
-#endif
     if (j3dSys.checkFlag(2)) {
         return;
     }
@@ -415,9 +406,6 @@ void J3DPatchedMaterial::load() {
 
 void J3DPatchedMaterial::loadSharedDL() {
     j3dSys.setMaterialMode(mMaterialMode);
-#if TARGET_PC
-    mTevBlock->loadTexture();
-#endif
     if (!j3dSys.checkFlag(0x02))
         mSharedDLObj->callDL();
 }
@@ -436,9 +424,6 @@ void J3DLockedMaterial::makeSharedDisplayList() {}
 
 void J3DLockedMaterial::load() {
     j3dSys.setMaterialMode(mMaterialMode);
-#if TARGET_PC
-    mTevBlock->loadTexture();
-#endif
     if (j3dSys.checkFlag(2)) {
         return;
     }
@@ -446,9 +431,6 @@ void J3DLockedMaterial::load() {
 
 void J3DLockedMaterial::loadSharedDL() {
     j3dSys.setMaterialMode(mMaterialMode);
-#if TARGET_PC
-    mTevBlock->loadTexture();
-#endif
     if (!j3dSys.checkFlag(0x02))
         mSharedDLObj->callDL();
 }
diff --git a/libs/JSystem/src/J3DGraphBase/J3DPacket.cpp b/libs/JSystem/src/J3DGraphBase/J3DPacket.cpp
index 9e28a7f7cb..354dee4130 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DPacket.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DPacket.cpp
@@ -1,15 +1,18 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
-#include <cstring>
-#include <os.h>
+#include "JSystem/J3DGraphBase/J3DPacket.h"
 #include "JSystem/J3DGraphAnimator/J3DModel.h"
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
 #include "JSystem/J3DGraphBase/J3DMaterial.h"
-#include "JSystem/J3DGraphBase/J3DPacket.h"
 #include "JSystem/J3DGraphBase/J3DShapeMtx.h"
 #include "JSystem/JKernel/JKRHeap.h"
+#include <os.h>
+#include <cstring>
 #include "global.h"
-#include "tracy/Tracy.hpp"
+
+#if TARGET_PC
+#include <tracy/Tracy.hpp>
+#endif
 
 J3DError J3DDisplayListObj::newDisplayList(u32 maxSize) {
     mMaxSize = ALIGN_NEXT(maxSize, 0x20);
@@ -68,9 +71,9 @@ void J3DDisplayListObj::callDL() const {
     GXCallDisplayList(mpDisplayList[0], mSize);
 }
 
-GDLObj J3DDisplayListObj::sGDLObj;
+DUSK_GAME_DATA GDLObj J3DDisplayListObj::sGDLObj;
 
-s32 J3DDisplayListObj::sInterruptFlag;
+DUSK_GAME_DATA s32 J3DDisplayListObj::sInterruptFlag;
 
 void J3DDisplayListObj::beginDL() {
     swapBuffer();
@@ -209,9 +212,6 @@ bool J3DMatPacket::isSame(J3DMatPacket* pOther) const {
 
 void J3DMatPacket::draw() {
     ZoneScoped;
-#if TARGET_PC 
-    j3dSys.setTexture(mpTexture);
-#endif
     mpMaterial->load();
 
 #if DEBUG && TARGET_PC
@@ -225,9 +225,6 @@ void J3DMatPacket::draw() {
     callDL();
 
     J3DShapePacket* packet = getShapePacket();
-#if TARGET_PC
-    packet->mpModel->getVertexBuffer()->setArray();
-#endif
     packet->getShape()->loadPreDrawSetting();
 
     while (packet != NULL) {
@@ -339,6 +336,11 @@ int J3DShapePacket::newDifferedDisplayList(u32 diffFlags) {
 void J3DShapePacket::prepareDraw() const {
     mpModel->getVertexBuffer()->setArray();
     j3dSys.setModel(mpModel);
+#if TARGET_PC
+    if (mpModel->getMtxCalcMode() == 2) {
+        mpModel->prepare_presentation_view();
+    }
+#endif
     j3dSys.setShapePacket((J3DShapePacket*)this);
 
     J3DShapeMtx::setLODFlag(mpModel->checkFlag(J3DMdlFlag_EnableLOD) != 0);
diff --git a/libs/JSystem/src/J3DGraphBase/J3DShape.cpp b/libs/JSystem/src/J3DGraphBase/J3DShape.cpp
index 4b407d1e05..07ed23ed4a 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DShape.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DShape.cpp
@@ -1,15 +1,17 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
 #include "JSystem/J3DGraphBase/J3DShape.h"
-
-#include <dolphin/gd.h>
-#include <gd.h>
-#include <gx.h>
-#include "JSystem/J3DGraphBase/J3DFifo.h"
 #include "JSystem/J3DGraphBase/J3DPacket.h"
 #include "JSystem/J3DGraphBase/J3DVertex.h"
+#include "JSystem/J3DGraphBase/J3DFifo.h"
+#include <gd.h>
+
+#if TARGET_PC
 #include "JSystem/JKernel/JKRHeap.h"
-#include "tracy/Tracy.hpp"
+
+#include <dolphin/gx.h>
+#include <tracy/Tracy.hpp>
+#endif
 
 void J3DGDSetVtxAttrFmtv(GXVtxFmt, GXVtxAttrFmtList const*, bool);
 void J3DFifoLoadPosMtxImm(Mtx, u32);
@@ -289,7 +291,7 @@ void J3DShape::makeVcdVatCmd() {
     OSRestoreInterrupts(sInterruptFlag);
 }
 
-void* J3DShape::sOldVcdVatCmd;
+DUSK_GAME_DATA void* J3DShape::sOldVcdVatCmd;
 
 void J3DShape::loadCurrentMtx() const {
     mCurrentMtx.load();
@@ -304,7 +306,7 @@ void J3DShape::loadPreDrawSetting() const {
     mCurrentMtx.load();
 }
 
-bool J3DShape::sEnvelopeFlag;
+DUSK_GAME_DATA bool J3DShape::sEnvelopeFlag;
 
 void J3DShape::setArrayAndBindPipeline() const {
     J3DShapeMtx::setCurrentPipeline((mFlags & 0x1C) >> 2);
diff --git a/libs/JSystem/src/J3DGraphBase/J3DShapeMtx.cpp b/libs/JSystem/src/J3DGraphBase/J3DShapeMtx.cpp
index d9af135999..ae9021f76c 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DShapeMtx.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DShapeMtx.cpp
@@ -6,13 +6,16 @@
 #include "JSystem/J3DGraphBase/J3DMatBlock.h"
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include "JSystem/J3DGraphBase/J3DTexture.h"
-#include "dusk/frame_interpolation.h"
 
-u16 J3DShapeMtx::sMtxLoadCache[10];
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
-#ifdef TARGET_PC
+DUSK_GAME_DATA u16 J3DShapeMtx::sMtxLoadCache[10];
+
+#if TARGET_PC
 static void J3DFrameInterpConcat(MtxP lhs, MtxP rhs, Mtx out) {
-    if (!dusk::frame_interp::lookup_concat_replacement(lhs, rhs, out)) {
+    if (!dusk::interp::lookup_concat_replacement(lhs, rhs, out)) {
         MTXConcat(lhs, rhs, out);
     }
 }
@@ -54,42 +57,42 @@ void J3DShapeMtx::loadMtxIndx_PNCPU(int slot, u16 indx) const {
     J3DFifoLoadNrmMtxImm(*j3dSys.getShapePacket()->getBaseMtxPtr(), slot * 3);
 }
 
-J3DShapeMtx_LoadFunc J3DShapeMtx::sMtxLoadPipeline[4] = {
+DUSK_GAME_DATA J3DShapeMtx_LoadFunc J3DShapeMtx::sMtxLoadPipeline[4] = {
     &J3DShapeMtx::loadMtxIndx_PNGP,
     &J3DShapeMtx::loadMtxIndx_PCPU,
     &J3DShapeMtx::loadMtxIndx_NCPU,
     &J3DShapeMtx::loadMtxIndx_PNCPU,
 };
 
-J3DShapeMtxConcatView_LoadFunc J3DShapeMtxConcatView::sMtxLoadPipeline[4] = {
+DUSK_GAME_DATA J3DShapeMtxConcatView_LoadFunc J3DShapeMtxConcatView::sMtxLoadPipeline[4] = {
     &J3DShapeMtxConcatView::loadMtxConcatView_PNGP,
     &J3DShapeMtxConcatView::loadMtxConcatView_PCPU,
     &J3DShapeMtxConcatView::loadMtxConcatView_NCPU,
     &J3DShapeMtxConcatView::loadMtxConcatView_PNCPU,
 };
 
-J3DShapeMtxConcatView_LoadFunc J3DShapeMtxConcatView::sMtxLoadLODPipeline[4] = {
+DUSK_GAME_DATA J3DShapeMtxConcatView_LoadFunc J3DShapeMtxConcatView::sMtxLoadLODPipeline[4] = {
     &J3DShapeMtxConcatView::loadMtxConcatView_PNGP_LOD,
     &J3DShapeMtxConcatView::loadMtxConcatView_PCPU,
     &J3DShapeMtxConcatView::loadMtxConcatView_NCPU,
     &J3DShapeMtxConcatView::loadMtxConcatView_PNCPU,
 };
 
-u32 J3DShapeMtx::sCurrentPipeline;
+DUSK_GAME_DATA u32 J3DShapeMtx::sCurrentPipeline;
 
-u8* J3DShapeMtx::sCurrentScaleFlag;
+DUSK_GAME_DATA u8* J3DShapeMtx::sCurrentScaleFlag;
 
-bool J3DShapeMtx::sNBTFlag;
+DUSK_GAME_DATA bool J3DShapeMtx::sNBTFlag;
 
-bool J3DShapeMtx::sLODFlag;
+DUSK_GAME_DATA bool J3DShapeMtx::sLODFlag;
 
-u32 J3DShapeMtx::sTexMtxLoadType;
+DUSK_GAME_DATA u32 J3DShapeMtx::sTexMtxLoadType;
 
-MtxP J3DShapeMtxConcatView::sMtxPtrTbl[2];
+DUSK_GAME_DATA MtxP J3DShapeMtxConcatView::sMtxPtrTbl[2];
 
-J3DTexGenBlock* J3DDifferedTexMtx::sTexGenBlock;
+DUSK_GAME_DATA J3DTexGenBlock* J3DDifferedTexMtx::sTexGenBlock;
 
-J3DTexMtxObj* J3DDifferedTexMtx::sTexMtxObj;
+DUSK_GAME_DATA J3DTexMtxObj* J3DDifferedTexMtx::sTexMtxObj;
 
 void J3DDifferedTexMtx::loadExecute(f32 const (*param_0)[4]) {
     static Mtx qMtx = {
diff --git a/libs/JSystem/src/J3DGraphBase/J3DSys.cpp b/libs/JSystem/src/J3DGraphBase/J3DSys.cpp
index b4598bfa7a..0f5beb9db5 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DSys.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DSys.cpp
@@ -1,27 +1,32 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
-#include "JSystem/J3DGraphBase/J3DFifo.h"
 #include "JSystem/J3DGraphBase/J3DSys.h"
 #include "JSystem/J3DGraphBase/J3DTevs.h"
 #include "JSystem/J3DGraphBase/J3DTexture.h"
-#include "dusk/gx_helper.h"
+#include "JSystem/J3DGraphBase/J3DFifo.h"
 #include "global.h"
-#include "tracy/Tracy.hpp"
 
-J3DSys j3dSys;
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#include "helpers/gx_helper.h"
 
-Mtx J3DSys::mCurrentMtx;
+#include <tracy/Tracy.hpp>
+#endif
 
-Vec J3DSys::mCurrentS;
+DUSK_GAME_DATA J3DSys j3dSys;
 
-Vec J3DSys::mParentS;
+DUSK_GAME_DATA Mtx J3DSys::mCurrentMtx;
 
-J3DTexCoordScaleInfo J3DSys::sTexCoordScaleTable[8];
+DUSK_GAME_DATA Vec J3DSys::mCurrentS;
+
+DUSK_GAME_DATA Vec J3DSys::mParentS;
+
+DUSK_GAME_DATA J3DTexCoordScaleInfo J3DSys::sTexCoordScaleTable[8];
 
 #if TARGET_PC // Original game bug, array is too small.
-static u8 NullTexData[0x20] ATTRIBUTE_ALIGN(32) = {0};
+ATTRIBUTE_ALIGN(32) static u8 NullTexData[0x20] = {0};
 #else
-static u8 NullTexData[0x10] ATTRIBUTE_ALIGN(32) = {0};
+ATTRIBUTE_ALIGN(32) static u8 NullTexData[0x10] = {0};
 #endif
 
 static Mtx j3dIdentityMtx = {
@@ -35,7 +40,7 @@ static Mtx23 IndMtx = {
     0.0f, 0.5f, 0.0f,
 };
 
-u32 j3dDefaultViewNo;
+DUSK_GAME_DATA u32 j3dDefaultViewNo;
 
 static GXColor ColorBlack = {0x00, 0x00, 0x00, 0x00};
 
@@ -370,3 +375,13 @@ void J3DSys::reinitPixelProc() {
     GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
     GXSetZCompLoc(GX_TRUE);
 }
+
+#if TARGET_PC
+void J3DSys::setViewMtx(const Mtx m) {
+    Mtx patched;
+    if (dusk::interp::lookup_replacement(m, patched)) {
+        m = patched;
+    }
+    MTXCopy(m, mViewMtx);
+}
+#endif
diff --git a/libs/JSystem/src/J3DGraphBase/J3DTevs.cpp b/libs/JSystem/src/J3DGraphBase/J3DTevs.cpp
index 719976770b..b43663731d 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DTevs.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DTevs.cpp
@@ -11,6 +11,10 @@
 #include "JSystem/J3DGraphBase/J3DTransform.h"
 #include "global.h"
 
+#if TARGET_PC
+#include "aurora/lib/gfx/texture.hpp"
+#endif
+
 static void J3DGDLoadTexMtxImm(f32 (*)[4], u32, GXTexMtxType);
 static void J3DGDLoadPostTexMtxImm(f32 (*)[4], u32);
 
@@ -280,6 +284,46 @@ u16 getTexNoReg(void* pDL) {
     return var_r31 & 0xFFFFFF;
 }
 
+#if TARGET_PC
+inline void J3DGDWrite_u64(u64 data) {
+    __GDWrite((u8)((data >> 56) & 0xFF));
+    __GDWrite((u8)((data >> 48) & 0xFF));
+    __GDWrite((u8)((data >> 40) & 0xFF));
+    __GDWrite((u8)((data >> 32) & 0xFF));
+    __GDWrite((u8)((data >> 24) & 0xFF));
+    __GDWrite((u8)((data >> 16) & 0xFF));
+    __GDWrite((u8)((data >> 8) & 0xFF));
+    __GDWrite((u8)((data >> 0) & 0xFF));
+}
+
+void J3D_emit_loaded_texobj_metadata(const GXTexObj_& obj, GXTexMapID id) {
+    GDOverflowCheck(38);
+    J3DGDWrite_u8(GX_AURORA);
+    J3DGDWrite_u16(GX_AURORA_LOAD_TEXOBJ);
+    J3DGDWrite_u8(static_cast<u8>(id));
+    J3DGDWrite_u64(reinterpret_cast<u64>(obj.data));
+    J3DGDWrite_u32(obj.width());
+    J3DGDWrite_u32(obj.height());
+    J3DGDWrite_u32(obj.format());
+    J3DGDWrite_u32(static_cast<u32>(obj.tlut));
+    J3DGDWrite_u8(static_cast<u8>(obj.has_mips()));
+    J3DGDWrite_u32(obj.texObjId);
+    J3DGDWrite_u32(obj.texDataVersion);
+}
+
+void J3D_emit_loaded_tlut_metadata(const GXTlutObj_& obj, u32 idx) {
+    GDOverflowCheck(22);
+    J3DGDWrite_u8(GX_AURORA);
+    J3DGDWrite_u16(GX_AURORA_LOAD_TLUT);
+    J3DGDWrite_u8(static_cast<u8>(idx));
+    J3DGDWrite_u64(reinterpret_cast<u64>(obj.data));
+    J3DGDWrite_u32(static_cast<u32>(obj.format));
+    J3DGDWrite_u16(obj.numEntries);
+    J3DGDWrite_u32(obj.tlutObjId);
+    J3DGDWrite_u32(obj.tlutDataVersion);
+}
+#endif
+
 void loadTexNo(u32 param_0, const u16& texNo) {
     ResTIMG* resTIMG = j3dSys.getTexture()->getResTIMG(texNo);
     J3D_ASSERT_NULLPTR(462, resTIMG != NULL);
@@ -287,6 +331,15 @@ void loadTexNo(u32 param_0, const u16& texNo) {
     J3DSys::sTexCoordScaleTable[param_0].field_0x00 = (u16)resTIMG->width;
     J3DSys::sTexCoordScaleTable[param_0].field_0x02 = (u16)resTIMG->height;
 
+#if TARGET_PC
+    J3D_emit_loaded_texobj_metadata(
+        *reinterpret_cast<GXTexObj_*>(j3dSys.getTexture()->getTexObj(texNo)), GXTexMapID(param_0));
+    if (resTIMG->indexTexture) {
+        J3D_emit_loaded_tlut_metadata(
+            *reinterpret_cast<GXTlutObj_*>(j3dSys.getTexture()->getTlutObj(texNo)), param_0);
+    }
+#endif
+
     GDOverflowCheck(0x14);
     J3DGDSetTexImgPtr(GXTexMapID(param_0), (u8*)resTIMG + resTIMG->imageOffset);
     J3DGDSetTexImgAttr(GXTexMapID(param_0), resTIMG->width, resTIMG->height, GXTexFmt(resTIMG->format & 0x0f));
@@ -315,7 +368,7 @@ void loadNBTScale(J3DNBTScale& NBTScale) {
     }
 }
 
-const J3DLightInfo j3dDefaultLightInfo = {
+DUSK_GAME_DATA const J3DLightInfo j3dDefaultLightInfo = {
     0.0f, 0.0f, 0.0f,
     0.0f, -1.0f, 0.0f,
     0xff, 0xff, 0xff, 0xff,
@@ -323,14 +376,14 @@ const J3DLightInfo j3dDefaultLightInfo = {
     1.0f, 0.0f, 0.0f,
 };
 
-J3DTexCoordInfo const j3dDefaultTexCoordInfo[8] = {
+DUSK_GAME_DATA J3DTexCoordInfo const j3dDefaultTexCoordInfo[8] = {
     {GX_MTX2x4, GX_TG_TEX0, GX_IDENTITY, 0}, {GX_MTX2x4, GX_TG_TEX1, GX_IDENTITY, 0},
     {GX_MTX2x4, GX_TG_TEX2, GX_IDENTITY, 0}, {GX_MTX2x4, GX_TG_TEX3, GX_IDENTITY, 0},
     {GX_MTX2x4, GX_TG_TEX4, GX_IDENTITY, 0}, {GX_MTX2x4, GX_TG_TEX5, GX_IDENTITY, 0},
     {GX_MTX2x4, GX_TG_TEX6, GX_IDENTITY, 0}, {GX_MTX2x4, GX_TG_TEX7, GX_IDENTITY, 0},
 };
 
-J3DTexMtxInfo const j3dDefaultTexMtxInfo = {
+DUSK_GAME_DATA J3DTexMtxInfo const j3dDefaultTexMtxInfo = {
     0x01,
     0x00,
     0xFF,
@@ -341,27 +394,27 @@ J3DTexMtxInfo const j3dDefaultTexMtxInfo = {
      1.0f},
 };
 
-J3DIndTexMtxInfo const j3dDefaultIndTexMtxInfo = {
+DUSK_GAME_DATA J3DIndTexMtxInfo const j3dDefaultIndTexMtxInfo = {
     0.5f, 0.0f, 0.0f,
     0.0f, 0.5f, 0.0f,
     1
 };
 
-J3DTevStageInfo const j3dDefaultTevStageInfo = {
+DUSK_GAME_DATA J3DTevStageInfo const j3dDefaultTevStageInfo = {
     0x04, 0x0A, 0x0F, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
     0x05, 0x07, 0x07, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
 };
 
-J3DIndTevStageInfo const j3dDefaultIndTevStageInfo = {
+DUSK_GAME_DATA J3DIndTevStageInfo const j3dDefaultIndTevStageInfo = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-J3DFogInfo const j3dDefaultFogInfo = {
+DUSK_GAME_DATA J3DFogInfo const j3dDefaultFogInfo = {
     0x00, 0x00, 0x0140, 0.0f, 0.0f, 0.1f, 10000.0f, 0xFF, 0xFF, 0xFF, 0x00,
     0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 };
 
-J3DNBTScaleInfo const j3dDefaultNBTScaleInfo = {
+DUSK_GAME_DATA J3DNBTScaleInfo const j3dDefaultNBTScaleInfo = {
 #if TARGET_PC
     0x00, {1.0f, 1.0f, 1.0f},
 #else
@@ -399,9 +452,9 @@ void makeTexCoordTable() {
     }
 }
 
-u8 j3dTevSwapTableTable[1024];
+DUSK_GAME_DATA u8 j3dTevSwapTableTable[1024];
 
-u8 j3dAlphaCmpTable[768];
+DUSK_GAME_DATA u8 j3dAlphaCmpTable[768];
 
 void makeAlphaCmpTable() {
     u8* table = j3dAlphaCmpTable;
@@ -417,7 +470,7 @@ void makeAlphaCmpTable() {
     }
 }
 
-u8 j3dZModeTable[96];
+DUSK_GAME_DATA u8 j3dZModeTable[96];
 
 void makeZModeTable() {
     u8* table = j3dZModeTable;
@@ -495,44 +548,44 @@ static void J3DGDLoadPostTexMtxImm(f32 (*param_1)[4], u32 param_2) {
     J3DGDWrite_f32(param_1[2][3]);
 }
 
-const GXColor j3dDefaultColInfo = {0xFF, 0xFF, 0xFF, 0xFF};
+DUSK_GAME_DATA const GXColor j3dDefaultColInfo = {0xFF, 0xFF, 0xFF, 0xFF};
 
-const GXColor j3dDefaultAmbInfo = {0x32, 0x32, 0x32, 0x32};
+DUSK_GAME_DATA const GXColor j3dDefaultAmbInfo = {0x32, 0x32, 0x32, 0x32};
 
-const u8 j3dDefaultNumChans = 1;
+DUSK_GAME_DATA const u8 j3dDefaultNumChans = 1;
 
-const J3DTevOrderInfo j3dDefaultTevOrderInfoNull = {0xFF, 0xFF, 0xFF, 0x00};
+DUSK_GAME_DATA const J3DTevOrderInfo j3dDefaultTevOrderInfoNull = {0xFF, 0xFF, 0xFF, 0x00};
 
-const J3DIndTexOrderInfo j3dDefaultIndTexOrderNull = {0xFF, 0xFF, 0x00, 0x00};
+DUSK_GAME_DATA const J3DIndTexOrderInfo j3dDefaultIndTexOrderNull = {0xFF, 0xFF, 0x00, 0x00};
 
-const GXColorS10 j3dDefaultTevColor = {0xFF, 0xFF, 0xFF, 0xFF};
+DUSK_GAME_DATA const GXColorS10 j3dDefaultTevColor = {0xFF, 0xFF, 0xFF, 0xFF};
 
-const J3DIndTexCoordScaleInfo j3dDefaultIndTexCoordScaleInfo = {
+DUSK_GAME_DATA const J3DIndTexCoordScaleInfo j3dDefaultIndTexCoordScaleInfo = {
     0x00,
     0x00,
     0x00,
     0x00,
 };
 
-const GXColor j3dDefaultTevKColor = {0xFF, 0xFF, 0xFF, 0xFF};
+DUSK_GAME_DATA const GXColor j3dDefaultTevKColor = {0xFF, 0xFF, 0xFF, 0xFF};
 
-J3DTevSwapModeInfo const j3dDefaultTevSwapMode = {
+DUSK_GAME_DATA J3DTevSwapModeInfo const j3dDefaultTevSwapMode = {
     0x00,
     0x00,
     0x00,
     0x00,
 };
 
-const J3DTevSwapModeTableInfo j3dDefaultTevSwapModeTable = {0x00, 0x01, 0x02, 0x03};
+DUSK_GAME_DATA const J3DTevSwapModeTableInfo j3dDefaultTevSwapModeTable = {0x00, 0x01, 0x02, 0x03};
 
-const J3DBlendInfo j3dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP};
+DUSK_GAME_DATA const J3DBlendInfo j3dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP};
 
-const J3DColorChanInfo j3dDefaultColorChanInfo = {
+DUSK_GAME_DATA const J3DColorChanInfo j3dDefaultColorChanInfo = {
     0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0xFF, 0xFF,
 };
 
-const u8 j3dDefaultTevSwapTableID = 0x1B;
+DUSK_GAME_DATA const u8 j3dDefaultTevSwapTableID = 0x1B;
 
-const u16 j3dDefaultAlphaCmpID = 0x00E7;
+DUSK_GAME_DATA const u16 j3dDefaultAlphaCmpID = 0x00E7;
 
-const u16 j3dDefaultZModeID = 0x0017;
+DUSK_GAME_DATA const u16 j3dDefaultZModeID = 0x0017;
diff --git a/libs/JSystem/src/J3DGraphBase/J3DTexture.cpp b/libs/JSystem/src/J3DGraphBase/J3DTexture.cpp
index a01e605abb..971d5d08dd 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DTexture.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DTexture.cpp
@@ -49,7 +49,7 @@ void J3DTexture::loadGX(u16 idx, GXTexMapID texMapID) const {
 }
 
 #if TARGET_PC
-void J3DTexture::loadGXTexObj(u16 idx) {
+void J3DTexture::initGXTexObj(u16 idx) {
     J3D_ASSERT_RANGE(29, idx < mNum);
     ResTIMG* timg = getResTIMG(idx);
 
@@ -89,7 +89,7 @@ void J3DTexture::entryNum(u16 num) {
     delete[] mpImgDataPtr;
     delete[] mpTlutDataPtr;
     mpTexObj = new TGXTexObj[num]();
-    mpTlutObj = new GXTlutObj[num]();
+    mpTlutObj = new TGXTlutObj[num]();
     mpImgDataPtr = new u8*[num]();
     mpTlutDataPtr = new u8*[num]();
 
diff --git a/libs/JSystem/src/J3DGraphBase/J3DTransform.cpp b/libs/JSystem/src/J3DGraphBase/J3DTransform.cpp
index 44e0711337..5a7099e6dc 100644
--- a/libs/JSystem/src/J3DGraphBase/J3DTransform.cpp
+++ b/libs/JSystem/src/J3DGraphBase/J3DTransform.cpp
@@ -74,12 +74,12 @@ void J3DCalcBBoardMtx(__REGISTER Mtx mtx) {
 	mtx[2][2] = z;
 }
 
-J3DTransformInfo const j3dDefaultTransformInfo = {
+DUSK_GAME_DATA J3DTransformInfo const j3dDefaultTransformInfo = {
     {1.0f, 1.0f, 1.0f}, {0, 0, 0}, {0.0f, 0.0f, 0.0f}};
 
-Vec const j3dDefaultScale = {1.0f, 1.0f, 1.0f};
+DUSK_GAME_DATA Vec const j3dDefaultScale = {1.0f, 1.0f, 1.0f};
 
-Mtx const j3dDefaultMtx = {
+DUSK_GAME_DATA Mtx const j3dDefaultMtx = {
     {1.0f, 0.0f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f, 0.0f}};
 
 void J3DCalcYBBoardMtx(Mtx mtx) {
@@ -610,7 +610,7 @@ void J3DPSMtxArrayConcat(Mtx mA, Mtx mB, Mtx mAB, u32 count) {
 }
 #endif // clang-format on
 
-f32 const PSMulUnit01[] = {
+DUSK_GAME_DATA f32 const PSMulUnit01[] = {
     0.0f,
     -1.0f,
 };
diff --git a/libs/JSystem/src/JAHostIO/JAHVirtualNode.cpp b/libs/JSystem/src/JAHostIO/JAHVirtualNode.cpp
index 71068a3591..1459a705cd 100644
--- a/libs/JSystem/src/JAHostIO/JAHVirtualNode.cpp
+++ b/libs/JSystem/src/JAHostIO/JAHVirtualNode.cpp
@@ -2,9 +2,9 @@
 #include <JSystem/JUtility/JUTAssert.h>
 #include <cstring>
 
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 
-u32 JAHVirtualNode::smVirNodeNum;
+DUSK_GAME_DATA u32 JAHVirtualNode::smVirNodeNum;
 
 void JAHVirtualNode::virtualMessage(JAHControl& control) {
     message(control);
diff --git a/libs/JSystem/src/JAHostIO/JAHioMessage.cpp b/libs/JSystem/src/JAHostIO/JAHioMessage.cpp
index bc0e26e211..a32c20962e 100644
--- a/libs/JSystem/src/JAHostIO/JAHioMessage.cpp
+++ b/libs/JSystem/src/JAHostIO/JAHioMessage.cpp
@@ -5,17 +5,17 @@
 #include "JSystem/JAHostIO/JAHioUtil.h"
 #include "JSystem/JHostIO/JORMContext.h"
 
-u16 JAHControl::smButtonWidth[] = {20, 50, 100, 150, 300, 600};
-u16 JAHControl::smCommentWidth[] = {20, 50, 100, 200, 400, 800};
-u16 JAHControl::smComboWidth[] = {50, 100, 150, 200, 300, 600};
-u16 JAHControl::smYTop = 5;
-u16 JAHControl::smXLeft = 5;
-u16 JAHControl::smIndentSize = 30;
-u16 JAHControl::smLineHeight = 23;
-u16 JAHControl::smContWidth = 450;
-u16 JAHControl::smIntX = 2;
-u16 JAHControl::smIntY = 5;
-u16 JAHControl::smNameWidth = 150;
+DUSK_GAME_DATA u16 JAHControl::smButtonWidth[] = {20, 50, 100, 150, 300, 600};
+DUSK_GAME_DATA u16 JAHControl::smCommentWidth[] = {20, 50, 100, 200, 400, 800};
+DUSK_GAME_DATA u16 JAHControl::smComboWidth[] = {50, 100, 150, 200, 300, 600};
+DUSK_GAME_DATA u16 JAHControl::smYTop = 5;
+DUSK_GAME_DATA u16 JAHControl::smXLeft = 5;
+DUSK_GAME_DATA u16 JAHControl::smIndentSize = 30;
+DUSK_GAME_DATA u16 JAHControl::smLineHeight = 23;
+DUSK_GAME_DATA u16 JAHControl::smContWidth = 450;
+DUSK_GAME_DATA u16 JAHControl::smIntX = 2;
+DUSK_GAME_DATA u16 JAHControl::smIntY = 5;
+DUSK_GAME_DATA u16 JAHControl::smNameWidth = 150;
 
 void JAHControl::returnY(u16 param_1) {
     mY += u16(smIntY + smLineHeight * param_1);
diff --git a/libs/JSystem/src/JAHostIO/JAHioMgr.cpp b/libs/JSystem/src/JAHostIO/JAHioMgr.cpp
index 91b0a030e6..9b404b6bef 100644
--- a/libs/JSystem/src/JAHostIO/JAHioMgr.cpp
+++ b/libs/JSystem/src/JAHostIO/JAHioMgr.cpp
@@ -5,7 +5,7 @@
 #include "JSystem/JHostIO/JORServer.h"
 
 template <>
-JAHioMgr* JAHSingletonBase<JAHioMgr>::sInstance = NULL;
+DUSK_GAME_DATA JAHioMgr* JAHSingletonBase<JAHioMgr>::sInstance = NULL;
 
 JAHioMgr::JAHioMgr() : field_0x4(0), field_0x8(0) {}
 
diff --git a/libs/JSystem/src/JAHostIO/JAHioNode.cpp b/libs/JSystem/src/JAHostIO/JAHioNode.cpp
index e6c342eeeb..6e6ea2a320 100644
--- a/libs/JSystem/src/JAHostIO/JAHioNode.cpp
+++ b/libs/JSystem/src/JAHostIO/JAHioNode.cpp
@@ -6,9 +6,9 @@
 #include "JSystem/JAHostIO/JAHioNode.h"
 
 #include "JSystem/JHostIO/JORServer.h"
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 
-JAHioNode* JAHioNode::smCurrentNode;
+DUSK_GAME_DATA JAHioNode* JAHioNode::smCurrentNode;
 
 JAHioNode::JAHioNode(const char* name) : mTree(this) {
     mLastChild = NULL;
diff --git a/libs/JSystem/src/JAHostIO/JAHioUtil.cpp b/libs/JSystem/src/JAHostIO/JAHioUtil.cpp
index 9a0fdf027a..6f1935744d 100644
--- a/libs/JSystem/src/JAHostIO/JAHioUtil.cpp
+++ b/libs/JSystem/src/JAHostIO/JAHioUtil.cpp
@@ -6,10 +6,10 @@
 #include "JSystem/JAHostIO/JAHioUtil.h"
 #include "JSystem/JHostIO/JORFile.h"
 
-char JAHioUtil::mStringBuffer[256];
+DUSK_GAME_DATA char JAHioUtil::mStringBuffer[256];
 
-JAHioNode* JAHUpdate::spNode;
-JORMContext* JAHUpdate::spMc;
+DUSK_GAME_DATA JAHioNode* JAHUpdate::spNode;
+DUSK_GAME_DATA JORMContext* JAHUpdate::spMc;
 
 static char* dummy(JORDir* dir) {
     return std::strrchr(dir->getFilename(), '\n');
diff --git a/libs/JSystem/src/JAudio2/JASAiCtrl.cpp b/libs/JSystem/src/JAudio2/JASAiCtrl.cpp
index 3764700149..e59c9d45fe 100644
--- a/libs/JSystem/src/JAudio2/JASAiCtrl.cpp
+++ b/libs/JSystem/src/JAudio2/JASAiCtrl.cpp
@@ -18,35 +18,37 @@
 #include <os.h>
 #include <stdint.h>
 
-#include "tracy/Tracy.hpp"
+#if TARGET_PC
+#include <tracy/Tracy.hpp>
+#endif
 
-s16* JASDriver::sDmaDacBuffer[3];
+DUSK_GAME_DATA s16* JASDriver::sDmaDacBuffer[3];
 
 static u8 data_804507A8 = 3;
 
-s16** JASDriver::sDspDacBuffer;
+DUSK_GAME_DATA s16** JASDriver::sDspDacBuffer;
 
-s32 JASDriver::sDspDacWriteBuffer;
+DUSK_GAME_DATA s32 JASDriver::sDspDacWriteBuffer;
 
-s32 JASDriver::sDspDacReadBuffer;
+DUSK_GAME_DATA s32 JASDriver::sDspDacReadBuffer;
 
-s32 JASDriver::sDspStatus;
+DUSK_GAME_DATA s32 JASDriver::sDspStatus;
 
-JASDriver::DSPBufCallback JASDriver::sDspDacCallback;
+DUSK_GAME_DATA JASDriver::DSPBufCallback JASDriver::sDspDacCallback;
 
-s16* JASDriver::lastRspMadep;
+DUSK_GAME_DATA s16* JASDriver::lastRspMadep;
 
-void (*JASDriver::dacCallbackFunc)(s16*, u32);
+DUSK_GAME_DATA void (*JASDriver::dacCallbackFunc)(s16*, u32);
 
-JASDriver::MixCallback JASDriver::extMixCallback;
+DUSK_GAME_DATA JASDriver::MixCallback JASDriver::extMixCallback;
 
-u32 JASDriver::sOutputRate;
+DUSK_GAME_DATA u32 JASDriver::sOutputRate;
 
-JASMixMode JASDriver::sMixMode = MIX_MODE_EXTRA;
+DUSK_GAME_DATA JASMixMode JASDriver::sMixMode = MIX_MODE_EXTRA;
 
-f32 JASDriver::sDacRate = 32028.5f;
+DUSK_GAME_DATA f32 JASDriver::sDacRate = 32028.5f;
 
-u32 JASDriver::sSubFrames = 0x00000007;
+DUSK_GAME_DATA u32 JASDriver::sSubFrames = 0x00000007;
 
 void JASDriver::initAI(void (*param_0)(void)) {
     setOutputRate(OUTPUT_RATE_0);
@@ -114,14 +116,14 @@ void JASDriver::setOutputRate(JASOutputRate param_0) {
 #endif
 }
 
-const JASDriver::MixFunc JASDriver::sMixFuncs[4] = {
+DUSK_GAME_DATA const JASDriver::MixFunc JASDriver::sMixFuncs[4] = {
     mixMonoTrack,
     mixMonoTrackWide,
     mixExtraTrack,
     mixInterleaveTrack,
 };
 
-u32 JASDriver::sSubFrameCounter;
+DUSK_GAME_DATA u32 JASDriver::sSubFrameCounter;
 
 void JASDriver::updateDac() {
     static u32 dacp = 0;
@@ -227,7 +229,7 @@ void JASDriver::readDspBuffer(s16* param_0, u32 param_1) {
     JASCalc::imixcopy(endDacBuffer, dacBuffer, param_0, param_1);
 }
 
-u32 sDspUpCount;
+DUSK_GAME_DATA u32 sDspUpCount;
 
 void JASDriver::finishDSPFrame() {
     static u32 waitcount;
diff --git a/libs/JSystem/src/JAudio2/JASAramStream.cpp b/libs/JSystem/src/JAudio2/JASAramStream.cpp
index 64ddfc467e..6a15869a7c 100644
--- a/libs/JSystem/src/JAudio2/JASAramStream.cpp
+++ b/libs/JSystem/src/JAudio2/JASAramStream.cpp
@@ -12,16 +12,16 @@
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include "JSystem/JSupport/JSupport.h"
 
-JASTaskThread* JASAramStream::sLoadThread;
+DUSK_GAME_DATA JASTaskThread* JASAramStream::sLoadThread;
 
-u8* JASAramStream::sReadBuffer;
+DUSK_GAME_DATA u8* JASAramStream::sReadBuffer;
 
-u32 JASAramStream::sBlockSize;
+DUSK_GAME_DATA u32 JASAramStream::sBlockSize;
 
-u32 JASAramStream::sChannelMax;
+DUSK_GAME_DATA u32 JASAramStream::sChannelMax;
 
-bool dvdHasErrored;
-bool hasErrored;
+DUSK_GAME_DATA bool dvdHasErrored;
+DUSK_GAME_DATA bool hasErrored;
 
 #define PAUSE_REQUESTED   1
 #define PAUSE_DVD_ERROR   2
diff --git a/libs/JSystem/src/JAudio2/JASAudioThread.cpp b/libs/JSystem/src/JAudio2/JASAudioThread.cpp
index fa476d1cb4..bd95337c44 100644
--- a/libs/JSystem/src/JAudio2/JASAudioThread.cpp
+++ b/libs/JSystem/src/JAudio2/JASAudioThread.cpp
@@ -41,7 +41,7 @@ void JASAudioThread::stop() {
     jamMessageBlock((void*)2);
 }
 
-volatile int JASAudioThread::snIntCount;
+DUSK_GAME_DATA volatile int JASAudioThread::snIntCount;
 
 class Lock {
 public:
diff --git a/libs/JSystem/src/JAudio2/JASBNKParser.cpp b/libs/JSystem/src/JAudio2/JASBNKParser.cpp
index 7898eedd48..ad8aa1ee46 100644
--- a/libs/JSystem/src/JAudio2/JASBNKParser.cpp
+++ b/libs/JSystem/src/JAudio2/JASBNKParser.cpp
@@ -13,7 +13,7 @@ JASBank* JASBNKParser::createBank(void const* stream, JKRHeap* heap) {
     return createBasicBank(stream, heap);
 }
 
-u32 JASBNKParser::sUsedHeapSize;
+DUSK_GAME_DATA u32 JASBNKParser::sUsedHeapSize;
 
 JASBasicBank* JASBNKParser::createBasicBank(void const* stream, JKRHeap* heap) {
     if (heap == NULL) {
diff --git a/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp b/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp
index 9170e59ed1..ac11742e6b 100644
--- a/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp
+++ b/libs/JSystem/src/JAudio2/JASBasicWaveBank.cpp
@@ -55,7 +55,7 @@ void JASBasicWaveBank::incWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
     }
 }
 
-u32 JASBasicWaveBank::mNoLoad;
+DUSK_GAME_DATA u32 JASBasicWaveBank::mNoLoad;
 
 void JASBasicWaveBank::decWaveTable(JASBasicWaveBank::TWaveGroup const* param_0) {
     JASMutexLock lock(&field_0x4);
diff --git a/libs/JSystem/src/JAudio2/JASCalc.cpp b/libs/JSystem/src/JAudio2/JASCalc.cpp
index 69369192fe..de0cf02295 100644
--- a/libs/JSystem/src/JAudio2/JASCalc.cpp
+++ b/libs/JSystem/src/JAudio2/JASCalc.cpp
@@ -11,6 +11,7 @@ void JASCalc::imixcopy(const s16* s1, const s16* s2, s16* dst, u32 n) {
     }
 }
 
+#if !TARGET_PC
 void JASCalc::bcopyfast(const void* src, void* dest, u32 size) {
     JUT_ASSERT(226, (reinterpret_cast<uintptr_t>(src) & 0x03) == 0);
     JUT_ASSERT(227, (reinterpret_cast<uintptr_t>(dest) & 0x03) == 0);
@@ -33,11 +34,7 @@ void JASCalc::bcopyfast(const void* src, void* dest, u32 size) {
     }
 }
 
-#if TARGET_ANDROID
-void JASCalc::_bcopy(const void* src, void* dest, u32 size) {
-#else
 void JASCalc::bcopy(const void* src, void* dest, u32 size) {
-#endif
     u32* usrc;
     u32* udest;
 
@@ -94,11 +91,7 @@ void JASCalc::bzerofast(void* dest, u32 size) {
     }
 }
 
-#if TARGET_ANDROID
-void JASCalc::_bzero(void* dest, u32 size) {
-#else
 void JASCalc::bzero(void* dest, u32 size) {
-#endif
     u32* udest;
     u8* bdest = (u8*)dest;
     if ((size & 0x1f) == 0 && (reinterpret_cast<uintptr_t>(dest) & 0x1f) == 0) {
@@ -139,9 +132,10 @@ void JASCalc::bzero(void* dest, u32 size) {
         }
     }
 }
+#endif
 
 #if AVOID_UB
-s16 const JASCalc::CUTOFF_TO_IIR_TABLE[129][4] = {
+DUSK_GAME_DATA s16 const JASCalc::CUTOFF_TO_IIR_TABLE[129][4] = {
 #else
 s16 const JASCalc::CUTOFF_TO_IIR_TABLE[128][4] = {
 #endif
diff --git a/libs/JSystem/src/JAudio2/JASChannel.cpp b/libs/JSystem/src/JAudio2/JASChannel.cpp
index 758167cc5c..a709edc3f9 100644
--- a/libs/JSystem/src/JAudio2/JASChannel.cpp
+++ b/libs/JSystem/src/JAudio2/JASChannel.cpp
@@ -12,13 +12,13 @@
 #include "JSystem/JMath/JMATrigonometric.h"
 #include "JSystem/JGeometry.h"
 
-OSMessageQueue JASChannel::sBankDisposeMsgQ;
+DUSK_GAME_DATA OSMessageQueue JASChannel::sBankDisposeMsgQ;
 
-OSMessage JASChannel::sBankDisposeMsg[16];
+DUSK_GAME_DATA OSMessage JASChannel::sBankDisposeMsg[16];
 
-OSMessage JASChannel::sBankDisposeList[16];
+DUSK_GAME_DATA OSMessage JASChannel::sBankDisposeList[16];
 
-int JASChannel::sBankDisposeListSize;
+DUSK_GAME_DATA int JASChannel::sBankDisposeListSize;
 
 JASChannel::JASChannel(Callback i_callback, void* i_callbackData) :
     mStatus(STATUS_STOP),
@@ -173,11 +173,7 @@ void JASChannel::updateEffectorParam(JASDsp::TChannel* i_channel, u16* i_mixerVo
 
     f32 pan = 0.5f;
     f32 dolby = 0.0f;
-#if TARGET_PC
-    u32 effectiveOutputMode = dusk::audio::EnableHrtf ? JAS_OUTPUT_SURROUND : JASDriver::getOutputMode();
-#else
     u32 effectiveOutputMode = JASDriver::getOutputMode();
-#endif
     switch (effectiveOutputMode) {
     case JAS_OUTPUT_MONO:
         break;
diff --git a/libs/JSystem/src/JAudio2/JASCmdStack.cpp b/libs/JSystem/src/JAudio2/JASCmdStack.cpp
index beaeee492e..90c56150ce 100644
--- a/libs/JSystem/src/JAudio2/JASCmdStack.cpp
+++ b/libs/JSystem/src/JAudio2/JASCmdStack.cpp
@@ -8,9 +8,9 @@
 #include "JSystem/JAudio2/JASCriticalSection.h"
 #include <os.h>
 
-JASPortCmd::TPortHead JASPortCmd::sCommandListOnce;
+DUSK_GAME_DATA JASPortCmd::TPortHead JASPortCmd::sCommandListOnce;
 
-JASPortCmd::TPortHead JASPortCmd::sCommandListStay;
+DUSK_GAME_DATA JASPortCmd::TPortHead JASPortCmd::sCommandListStay;
 
 bool JASPortCmd::addPortCmdOnce() {
 	JASCriticalSection cs;
diff --git a/libs/JSystem/src/JAudio2/JASDSPChannel.cpp b/libs/JSystem/src/JAudio2/JASDSPChannel.cpp
index 62c983248c..7c35ce8e94 100644
--- a/libs/JSystem/src/JAudio2/JASDSPChannel.cpp
+++ b/libs/JSystem/src/JAudio2/JASDSPChannel.cpp
@@ -4,7 +4,7 @@
 #include "JSystem/JAudio2/JASHeapCtrl.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
 
-JASDSPChannel* JASDSPChannel::sDspChannels;
+DUSK_GAME_DATA JASDSPChannel* JASDSPChannel::sDspChannels;
 
 JASDSPChannel::JASDSPChannel() :
     mStatus(STATUS_INACTIVE),
diff --git a/libs/JSystem/src/JAudio2/JASDSPInterface.cpp b/libs/JSystem/src/JAudio2/JASDSPInterface.cpp
index 14a723e27d..7a9b5cda3e 100644
--- a/libs/JSystem/src/JAudio2/JASDSPInterface.cpp
+++ b/libs/JSystem/src/JAudio2/JASDSPInterface.cpp
@@ -11,13 +11,13 @@
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include <os.h>
 
-JASDsp::TChannel* JASDsp::CH_BUF;
+DUSK_GAME_DATA JASDsp::TChannel* JASDsp::CH_BUF;
 
-JASDsp::FxBuf* JASDsp::FX_BUF;
+DUSK_GAME_DATA JASDsp::FxBuf* JASDsp::FX_BUF;
 
-f32 JASDsp::sDSPVolume;
+DUSK_GAME_DATA f32 JASDsp::sDSPVolume;
 
-u16 JASDsp::SEND_TABLE[] = {
+DUSK_GAME_DATA u16 JASDsp::SEND_TABLE[] = {
     0x0D00,
     0x0D60,
     0x0DC8,
@@ -32,10 +32,10 @@ u16 JASDsp::SEND_TABLE[] = {
     0x0000,
 };
 
-u32 JASWaveInfo::one = 1;
+DUSK_GAME_DATA u32 JASWaveInfo::one = 1;
 
 #if DEBUG
-s32 JASDsp::dspMutex = 1;
+DUSK_GAME_DATA s32 JASDsp::dspMutex = 1;
 #endif
 
 void JASDsp::boot(void (*param_0)(void*)) {
@@ -99,14 +99,14 @@ void JASDsp::invalChannelAll() {
     DCInvalidateRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
 }
 
-u8 const ATTRIBUTE_ALIGN(32) JASDsp::DSPADPCM_FILTER[64] = {
+ATTRIBUTE_ALIGN(32) DUSK_GAME_DATA u8 const JASDsp::DSPADPCM_FILTER[64] = {
     0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x04, 0x00,
     0x10, 0x00, 0xF8, 0x00, 0x0E, 0x00, 0xFA, 0x00, 0x0C, 0x00, 0xFC, 0x00, 0x12, 0x00, 0xF6, 0x00,
     0x10, 0x68, 0xF7, 0x38, 0x12, 0xC0, 0xF7, 0x04, 0x14, 0x00, 0xF4, 0x00, 0x08, 0x00, 0xF8, 0x00,
     0x04, 0x00, 0xFC, 0x00, 0xFC, 0x00, 0x04, 0x00, 0xFC, 0x00, 0x00, 0x00, 0xF8, 0x00, 0x00, 0x00,
 };
 
-u32 const ATTRIBUTE_ALIGN(32) JASDsp::DSPRES_FILTER[320] = {
+ATTRIBUTE_ALIGN(32) DUSK_GAME_DATA u32 const JASDsp::DSPRES_FILTER[320] = {
     0x0C3966AD,
     0x0D46FFDF,
     0x0B396696,
diff --git a/libs/JSystem/src/JAudio2/JASDriverIF.cpp b/libs/JSystem/src/JAudio2/JASDriverIF.cpp
index 7d602a8856..a08e3339ea 100644
--- a/libs/JSystem/src/JAudio2/JASDriverIF.cpp
+++ b/libs/JSystem/src/JAudio2/JASDriverIF.cpp
@@ -3,13 +3,14 @@
 #include "JSystem/JAudio2/JASDriverIF.h"
 #include "JSystem/JAudio2/JASAiCtrl.h"
 #include "JSystem/JAudio2/JASDSPInterface.h"
+#include "dusk/settings.h"
 #include <os.h>
 
 void JASDriver::setDSPLevel(f32 param_0) {
     JASDsp::setDSPMixerLevel(param_0);
 }
 
-u16 JASDriver::MAX_MIXERLEVEL = 0x2EE0;
+DUSK_GAME_DATA u16 JASDriver::MAX_MIXERLEVEL = 0x2EE0;
 
 u16 JASDriver::getChannelLevel_dsp() {
     return JASDriver::MAX_MIXERLEVEL;
@@ -23,14 +24,25 @@ f32 JASDriver::getDSPLevel() {
     return JASDsp::getDSPMixerLevel();
 }
 
-u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = JAS_OUTPUT_STEREO;
+DUSK_GAME_DATA u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = JAS_OUTPUT_STEREO;
 
 void JASDriver::setOutputMode(u32 mode) {
     JAS_SYSTEM_OUTPUT_MODE = mode;
 }
 
 u32 JASDriver::getOutputMode() {
+#ifdef TARGET_PC
+    switch (dusk::getSettings().audio.outputMode) {
+        case dusk::AudioOutputMode::StereoSpeakers:
+            return JAS_OUTPUT_STEREO;
+        case dusk::AudioOutputMode::StereoHeadphones:
+        case dusk::AudioOutputMode::Surround6ch:
+        case dusk::AudioOutputMode::Surround8ch:
+            return JAS_OUTPUT_SURROUND;
+    }
+#else
     return JASDriver::JAS_SYSTEM_OUTPUT_MODE;
+#endif
 }
 
 void JASDriver::waitSubFrame() {
@@ -40,11 +52,11 @@ void JASDriver::waitSubFrame() {
     } while (r31 == getSubFrameCounter());
 }
 
-JASCallbackMgr JASDriver::sDspSyncCallback;
+DUSK_GAME_DATA JASCallbackMgr JASDriver::sDspSyncCallback;
 
-JASCallbackMgr JASDriver::sSubFrameCallback;
+DUSK_GAME_DATA JASCallbackMgr JASDriver::sSubFrameCallback;
 
-JASCallbackMgr JASDriver::sUpdateDacCallback;
+DUSK_GAME_DATA JASCallbackMgr JASDriver::sUpdateDacCallback;
 
 int JASDriver::rejectCallback(DriverCallback callback, void* param_1) {
     int r31 = sDspSyncCallback.reject(callback, param_1);
diff --git a/libs/JSystem/src/JAudio2/JASDvdThread.cpp b/libs/JSystem/src/JAudio2/JASDvdThread.cpp
index 31a313a8b1..dfa85d3166 100644
--- a/libs/JSystem/src/JAudio2/JASDvdThread.cpp
+++ b/libs/JSystem/src/JAudio2/JASDvdThread.cpp
@@ -4,7 +4,7 @@
 #include "JSystem/JAudio2/JASTaskThread.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
 
-JASTaskThread* JASDvd::sThread;
+DUSK_GAME_DATA JASTaskThread* JASDvd::sThread;
 
 JASTaskThread* JASDvd::getThreadPointer() {
     return JASDvd::sThread;
diff --git a/libs/JSystem/src/JAudio2/JASHeapCtrl.cpp b/libs/JSystem/src/JAudio2/JASHeapCtrl.cpp
index e3722e3726..ef2d26256a 100644
--- a/libs/JSystem/src/JAudio2/JASHeapCtrl.cpp
+++ b/libs/JSystem/src/JAudio2/JASHeapCtrl.cpp
@@ -247,7 +247,7 @@ JASGenericMemPool::~JASGenericMemPool() {
     }
 }
 
-JKRSolidHeap* JASDram;
+DUSK_GAME_DATA JKRSolidHeap* JASDram;
 
 // TODO: What is this and Where does it go?
 struct TNextOnFreeList {
@@ -290,11 +290,11 @@ void JASGenericMemPool::free(void* ptr, u32 param_1) {
     freeMemCount++;
 }
 
-uintptr_t JASKernel::sAramBase;
+DUSK_GAME_DATA uintptr_t JASKernel::sAramBase;
 
-JKRHeap* JASKernel::sSystemHeap;
+DUSK_GAME_DATA JKRHeap* JASKernel::sSystemHeap;
 
-JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable>* JASKernel::sCommandHeap;
+DUSK_GAME_DATA JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable>* JASKernel::sCommandHeap;
 
 void JASKernel::setupRootHeap(JKRSolidHeap* heap, u32 size) {
     JUT_ASSERT(784, heap);
@@ -314,7 +314,7 @@ JASMemChunkPool<1024, JASThreadingModel::ObjectLevelLockable>* JASKernel::getCom
     return JASKernel::sCommandHeap;
 }
 
-JASHeap JASKernel::audioAramHeap;
+DUSK_GAME_DATA JASHeap JASKernel::audioAramHeap;
 
 void JASKernel::setupAramHeap(uintptr_t param_0, u32 param_1) {
 #if !PLATFORM_GCN
diff --git a/libs/JSystem/src/JAudio2/JASLfo.cpp b/libs/JSystem/src/JAudio2/JASLfo.cpp
index d369072a15..4a9af0c3c9 100644
--- a/libs/JSystem/src/JAudio2/JASLfo.cpp
+++ b/libs/JSystem/src/JAudio2/JASLfo.cpp
@@ -40,7 +40,7 @@ void JASLfo::incCounter(f32 param_0) {
     }
 }
 
-JASLfo JASLfo::sFreeRunLfo;
+DUSK_GAME_DATA JASLfo JASLfo::sFreeRunLfo;
 
 void JASLfo::resetCounter() {
     field_0x16 = mDelay;
diff --git a/libs/JSystem/src/JAudio2/JASOscillator.cpp b/libs/JSystem/src/JAudio2/JASOscillator.cpp
index f4bf2ade6f..666b2dd439 100644
--- a/libs/JSystem/src/JAudio2/JASOscillator.cpp
+++ b/libs/JSystem/src/JAudio2/JASOscillator.cpp
@@ -131,25 +131,25 @@ void JASOscillator::update() {
     updateCurrentValue(psVar1[mCurPoint].mTime);
 }
 
-f32 const JASOscillator::sCurveTableLinear[17] = {
+DUSK_GAME_DATA f32 const JASOscillator::sCurveTableLinear[17] = {
     1.0, 0.9375, 0.875, 0.8125, 0.75, 0.6875, 0.625, 0.5625, 0.5,
     0.4375, 0.375, 0.3125, 0.25, 0.1875, 0.125, 0.0625, 0.0,
 };
 
-f32 const JASOscillator::sCurveTableSampleCell[17] = {
+DUSK_GAME_DATA f32 const JASOscillator::sCurveTableSampleCell[17] = {
     1.0, 0.9704890251159668, 0.7812740206718445, 0.5462809801101685, 0.39979198575019836, 
     0.28931498527526855, 0.21210399270057678, 0.15747599303722382, 0.1126129999756813, 0.08178959786891937, 
     0.057985201478004456, 0.04364150017499924, 0.03082370012998581, 0.023712899535894394, 0.015259300358593464, 
     0.00915555004030466, 0.0
 };
 
-f32 const JASOscillator::sCurveTableSqRoot[17] = {
+DUSK_GAME_DATA f32 const JASOscillator::sCurveTableSqRoot[17] = {
     1.0, 0.8789060115814209, 0.765625, 0.6601560115814209, 0.5625, 0.4726560115814209,
     0.390625, 0.3164060115814209, 0.25, 0.1914059966802597, 0.140625, 0.09765619784593582,
     0.0625, 0.03515620157122612, 0.015625, 0.00390625, 0.0
 };
 
-f32 const JASOscillator::sCurveTableSquare[17] = {
+DUSK_GAME_DATA f32 const JASOscillator::sCurveTableSquare[17] = {
     1.0, 0.9682459831237793, 0.9354140162467957, 0.9013879895210266, 0.8660249710083008,
     0.8291559815406799, 0.790569007396698, 0.75, 0.7071070075035095, 0.66143798828125,
     0.6123719811439514, 0.55901700258255, 0.5, 0.433012992143631, 0.35355299711227417, 0.25, 0.0,
diff --git a/libs/JSystem/src/JAudio2/JASProbe.cpp b/libs/JSystem/src/JAudio2/JASProbe.cpp
index 55a63e67c8..70e930c2bb 100644
--- a/libs/JSystem/src/JAudio2/JASProbe.cpp
+++ b/libs/JSystem/src/JAudio2/JASProbe.cpp
@@ -26,7 +26,7 @@ void JASProbe::stop() {
 	_1A8++;
 }
 
-JASProbe* JASProbe::sProbeTable[16];
+DUSK_GAME_DATA JASProbe* JASProbe::sProbeTable[16];
 
 void JASProbe::start(s32 index, char const* name) {
 	JASProbe* probe;
diff --git a/libs/JSystem/src/JAudio2/JASResArcLoader.cpp b/libs/JSystem/src/JAudio2/JASResArcLoader.cpp
index a55c73469c..57e6742c51 100644
--- a/libs/JSystem/src/JAudio2/JASResArcLoader.cpp
+++ b/libs/JSystem/src/JAudio2/JASResArcLoader.cpp
@@ -17,7 +17,7 @@ size_t JASResArcLoader::getResSize(JKRArchive const* i_archiveP, u16 i_resourceI
         return 0;
 	}
 
-    return file->data_size;
+    return DUSK_IF_ELSE(i_archiveP->getFileSize(file), file->data_size);
 }
 
 size_t JASResArcLoader::getResMaxSize(JKRArchive const* i_archiveP) {
@@ -27,9 +27,16 @@ size_t JASResArcLoader::getResMaxSize(JKRArchive const* i_archiveP) {
     for (index = 0; index < fileEntries; index++) {
         JKRArchive::SDIFileEntry* file = i_archiveP->findIdxResource(index);
         if (file) {
+#if TARGET_PC
+            const u32 fileSize = i_archiveP->getFileSize(file);
+            if (maxSize < fileSize) {
+                maxSize = fileSize;
+            }
+#else
             if (maxSize < file->data_size) {
                 maxSize = file->data_size;
             }
+#endif
         }
     }
 
diff --git a/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp b/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp
index a4e4a4b441..d9fe9d6698 100644
--- a/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp
+++ b/libs/JSystem/src/JAudio2/JASSeqCtrl.cpp
@@ -4,7 +4,7 @@
 #include "JSystem/JAudio2/JASSeqParser.h"
 #include "JSystem/JAudio2/JASTrack.h"
 
-JASSeqParser JASSeqCtrl::sDefaultParser;
+DUSK_GAME_DATA JASSeqParser JASSeqCtrl::sDefaultParser;
 
 JASSeqCtrl::JASSeqCtrl() {
     field_0x3c = &sDefaultParser;
diff --git a/libs/JSystem/src/JAudio2/JASSeqParser.cpp b/libs/JSystem/src/JAudio2/JASSeqParser.cpp
index b2077ce499..92288cbc4e 100644
--- a/libs/JSystem/src/JAudio2/JASSeqParser.cpp
+++ b/libs/JSystem/src/JAudio2/JASSeqParser.cpp
@@ -9,7 +9,7 @@
 #include "JSystem/JUtility/JUTAssert.h"
 
 
-JASSeqParser::CmdInfo JASSeqParser::sCmdInfo[96] = {
+DUSK_GAME_DATA JASSeqParser::CmdInfo JASSeqParser::sCmdInfo[96] = {
     NULL, 0x0000, 0x0000,
     NULL, 0x0000, 0x0000,
     NULL, 0x0000, 0x0000,
@@ -108,7 +108,7 @@ JASSeqParser::CmdInfo JASSeqParser::sCmdInfo[96] = {
     &JASSeqParser::cmdFinish, 0x0000, 0x0000,
 };
 
-JASSeqParser::CmdInfo JASSeqParser::sExtCmdInfo[255] = {
+DUSK_GAME_DATA JASSeqParser::CmdInfo JASSeqParser::sExtCmdInfo[255] = {
     NULL, 0x0000, 0x0000,
     &JASSeqParser::cmdDump, 0x0000, 0x0000,
     NULL, 0x0000, 0x0000,
@@ -589,7 +589,7 @@ s32 JASSeqParser::cmdIntTimer(JASTrack* param_0, u32* param_1) {
     return 0;
 }
 
-u16 (*JASSeqParser::sCallBackFunc)(JASTrack*, u16);
+DUSK_GAME_DATA u16 (*JASSeqParser::sCallBackFunc)(JASTrack*, u16);
 
 s32 JASSeqParser::cmdSyncCPU(JASTrack* param_0, u32* param_1) {
     u16 r31 = 0xffff;
diff --git a/libs/JSystem/src/JAudio2/JASTrack.cpp b/libs/JSystem/src/JAudio2/JASTrack.cpp
index 68fbee63e5..4b1a7ba7aa 100644
--- a/libs/JSystem/src/JAudio2/JASTrack.cpp
+++ b/libs/JSystem/src/JAudio2/JASTrack.cpp
@@ -15,9 +15,9 @@ JASTrack::JASTrack() : mDefaultChannelMgr(this), mChannelMgrCount(1), mStatus(0)
     init();
 }
 
-JASDefaultBankTable JASTrack::sDefaultBankTable;
+DUSK_GAME_DATA JASDefaultBankTable JASTrack::sDefaultBankTable;
 
-JASTrack::TList JASTrack::sTrackList;
+DUSK_GAME_DATA JASTrack::TList JASTrack::sTrackList;
 
 // NONMATCHING JASPoolAllocObject_MultiThreaded<_> locations
 JASTrack::~JASTrack() {
@@ -50,16 +50,16 @@ void JASTrack::setChannelMgrCount(u32 count) {
     }
 }
 
-JASOscillator::Point const JASTrack::sAdsTable[4] = {
+DUSK_GAME_DATA JASOscillator::Point const JASTrack::sAdsTable[4] = {
     {0, 0, 0x7fff},
     {0, 0, 0x7fff},
     {0, 0, 0},
     {0xe, 0, 0},
 };
 
-JASOscillator::Data const JASTrack::sEnvOsc = {0, 1.0f, NULL, NULL, 1.0f, 0.0f};
+DUSK_GAME_DATA JASOscillator::Data const JASTrack::sEnvOsc = {0, 1.0f, NULL, NULL, 1.0f, 0.0f};
 
-JASOscillator::Data const JASTrack::sPitchEnvOsc = {1, 1.0f, NULL, NULL, 1.0f, 0.0f};
+DUSK_GAME_DATA JASOscillator::Data const JASTrack::sPitchEnvOsc = {1, 1.0f, NULL, NULL, 1.0f, 0.0f};
 
 // NONMATCHING JASPoolAllocObject_MultiThreaded<_> locations
 void JASTrack::init() {
@@ -552,7 +552,7 @@ void JASTrack::setOscAdsr(s16 param_0, s16 param_1, s16 param_2, s16 param_3, u1
     mDirectRelease = i_directRelease;
 }
 
-const u32 JASDsp::FILTER_MODE_IIR = 0x00000020;
+DUSK_GAME_DATA const u32 JASDsp::FILTER_MODE_IIR = 0x00000020;
 
 void JASTrack::setFIR(s16 const* i_FIR) {
     for (int i = 0; i < 8; i++) {
diff --git a/libs/JSystem/src/JAudio2/JASVoiceBank.cpp b/libs/JSystem/src/JAudio2/JASVoiceBank.cpp
index f69616a3af..0d3cd3adb2 100644
--- a/libs/JSystem/src/JAudio2/JASVoiceBank.cpp
+++ b/libs/JSystem/src/JAudio2/JASVoiceBank.cpp
@@ -3,11 +3,11 @@
 #include "JSystem/JAudio2/JASVoiceBank.h"
 #include "JSystem/JAudio2/JASBasicInst.h"
 
-const JASOscillator::Data JASVoiceBank::sOscData = {
+DUSK_GAME_DATA const JASOscillator::Data JASVoiceBank::sOscData = {
     0, 1.0f, NULL, NULL, 1.0f, 0.0f,
 };
 
-JASOscillator::Data* JASVoiceBank::sOscTable;
+DUSK_GAME_DATA JASOscillator::Data* JASVoiceBank::sOscTable;
 
 bool JASVoiceBank::getInstParam(int param_0, int param_1, int param_2,
                                     JASInstParam* param_3) const {
diff --git a/libs/JSystem/src/JAudio2/JASWSParser.cpp b/libs/JSystem/src/JAudio2/JASWSParser.cpp
index 4288377548..519eaa3307 100644
--- a/libs/JSystem/src/JAudio2/JASWSParser.cpp
+++ b/libs/JSystem/src/JAudio2/JASWSParser.cpp
@@ -21,7 +21,7 @@ JASWaveBank* JASWSParser::createWaveBank(void const* stream, JKRHeap* heap) {
     }
 }
 
-u32 JASWSParser::sUsedHeapSize;
+DUSK_GAME_DATA u32 JASWSParser::sUsedHeapSize;
 
 JASBasicWaveBank* JASWSParser::createBasicWaveBank(void const* stream, JKRHeap* heap) {
     if (heap == NULL) {
diff --git a/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp b/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp
index 41ad35380d..02730f46b4 100644
--- a/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp
+++ b/libs/JSystem/src/JAudio2/JASWaveArcLoader.cpp
@@ -9,9 +9,9 @@
 #include <os.h>
 #include <stdint.h>
 
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 
-JASHeap* JASWaveArcLoader::sAramHeap;
+DUSK_GAME_DATA JASHeap* JASWaveArcLoader::sAramHeap;
 
 JASHeap* JASWaveArcLoader::getRootHeap() {
     if (JASWaveArcLoader::sAramHeap) {
@@ -20,7 +20,7 @@ JASHeap* JASWaveArcLoader::getRootHeap() {
     return JASKernel::getAramHeap();
 }
 
-char JASWaveArcLoader::sCurrentDir[DIR_MAX] = "/AudioRes/Waves/";
+DUSK_GAME_DATA char JASWaveArcLoader::sCurrentDir[DIR_MAX] = "/AudioRes/Waves/";
 
 void JASWaveArcLoader::setCurrentDir(char const* dir) {
     JUT_ASSERT(40, std::strlen(dir) < DIR_MAX - 1);
diff --git a/libs/JSystem/src/JAudio2/dsptask.cpp b/libs/JSystem/src/JAudio2/dsptask.cpp
index 7d2e8dd2ad..ce91ae2e78 100644
--- a/libs/JSystem/src/JAudio2/dsptask.cpp
+++ b/libs/JSystem/src/JAudio2/dsptask.cpp
@@ -25,7 +25,7 @@ void DspHandShake(void*) {
     Dsp_Running_Start();
 }
 
-static u8 jdsp[7936] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 jdsp[7936] = {
     0x02, 0x9F, 0x00, 0x12, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x00, 0x00, 0x02, 0xFF, 0x00, 0x00,
     0x02, 0xFF, 0x00, 0x00, 0x02, 0xFF, 0x00, 0x00, 0x02, 0xFF, 0x00, 0x00, 0x02, 0x9F, 0x06, 0xA5,
     0x02, 0x9F, 0x00, 0x4E, 0x12, 0x05, 0x02, 0xBF, 0x00, 0x57, 0x81, 0x00, 0x00, 0x9F, 0x10, 0x00,
@@ -524,9 +524,9 @@ static u8 jdsp[7936] ATTRIBUTE_ALIGN(32) = {
     0x80, 0x01, 0x02, 0xBF, 0x00, 0xF4, 0x02, 0xDF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static DSPTaskInfo audio_task ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static DSPTaskInfo audio_task;
 
-static u8 AUDIO_YIELD_BUFFER[8192] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 AUDIO_YIELD_BUFFER[8192];
 
 void DspBoot(void (*requestCallback)(void*)) {
     DspInitWork();
diff --git a/libs/JSystem/src/JAudio2/osdsp_task.cpp b/libs/JSystem/src/JAudio2/osdsp_task.cpp
index 7ec8f3f855..c7d24eaca8 100644
--- a/libs/JSystem/src/JAudio2/osdsp_task.cpp
+++ b/libs/JSystem/src/JAudio2/osdsp_task.cpp
@@ -5,8 +5,8 @@
 #include <dsp.h>
 #include <os.h>
 
-extern DSPTaskInfo* __DSP_first_task;
-extern DSPTaskInfo* __DSP_curr_task;
+DUSK_GAME_EXTERN DSPTaskInfo* __DSP_first_task;
+DUSK_GAME_EXTERN DSPTaskInfo* __DSP_curr_task;
 extern "C" void __DSP_exec_task(DSPTaskInfo*, DSPTaskInfo*);
 extern "C" void __DSP_remove_task(DSPTaskInfo* task);
 
diff --git a/libs/JSystem/src/JFramework/JFWDisplay.cpp b/libs/JSystem/src/JFramework/JFWDisplay.cpp
index 2d4c9c7126..0524cb86f7 100644
--- a/libs/JSystem/src/JFramework/JFWDisplay.cpp
+++ b/libs/JSystem/src/JFramework/JFWDisplay.cpp
@@ -12,16 +12,18 @@
 #include "global.h"
 #include <stdint.h>
 
-#ifdef TARGET_PC
+#if TARGET_PC
 #include "dusk/dusk.h"
-#include "dusk/gx_helper.h"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/logging.h"
 #include "dusk/settings.h"
 #include "dusk/time.h"
+#include "helpers/gx_helper.h"
+
 #include "f_op/f_op_overlap_mng.h"
 
-#include "SDL3/SDL_timer.h"
-#include "tracy/Tracy.hpp"
+#include <SDL3/SDL_timer.h>
+#include <tracy/Tracy.hpp>
 
 #include <chrono>
 #endif
@@ -37,7 +39,7 @@ void JFWDisplay::ctor_subroutine(bool enableAlpha) {
     mTickRate = 0;
     mCombinationRatio = 0.0f;
     field_0x30 = 0;
-    field_0x2c = OSGetTick();
+    field_0x2c = DUSK_IF_ELSE(static_cast<OSTick>(OSGetNativeTime()), OSGetTick());
     field_0x34 = 0;
     field_0x48 = 0;
     field_0x4a = 0;
@@ -65,7 +67,7 @@ JFWDisplay::~JFWDisplay() {
     mXfbManager = NULL;
 }
 
-JFWDisplay* JFWDisplay::sManager;
+DUSK_GAME_DATA JFWDisplay* JFWDisplay::sManager;
 
 JFWDisplay* JFWDisplay::createManager(GXRenderModeObj const* p_rObj, JKRHeap* p_heap,
                                       JUTXfb::EXfbNumber xfb_num, bool enableAlpha) {
@@ -216,8 +218,8 @@ void JFWDisplay::endGX() {
 
     if (mFader != NULL) {
         ortho.setPort();
-#ifdef TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending()) {
+#if TARGET_PC
+        if (dusk::interp::get_ui_tick_pending()) {
             mFader->advance();
         }
         if (mFader->getStatus() != JUTFader::Wait) {
@@ -257,7 +259,7 @@ void JFWDisplay::beginRender() {
     waitForTick(mTickRate, mFrameRate);
     JUTVideo::getManager()->waitRetraceIfNeed();
 
-    OSTick tick = OSGetTick();
+    OSTick tick = DUSK_IF_ELSE(static_cast<OSTick>(OSGetNativeTime()), OSGetTick());
     field_0x30 = tick - field_0x2c;
     field_0x2c = tick;
     field_0x34 = field_0x2c - JUTVideo::getVideoLastTick();
@@ -370,7 +372,7 @@ constexpr auto FRAME_PERIOD = std::chrono::duration_cast<std::chrono::nanosecond
 constexpr auto RETRACE_PERIOD = FRAME_PERIOD / 2;
 
 static void waitPrecise(Limiter& limiter, Limiter::duration_t targetNs) {
-   const auto sleepTime = limiter.Sleep(targetNs);
+    const auto sleepTime = limiter.Sleep(targetNs);
     dusk::frameUsagePct =
         100.0f * (1.0f - static_cast<float>(sleepTime) / static_cast<float>(targetNs));
 }
@@ -380,15 +382,12 @@ static void waitForTick(u32 p1, u16 p2) {
 #if TARGET_PC
     static Limiter limiter;
 
-    if (dusk::frame_interp::is_enabled() && !dusk::getTransientSettings().skipFrameRateLimit) {
-        dusk::frameUsagePct = 0.f; 
-        return; 
+    if (dusk::interp::is_enabled() || dusk::getTransientSettings().turboMode) {
+        limiter.Reset();
+        dusk::frameUsagePct = 0.f;
+        return;
     }
 
-    if (dusk::getTransientSettings().skipFrameRateLimit) {
-        p1 = OS_TIMER_CLOCK / 120;
-    }
-    
     if (fopOvlpM_IsPeek() && dusk::getTransientSettings().stateShareLoadActive) {
         return;
     }
@@ -398,7 +397,6 @@ static void waitForTick(u32 p1, u16 p2) {
 
     if (p1 != 0) {
 #if TARGET_PC
-        static Limiter limiter;
         waitPrecise(limiter, static_cast<Uint64>(OSTicksToMicroseconds(p1)) * 1000ULL);
 #else
         static OSTime nextTick = OSGetTime();
@@ -412,7 +410,6 @@ static void waitForTick(u32 p1, u16 p2) {
     } else {
         u32 uVar1 = (p2 == 0) ? 1 : p2;
 #if TARGET_PC
-        static Limiter limiter;
         waitPrecise(limiter, static_cast<Uint64>((RETRACE_PERIOD * uVar1).count()));
 #else
         static u32 nextCount = VIGetRetraceCount();
@@ -428,7 +425,7 @@ static void waitForTick(u32 p1, u16 p2) {
     }
 }
 
-JSUList<JFWAlarm> JFWAlarm::sList(false);
+DUSK_GAME_DATA JSUList<JFWAlarm> JFWAlarm::sList(false);
 static void JFWThreadAlarmHandler(OSAlarm* p_alarm, OSContext* p_ctx) {
     JFWAlarm* alarm = static_cast<JFWAlarm*>(p_alarm);
     alarm->removeLink();
@@ -451,13 +448,13 @@ static void dummy() {
     JUTXfb::getManager()->setDisplayingXfbIndex(0);
 }
 
-static Mtx e_mtx ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static Mtx e_mtx = {
     {1.0f, 0.0f, 0.0f, 0.0f},
     {0.0f, 1.0f, 0.0f, 0.0f},
     {0.0f, 0.0f, 1.0f, 0.0f},
 };
 
-static u8 clear_z_TX[64] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 clear_z_TX[64] = {
     0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
     0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
diff --git a/libs/JSystem/src/JFramework/JFWSystem.cpp b/libs/JSystem/src/JFramework/JFWSystem.cpp
index d6322f34c9..e0f9f58ef6 100644
--- a/libs/JSystem/src/JFramework/JFWSystem.cpp
+++ b/libs/JSystem/src/JFramework/JFWSystem.cpp
@@ -13,32 +13,32 @@
 #include "JSystem/JUtility/JUTResFont.h"
 #include "JSystem/JUtility/JUTDbPrint.h"
 
-s32 JFWSystem::CSetUpParam::maxStdHeaps = 2;
+DUSK_GAME_DATA s32 JFWSystem::CSetUpParam::maxStdHeaps = 2;
 
-u32 JFWSystem::CSetUpParam::sysHeapSize = 0x400000;
+DUSK_GAME_DATA u32 JFWSystem::CSetUpParam::sysHeapSize = 0x400000;
 
-JKRExpHeap* JFWSystem::rootHeap;
+DUSK_GAME_DATA JKRExpHeap* JFWSystem::rootHeap;
 
-JKRExpHeap* JFWSystem::systemHeap;
+DUSK_GAME_DATA JKRExpHeap* JFWSystem::systemHeap;
 
 
-u32 JFWSystem::CSetUpParam::fifoBufSize = 0x40000;
+DUSK_GAME_DATA u32 JFWSystem::CSetUpParam::fifoBufSize = 0x40000;
 
-u32 JFWSystem::CSetUpParam::aramAudioBufSize = 0x800000;
+DUSK_GAME_DATA u32 JFWSystem::CSetUpParam::aramAudioBufSize = 0x800000;
 
-u32 JFWSystem::CSetUpParam::aramGraphBufSize = 0x600000;
+DUSK_GAME_DATA u32 JFWSystem::CSetUpParam::aramGraphBufSize = 0x600000;
 
-s32 JFWSystem::CSetUpParam::streamPriority = 8;
+DUSK_GAME_DATA s32 JFWSystem::CSetUpParam::streamPriority = 8;
 
-s32 JFWSystem::CSetUpParam::decompPriority = 7;
+DUSK_GAME_DATA s32 JFWSystem::CSetUpParam::decompPriority = 7;
 
-s32 JFWSystem::CSetUpParam::aPiecePriority = 6;
+DUSK_GAME_DATA s32 JFWSystem::CSetUpParam::aPiecePriority = 6;
 
-ResFONT* JFWSystem::CSetUpParam::systemFontRes = (ResFONT*)&JUTResFONT_Ascfont_fix12;
+DUSK_GAME_DATA ResFONT* JFWSystem::CSetUpParam::systemFontRes = (ResFONT*)&JUTResFONT_Ascfont_fix12;
 
-const GXRenderModeObj* JFWSystem::CSetUpParam::renderMode = &GXNtsc480IntDf;
+DUSK_GAME_DATA const GXRenderModeObj* JFWSystem::CSetUpParam::renderMode = &GXNtsc480IntDf;
 
-u32 JFWSystem::CSetUpParam::exConsoleBufferSize = 0x24FC;
+DUSK_GAME_DATA u32 JFWSystem::CSetUpParam::exConsoleBufferSize = 0x24FC;
 
 void JFWSystem::firstInit() {
     JUT_ASSERT(80, rootHeap == NULL);
@@ -49,17 +49,17 @@ void JFWSystem::firstInit() {
     JKRHEAP_NAME(systemHeap, "System");
 }
 
-JKRThread* JFWSystem::mainThread;
+DUSK_GAME_DATA JKRThread* JFWSystem::mainThread;
 
-JUTDbPrint* JFWSystem::debugPrint;
+DUSK_GAME_DATA JUTDbPrint* JFWSystem::debugPrint;
 
-JUTResFont* JFWSystem::systemFont;
+DUSK_GAME_DATA JUTResFont* JFWSystem::systemFont;
 
-JUTConsoleManager* JFWSystem::systemConsoleManager;
+DUSK_GAME_DATA JUTConsoleManager* JFWSystem::systemConsoleManager;
 
-JUTConsole* JFWSystem::systemConsole;
+DUSK_GAME_DATA JUTConsole* JFWSystem::systemConsole;
 
-bool JFWSystem::sInitCalled = false;
+DUSK_GAME_DATA bool JFWSystem::sInitCalled = false;
 
 void JFWSystem::init() {
     JUT_ASSERT(101, sInitCalled == false);
diff --git a/libs/JSystem/src/JHostIO/JHIMccBuf.cpp b/libs/JSystem/src/JHostIO/JHIMccBuf.cpp
index 363eb23dd8..1f9df6be7b 100644
--- a/libs/JSystem/src/JHostIO/JHIMccBuf.cpp
+++ b/libs/JSystem/src/JHostIO/JHIMccBuf.cpp
@@ -14,8 +14,8 @@ void JHIReport(const char* fmt, ...) {}
 
 void JHIHalt(const char* fmt, ...) {}
 
-u8* JHIMccBuf::mTempBuf;
-u16 JHIMccBuf::mRefCount;
+DUSK_GAME_DATA u8* JHIMccBuf::mTempBuf;
+DUSK_GAME_DATA u16 JHIMccBuf::mRefCount;
 
 JHIMccBuf::JHIMccBuf(u16 channel, u16 param_1, u32 param_2) {
     initInstance(channel, param_1, param_2);
diff --git a/libs/JSystem/src/JHostIO/JHIRMcc.cpp b/libs/JSystem/src/JHostIO/JHIRMcc.cpp
index fc1b295181..f3892f6520 100644
--- a/libs/JSystem/src/JHostIO/JHIRMcc.cpp
+++ b/libs/JSystem/src/JHostIO/JHIRMcc.cpp
@@ -7,14 +7,14 @@
 #include <revolution/hio2.h>
 #endif
 
-HIO2DeviceType gExiDevice = HIO2_DEVICE_INVALID;
-u8 data_8074bd04 = 1;
+DUSK_GAME_DATA HIO2DeviceType gExiDevice = HIO2_DEVICE_INVALID;
+DUSK_GAME_DATA u8 data_8074bd04 = 1;
 
-s32 ghHIO2;
-JHIMccContext tContext_old;
-JHIMccContext tContext_new;
-bool data_8074d138;
-u8 data_8074d139;
+DUSK_GAME_DATA s32 ghHIO2;
+DUSK_GAME_DATA JHIMccContext tContext_old;
+DUSK_GAME_DATA JHIMccContext tContext_new;
+DUSK_GAME_DATA bool data_8074d138;
+DUSK_GAME_DATA u8 data_8074d139;
 
 BOOL JHIhio2CallbackEnum(HIO2DeviceType type) {
     gExiDevice = type;
diff --git a/libs/JSystem/src/JHostIO/JHIhioASync.cpp b/libs/JSystem/src/JHostIO/JHIhioASync.cpp
index b423c366fe..a25e5bd136 100644
--- a/libs/JSystem/src/JHostIO/JHIhioASync.cpp
+++ b/libs/JSystem/src/JHostIO/JHIhioASync.cpp
@@ -9,16 +9,16 @@
 #endif
 #include "global.h"
 
-u32 gsEnableHostio;
-u32 gsEnableInterface;
-u32 gsDataToRead;
+DUSK_GAME_DATA u32 gsEnableHostio;
+DUSK_GAME_DATA u32 gsEnableInterface;
+DUSK_GAME_DATA u32 gsDataToRead;
 
-u8* gsReadBuf;
-u8* gsWriteBuf;
-JHICommBufReader* gsJHIrecvBuf;
-JHICommBufWriter* gsJHIsendBuf;
+DUSK_GAME_DATA u8* gsReadBuf;
+DUSK_GAME_DATA u8* gsWriteBuf;
+DUSK_GAME_DATA JHICommBufReader* gsJHIrecvBuf;
+DUSK_GAME_DATA JHICommBufWriter* gsJHIsendBuf;
 
-JHIMccContext gMccContext;
+DUSK_GAME_DATA JHIMccContext gMccContext;
 
 BOOL JHIInit(u32 enabled) {
     gsEnableHostio = enabled;
diff --git a/libs/JSystem/src/JHostIO/JORServer.cpp b/libs/JSystem/src/JHostIO/JORServer.cpp
index 62086b259c..cabcf10bb3 100644
--- a/libs/JSystem/src/JHostIO/JORServer.cpp
+++ b/libs/JSystem/src/JHostIO/JORServer.cpp
@@ -113,7 +113,7 @@ void JORReflexible::listenPropertyEvent(const JORPropertyEvent* pEvent) {
 }
 #endif
 
-JORServer* JORServer::instance;
+DUSK_GAME_DATA JORServer* JORServer::instance;
 
 JORServer* JORServer::create() {
     if (instance == NULL) {
diff --git a/libs/JSystem/src/JKernel/JKRAram.cpp b/libs/JSystem/src/JKernel/JKRAram.cpp
index 2770328afa..98829765bc 100644
--- a/libs/JSystem/src/JKernel/JKRAram.cpp
+++ b/libs/JSystem/src/JKernel/JKRAram.cpp
@@ -27,7 +27,7 @@ static int JKRDecompressFromAramToMainRam(u32 src, void* dst, u32 srcLength, u32
                                           u32 offset, u32* resourceSize);
 int decompSZS_subroutine(u8* src, u8* dest);
 
-JKRAram* JKRAram::sAramObject;
+DUSK_GAME_DATA JKRAram* JKRAram::sAramObject;
 
 JKRAram* JKRAram::create(u32 aram_audio_buffer_size, u32 aram_audio_graph_size, s32 stream_priority,
                          s32 decomp_priority, s32 piece_priority) {
@@ -48,14 +48,14 @@ void JKRAram::destroy() {
 }
 #endif
 
-OSMessage JKRAram::sMessageBuffer[4] = {
+DUSK_GAME_DATA OSMessage JKRAram::sMessageBuffer[4] = {
     NULL,
     NULL,
     NULL,
     NULL,
 };
 
-OSMessageQueue JKRAram::sMessageQueue = {0};
+DUSK_GAME_DATA OSMessageQueue JKRAram::sMessageQueue = {0};
 
 JKRAram::JKRAram(u32 audio_buffer_size, u32 audio_graph_size, s32 priority)
     : JKRThread(stack_size, 0x10, priority) {
@@ -279,11 +279,11 @@ u8* JKRAram::aramToMainRam(u32 address, u8* buf, u32 p3, JKRExpandSwitch expandS
     }
 }
 
-JSUList<JKRAMCommand> JKRAram::sAramCommandList;
+DUSK_GAME_DATA JSUList<JKRAMCommand> JKRAram::sAramCommandList;
 
 static OSMutex decompMutex;
 
-u32 JKRAram::sSZSBufferSize = 0x00000400;
+DUSK_GAME_DATA u32 JKRAram::sSZSBufferSize = 0x00000400;
 
 static u8* szpBuf;
 
diff --git a/libs/JSystem/src/JKernel/JKRAramArchive.cpp b/libs/JSystem/src/JKernel/JKRAramArchive.cpp
index d6923ee06b..fcb54271e4 100644
--- a/libs/JSystem/src/JKernel/JKRAramArchive.cpp
+++ b/libs/JSystem/src/JKernel/JKRAramArchive.cpp
@@ -196,6 +196,13 @@ cleanup:
 
 void* JKRAramArchive::fetchResource(SDIFileEntry* pEntry, u32* pOutSize) {
     JUT_ASSERT(442, isMounted());
+
+#if TARGET_PC
+    if (void* data = getOverlayData(pEntry, pOutSize); data != nullptr) {
+        return data;
+    }
+#endif
+
     u32 outSize;
     u8* outBuf;
     if (pOutSize == NULL) {
@@ -231,6 +238,13 @@ void* JKRAramArchive::fetchResource(SDIFileEntry* pEntry, u32* pOutSize) {
 void* JKRAramArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* pEntry,
                                     u32* resourceSize) {
     JUT_ASSERT(515, isMounted());
+
+#if TARGET_PC
+    if (copyOverlayData(buffer, bufferSize, pEntry, resourceSize)) {
+        return buffer;
+    }
+#endif
+
     u32 size = pEntry->data_size;
     if (size > bufferSize) {
         size = bufferSize;
@@ -337,6 +351,12 @@ u32 JKRAramArchive::getExpandedResSize(const void* ptr) const {
         return this->getResSize(ptr);
     }
 
+#if TARGET_PC
+    if (u32 size; getOverlayResourceSize(ptr, &size)) {
+        return size;
+    }
+#endif
+
     JKRArchive::SDIFileEntry* entry = this->findPtrResource(ptr);
     if (entry == NULL) {
         return 0xFFFFFFFF;
diff --git a/libs/JSystem/src/JKernel/JKRAramHeap.cpp b/libs/JSystem/src/JKernel/JKRAramHeap.cpp
index 83e5cc9ac7..7b3406383b 100644
--- a/libs/JSystem/src/JKernel/JKRAramHeap.cpp
+++ b/libs/JSystem/src/JKernel/JKRAramHeap.cpp
@@ -6,7 +6,7 @@
 #include <climits>
 #include "os_report.h"
 
-JSUList<JKRAramBlock> JKRAramHeap::sAramList;
+DUSK_GAME_DATA JSUList<JKRAramBlock> JKRAramHeap::sAramList;
 
 JKRAramHeap::JKRAramHeap(u32 startAddress, u32 size) {
     OSInitMutex(&mMutex);
diff --git a/libs/JSystem/src/JKernel/JKRAramPiece.cpp b/libs/JSystem/src/JKernel/JKRAramPiece.cpp
index 0946275b83..bfbabfd478 100644
--- a/libs/JSystem/src/JKernel/JKRAramPiece.cpp
+++ b/libs/JSystem/src/JKernel/JKRAramPiece.cpp
@@ -23,12 +23,12 @@ void JKRAramPiece::sendCommand(JKRAMCommand* command) {
     startDMA(command);
 }
 
-JSUList<JKRAMCommand> JKRAramPiece::sAramPieceCommandList;
+DUSK_GAME_DATA JSUList<JKRAMCommand> JKRAramPiece::sAramPieceCommandList;
 
-OSMutex JKRAramPiece::mMutex;
+DUSK_GAME_DATA OSMutex JKRAramPiece::mMutex;
 
 #if DEBUG && TARGET_PC
-volatile u8 forceRead;
+DUSK_GAME_DATA volatile u8 forceRead;
 #endif
 
 JKRAMCommand* JKRAramPiece::orderAsync(int direction, uintptr_t source, uintptr_t destination, u32 length,
diff --git a/libs/JSystem/src/JKernel/JKRAramStream.cpp b/libs/JSystem/src/JKernel/JKRAramStream.cpp
index a30f23dfaa..548a044571 100644
--- a/libs/JSystem/src/JKernel/JKRAramStream.cpp
+++ b/libs/JSystem/src/JKernel/JKRAramStream.cpp
@@ -12,7 +12,7 @@ const u32 stack_size = 0xc00;
 const u32 stack_size = 0x4000;
 #endif
 
-JKRAramStream* JKRAramStream::sAramStreamObject;
+DUSK_GAME_DATA JKRAramStream* JKRAramStream::sAramStreamObject;
 
 JKRAramStream* JKRAramStream::create(s32 priority) {
     if (!sAramStreamObject) {
@@ -23,14 +23,14 @@ JKRAramStream* JKRAramStream::create(s32 priority) {
     return sAramStreamObject;
 }
 
-void* JKRAramStream::sMessageBuffer[4] = {
+DUSK_GAME_DATA void* JKRAramStream::sMessageBuffer[4] = {
     NULL,
     NULL,
     NULL,
     NULL,
 };
 
-OSMessageQueue JKRAramStream::sMessageQueue = {0};
+DUSK_GAME_DATA OSMessageQueue JKRAramStream::sMessageQueue = {0};
 
 JKRAramStream::JKRAramStream(s32 priority) : JKRThread(stack_size, 0x10, priority) {
     resume();
@@ -141,11 +141,11 @@ s32 JKRAramStream::writeToAram(JKRAramStreamCommand* command) {
     return writtenLength;
 }
 
-u8* JKRAramStream::transBuffer;
+DUSK_GAME_DATA u8* JKRAramStream::transBuffer;
 
-u32 JKRAramStream::transSize;
+DUSK_GAME_DATA u32 JKRAramStream::transSize;
 
-JKRHeap* JKRAramStream::transHeap;
+DUSK_GAME_DATA JKRHeap* JKRAramStream::transHeap;
 
 JKRAramStreamCommand* JKRAramStream::write_StreamToAram_Async(JSUFileInputStream* stream, u32 addr,
                                                               u32 size, u32 offset,
diff --git a/libs/JSystem/src/JKernel/JKRArchivePri.cpp b/libs/JSystem/src/JKernel/JKRArchivePri.cpp
index 9da4c2d1aa..f81082cc2f 100644
--- a/libs/JSystem/src/JKernel/JKRArchivePri.cpp
+++ b/libs/JSystem/src/JKernel/JKRArchivePri.cpp
@@ -7,9 +7,43 @@
 
 #if TARGET_PC
 #include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <limits>
+#include <ranges>
+#include <string_view>
+#include <borealis/log.hpp>
+#include "JSystem/JKernel/JKRDvdRipper.h"
+#if _WIN32
+#include <malloc.h>
 #endif
 
-u32 JKRArchive::sCurrentDirID;
+std::atomic<u64> JKRArchive::sArcOverlayGeneration{0};
+
+namespace {
+
+inline constexpr borealis::Log Log{"JKRArchivePri"};
+
+void* alloc_overlay_buffer(u32 size) {
+#if _WIN32
+    return _aligned_malloc(size, alignof(std::max_align_t));
+#else
+    return std::malloc(size);
+#endif
+}
+
+void free_overlay_buffer(void* data) {
+#if _WIN32
+    _aligned_free(data);
+#else
+    std::free(data);
+#endif
+}
+
+}  // namespace
+#endif
+
+DUSK_GAME_DATA u32 JKRArchive::sCurrentDirID;
 
 JKRArchive::JKRArchive() {
     mIsMounted = false;
@@ -42,6 +76,7 @@ JKRArchive::JKRArchive(s32 entryNumber, JKRArchive::EMountMode mountMode) {
 
 JKRArchive::~JKRArchive() {
 #if TARGET_PC
+    removeAllOverlayResources();
     if (mFileData != nullptr) {
         JKRHeap::getSystemHeap()->free(mFileData);
         mFileData = nullptr;
@@ -270,4 +305,246 @@ void JKRArchive::initFileDataPointers() {
         mFiles[i].index = i;
     }
 }
+
+void JKRArchive::notifyOverlayFilesChanged() {
+    sArcOverlayGeneration.fetch_add(1, std::memory_order_release);
+}
+
+bool JKRArchive::buildArcOverlaysPath() const {
+    if (mArcOverlaysPathResolved) {
+        return !mArcOverlaysPath.empty();
+    }
+    mArcOverlaysPathResolved = true;
+
+    if (mEntryNum < 0) {
+        return false;
+    }
+
+    char pathBuffer[1024];
+    if (!DVDConvertEntrynumToPath(mEntryNum, pathBuffer, sizeof(pathBuffer))) {
+        return false;
+    }
+
+    std::string path{pathBuffer};
+    constexpr std::string_view extension{".arc"};
+    if (path.size() < extension.size() ||
+        path.compare(path.size() - extension.size(), extension.size(), extension) != 0)
+    {
+        return false;
+    }
+    path.resize(path.size() - extension.size());
+    path.push_back('/');
+
+    mArcOverlaysPath = std::move(path);
+    return true;
+}
+
+void JKRArchive::buildIndexToPathMap(u32 dirIndex, const std::string& currentPath) const {
+    const SDIDirEntry& dir = mNodes[dirIndex];
+    for (int i = 0; i < dir.num_entries; i++) {
+        const SDIFileEntry& entry = mFiles[dir.first_file_index + i];
+        std::string entryName{&mStringTable[entry.getNameOffset()]};
+        if (entryName == "." || entryName == "..") {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            buildIndexToPathMap(entry.data_offset, currentPath + entryName + "/");
+        } else {
+            mIdxToPathMap[entry.index] = currentPath + entryName;
+        }
+    }
+}
+
+bool JKRArchive::getOverlayPath(SDIFileEntry* entry, std::string& path) const {
+    if (entry == nullptr || !buildArcOverlaysPath()) {
+        return false;
+    }
+
+    if (mIdxToPathMap.empty()) {
+        buildIndexToPathMap(0, std::string{&mStringTable[mNodes[0].name_offset]} + "/");
+    }
+
+    const auto pathIt = mIdxToPathMap.find(entry->index);
+    if (pathIt == mIdxToPathMap.end()) {
+        return false;
+    }
+
+    path = mArcOverlaysPath + pathIt->second;
+    return true;
+}
+
+void* JKRArchive::getActiveOverlayData(SDIFileEntry* entry, u32* outSize) const {
+    const auto activeIt = mActiveArcOverlayResources.find(entry->index);
+    if (activeIt == mActiveArcOverlayResources.end()) {
+        return nullptr;
+    }
+
+    const auto resourceIt = mArcOverlayResources.find(activeIt->second);
+    const u64 generation = sArcOverlayGeneration.load(std::memory_order_acquire);
+    if (resourceIt == mArcOverlayResources.end() || resourceIt->second.generation != generation) {
+        // Keep the allocation owned so raw pointers returned by earlier fetches remain valid.
+        mActiveArcOverlayResources.erase(activeIt);
+        return nullptr;
+    }
+
+    if (outSize != nullptr) {
+        *outSize = resourceIt->second.size;
+    }
+    return resourceIt->first;
+}
+
+void* JKRArchive::getOverlayData(SDIFileEntry* entry, u32* outSize) {
+    if (entry == nullptr) {
+        return nullptr;
+    }
+
+    if (void* data = getActiveOverlayData(entry, outSize)) {
+        return data;
+    }
+
+    std::string path;
+    if (!getOverlayPath(entry, path)) {
+        return nullptr;
+    }
+
+    constexpr u32 alignmentMask = 0x1f;
+    const u64 generation = sArcOverlayGeneration.load(std::memory_order_acquire);
+    DVDFileInfo fileInfo{};
+    if (!DVDOpen(path.c_str(), &fileInfo)) {
+        return nullptr;
+    }
+
+    const u32 logicalSize = fileInfo.length;
+    if (logicalSize > static_cast<u32>(std::numeric_limits<s32>::max()) - alignmentMask) {
+        DVDClose(&fileInfo);
+        return nullptr;
+    }
+
+    const u32 readSize = ALIGN_NEXT(logicalSize, 0x20);
+    const u32 allocationSize = readSize == 0 ? 1 : readSize;
+    void* data = alloc_overlay_buffer(allocationSize);
+    if (data == nullptr) {
+        DVDClose(&fileInfo);
+        return nullptr;
+    }
+
+    const s32 status = DVDReadPrio(&fileInfo, data, readSize, 0, 2);
+    DVDClose(&fileInfo);
+    if (status < DVD_RESULT_GOOD || static_cast<u32>(status) != logicalSize) {
+        free_overlay_buffer(data);
+        return nullptr;
+    }
+
+    mArcOverlayResources.emplace(data, ArcOverlayResource{
+                                           .entryIndex = entry->index,
+                                           .size = logicalSize,
+                                           .generation = generation,
+                                       });
+    mActiveArcOverlayResources[entry->index] = data;
+
+    if (outSize != nullptr) {
+        *outSize = logicalSize;
+    }
+    return data;
+}
+
+bool JKRArchive::copyOverlayData(void* buffer, u32 bufferSize, SDIFileEntry* entry, u32* outSize) {
+    u32 overlaySize;
+    const void* overlayData = getOverlayData(entry, &overlaySize);
+    if (overlayData == nullptr) {
+        return false;
+    }
+
+    if (overlaySize > bufferSize) {
+        std::string path;
+        getOverlayPath(entry, path);
+        Log.error("Overlay %s is %u bytes but the game reserved %u\n", path.c_str(), overlaySize,
+            bufferSize);
+        return false;
+    }
+    if (overlaySize != 0) {
+        memcpy(buffer, overlayData, overlaySize);
+    }
+    if (outSize != nullptr) {
+        *outSize = overlaySize;
+    }
+    return true;
+}
+
+bool JKRArchive::getOverlayResourceSize(const void* data, u32* outSize) const {
+    const auto resourceIt = mArcOverlayResources.find(const_cast<void*>(data));
+    if (resourceIt == mArcOverlayResources.end()) {
+        return false;
+    }
+
+    if (outSize != nullptr) {
+        *outSize = resourceIt->second.size;
+    }
+    return true;
+}
+
+bool JKRArchive::getOverlayFileSize(SDIFileEntry* entry, u32* outSize) const {
+    if (entry == nullptr) {
+        return false;
+    }
+
+    u32 activeSize;
+    if (getActiveOverlayData(entry, &activeSize) != nullptr) {
+        if (outSize != nullptr) {
+            *outSize = activeSize;
+        }
+        return true;
+    }
+
+    std::string path;
+    if (!getOverlayPath(entry, path)) {
+        return false;
+    }
+
+    DVDFileInfo fileInfo{};
+    if (!DVDOpen(path.c_str(), &fileInfo)) {
+        return false;
+    }
+
+    if (outSize != nullptr) {
+        *outSize = fileInfo.length;
+    }
+    DVDClose(&fileInfo);
+    return true;
+}
+
+u32 JKRArchive::getFileSize(SDIFileEntry* entry) const {
+    u32 size;
+    if (getOverlayFileSize(entry, &size)) {
+        return size;
+    }
+    return entry != nullptr ? entry->getSize() : 0;
+}
+
+bool JKRArchive::removeOverlayResource(void* resource, bool freeResource) {
+    const auto resourceIt = mArcOverlayResources.find(resource);
+    if (resourceIt == mArcOverlayResources.end()) {
+        return false;
+    }
+
+    const auto activeIt = mActiveArcOverlayResources.find(resourceIt->second.entryIndex);
+    if (activeIt != mActiveArcOverlayResources.end() && activeIt->second == resource) {
+        mActiveArcOverlayResources.erase(activeIt);
+    }
+
+    if (freeResource) {
+        free_overlay_buffer(resource);
+    }
+    mArcOverlayResources.erase(resourceIt);
+    return true;
+}
+
+void JKRArchive::removeAllOverlayResources() {
+    mActiveArcOverlayResources.clear();
+    for (const auto& key : mArcOverlayResources | std::views::keys) {
+        free_overlay_buffer(key);
+    }
+    mArcOverlayResources.clear();
+}
+
 #endif
diff --git a/libs/JSystem/src/JKernel/JKRArchivePub.cpp b/libs/JSystem/src/JKernel/JKRArchivePub.cpp
index 731a049457..97306c9033 100644
--- a/libs/JSystem/src/JKernel/JKRArchivePub.cpp
+++ b/libs/JSystem/src/JKernel/JKRArchivePub.cpp
@@ -246,6 +246,7 @@ u32 JKRArchive::readResource(void* buffer, u32 bufferSize, u16 id) {
 
 void JKRArchive::removeResourceAll() {
     if (mArcInfoBlock && mMountMode != MOUNT_MEM) {
+        IF_DUSK(removeAllOverlayResources();)
         SDIFileEntry* fileEntry = mFiles;
         for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
             if (JKAR_DATA(fileEntry)) {
@@ -259,6 +260,13 @@ void JKRArchive::removeResourceAll() {
 
 bool JKRArchive::removeResource(void* resource) {
     JUT_ASSERT(678, resource != NULL);
+
+#if TARGET_PC
+    if (removeOverlayResource(resource, true)) {
+        return true;
+    }
+#endif
+
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (fileEntry == NULL)
         return false;
@@ -270,6 +278,13 @@ bool JKRArchive::removeResource(void* resource) {
 
 bool JKRArchive::detachResource(void* resource) {
     JUT_ASSERT(707, resource != NULL);
+
+#if TARGET_PC
+    if (removeOverlayResource(resource, false)) {
+        return true;
+    }
+#endif
+
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (fileEntry == NULL)
         return false;
@@ -280,6 +295,13 @@ bool JKRArchive::detachResource(void* resource) {
 
 u32 JKRArchive::getResSize(const void* resource) const {
     JUT_ASSERT(732, resource != NULL);
+
+#if TARGET_PC
+    if (u32 size; getOverlayResourceSize(resource, &size)) {
+        return size;
+    }
+#endif
+    
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (fileEntry == NULL)
         return -1;
diff --git a/libs/JSystem/src/JKernel/JKRCompArchive.cpp b/libs/JSystem/src/JKernel/JKRCompArchive.cpp
index 716aaa2838..acac590ec0 100644
--- a/libs/JSystem/src/JKernel/JKRCompArchive.cpp
+++ b/libs/JSystem/src/JKernel/JKRCompArchive.cpp
@@ -226,6 +226,13 @@ bool JKRCompArchive::open(s32 entryNum) {
 
 void* JKRCompArchive::fetchResource(SDIFileEntry *fileEntry, u32 *pSize) {
     JUT_ASSERT(597, isMounted());
+
+#if TARGET_PC
+    if (void* data = getOverlayData(fileEntry, pSize); data != nullptr) {
+        return data;
+    }
+#endif
+
     u32 ptrSize;
     u32 size = fileEntry->data_size;
     int compression = JKRConvertAttrToCompressionType(u8(fileEntry->type_flags_and_name_offset >> 0x18));
@@ -274,6 +281,13 @@ void *JKRCompArchive::fetchResource(void *data, u32 compressedSize, SDIFileEntry
 {
     u32 size = 0;
     JUT_ASSERT(708, isMounted());
+
+#if TARGET_PC
+    if (copyOverlayData(data, compressedSize, fileEntry, pSize)) {
+        return data;
+    }
+#endif
+
     u32 fileSize = fileEntry->data_size;
     u32 alignedSize = ALIGN_NEXT(fileSize, 32);
     u32 fileFlag = fileEntry->type_flags_and_name_offset >> 0x18;
@@ -319,6 +333,7 @@ void *JKRCompArchive::fetchResource(void *data, u32 compressedSize, SDIFileEntry
 
 void JKRCompArchive::removeResourceAll() {
     if (mArcInfoBlock != NULL && mMountMode != MOUNT_MEM) {
+        IF_DUSK(removeAllOverlayResources();)
         SDIFileEntry* fileEntry = mFiles;
         for (int i = 0; i < mArcInfoBlock->num_file_entries; i++) {
             int tmp = fileEntry->type_flags_and_name_offset >> 0x18;
@@ -336,6 +351,12 @@ void JKRCompArchive::removeResourceAll() {
 }
 
 bool JKRCompArchive::removeResource(void* resource) {
+#if TARGET_PC
+    if (removeOverlayResource(resource, true)) {
+        return true;
+    }
+#endif
+
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (!fileEntry)
         return false;
@@ -356,6 +377,12 @@ u32 JKRCompArchive::getExpandedResSize(const void *resource) const
         return getResSize(resource);
     }
 
+#if TARGET_PC
+    if (u32 size; getOverlayResourceSize(resource, &size)) {
+        return size;
+    }
+#endif
+
     SDIFileEntry *fileEntry = findPtrResource(resource);
     if(!fileEntry) {
         return 0xffffffff;
diff --git a/libs/JSystem/src/JKernel/JKRDecomp.cpp b/libs/JSystem/src/JKernel/JKRDecomp.cpp
index a97edea0a3..2f8b9a68d7 100644
--- a/libs/JSystem/src/JKernel/JKRDecomp.cpp
+++ b/libs/JSystem/src/JKernel/JKRDecomp.cpp
@@ -10,7 +10,7 @@ const u32 stack_size = 0x800;
 const u32 stack_size = 0x4000;
 #endif
 
-JKRDecomp* JKRDecomp::sDecompObject;
+DUSK_GAME_DATA JKRDecomp* JKRDecomp::sDecompObject;
 
 JKRDecomp* JKRDecomp::create(s32 priority) {
     if (!sDecompObject) {
@@ -29,9 +29,9 @@ void JKRDecomp::destroy() {
 }
 #endif
 
-OSMessage JKRDecomp::sMessageBuffer[8] = {0};
+DUSK_GAME_DATA OSMessage JKRDecomp::sMessageBuffer[8] = {0};
 
-OSMessageQueue JKRDecomp::sMessageQueue = {0};
+DUSK_GAME_DATA OSMessageQueue JKRDecomp::sMessageQueue = {0};
 
 JKRDecomp::JKRDecomp(s32 priority) : JKRThread(stack_size, 0x10, priority) {
     resume();
diff --git a/libs/JSystem/src/JKernel/JKRDvdAramRipper.cpp b/libs/JSystem/src/JKernel/JKRDvdAramRipper.cpp
index 9472539e24..22f040b360 100644
--- a/libs/JSystem/src/JKernel/JKRDvdAramRipper.cpp
+++ b/libs/JSystem/src/JKernel/JKRDvdAramRipper.cpp
@@ -75,9 +75,9 @@ JKRADCommand* JKRDvdAramRipper::loadToAram_Async(JKRDvdFile* dvdFile, u32 addres
     return command;
 }
 
-JSUList<JKRADCommand> JKRDvdAramRipper::sDvdAramAsyncList;
+DUSK_GAME_DATA JSUList<JKRADCommand> JKRDvdAramRipper::sDvdAramAsyncList;
 
-bool JKRDvdAramRipper::errorRetry = true;
+DUSK_GAME_DATA bool JKRDvdAramRipper::errorRetry = true;
 
 JKRADCommand* JKRDvdAramRipper::callCommand_Async(JKRADCommand* command) {
     s32 compression;
@@ -228,7 +228,7 @@ JKRADCommand::~JKRADCommand() {
 
 static OSMutex decompMutex;
 
-u32 JKRDvdAramRipper::sSZSBufferSize = 0x00000400;
+DUSK_GAME_DATA u32 JKRDvdAramRipper::sSZSBufferSize = 0x00000400;
 
 static u8* szpBuf;
 
diff --git a/libs/JSystem/src/JKernel/JKRDvdArchive.cpp b/libs/JSystem/src/JKernel/JKRDvdArchive.cpp
index b82302c900..d599879f8f 100644
--- a/libs/JSystem/src/JKernel/JKRDvdArchive.cpp
+++ b/libs/JSystem/src/JKernel/JKRDvdArchive.cpp
@@ -147,6 +147,13 @@ cleanup:
 
 void* JKRDvdArchive::fetchResource(SDIFileEntry* fileEntry, u32* returnSize) {
     JUT_ASSERT(428, isMounted());
+
+#if TARGET_PC
+    if (void* data = getOverlayData(fileEntry, returnSize); data != nullptr) {
+        return data;
+    }
+#endif
+
     u32 tempReturnSize;
     if (returnSize == NULL) {
         returnSize = &tempReturnSize;
@@ -181,6 +188,13 @@ void* JKRDvdArchive::fetchResource(SDIFileEntry* fileEntry, u32* returnSize) {
 void* JKRDvdArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* fileEntry,
                                    u32* returnSize) {
     JUT_ASSERT(504, isMounted());
+
+#if TARGET_PC
+    if (copyOverlayData(buffer, bufferSize, fileEntry, returnSize)) {
+        return buffer;
+    }
+#endif
+
     u32 size = fileEntry->data_size;
     JKRCompression fileCompression = JKRConvertAttrToCompressionType(u8(fileEntry->type_flags_and_name_offset >> 24));
 
@@ -344,6 +358,12 @@ u32 JKRDvdArchive::getExpandedResSize(const void* resource) const {
         return getResSize(resource);
     }
 
+#if TARGET_PC
+    if (u32 size; getOverlayResourceSize(resource, &size)) {
+        return size;
+    }
+#endif
+
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (!fileEntry) {
         return -1;
diff --git a/libs/JSystem/src/JKernel/JKRDvdFile.cpp b/libs/JSystem/src/JKernel/JKRDvdFile.cpp
index face6c824b..83f7d4d333 100644
--- a/libs/JSystem/src/JKernel/JKRDvdFile.cpp
+++ b/libs/JSystem/src/JKernel/JKRDvdFile.cpp
@@ -5,7 +5,7 @@
 #include "JSystem/JUtility/JUTException.h"
 #include <stdint.h>
 
-JSUList<JKRDvdFile> JKRDvdFile::sDvdList;
+DUSK_GAME_DATA JSUList<JKRDvdFile> JKRDvdFile::sDvdList;
 
 JKRDvdFile::JKRDvdFile() : mDvdLink(this) {
     initiate();
diff --git a/libs/JSystem/src/JKernel/JKRDvdRipper.cpp b/libs/JSystem/src/JKernel/JKRDvdRipper.cpp
index ae65f42ba3..2c2d521b3a 100644
--- a/libs/JSystem/src/JKernel/JKRDvdRipper.cpp
+++ b/libs/JSystem/src/JKernel/JKRDvdRipper.cpp
@@ -44,7 +44,7 @@ void* JKRDvdRipper::loadToMainRAM(s32 entryNumber, u8* dst, JKRExpandSwitch expa
                          pCompression, param_8);
 }
 
-bool JKRDvdRipper::errorRetry = true;
+DUSK_GAME_DATA bool JKRDvdRipper::errorRetry = true;
 
 void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch expandSwitch,
                                   u32 dstLength, JKRHeap* heap,
@@ -236,13 +236,13 @@ void* JKRDvdRipper::loadToMainRAM(JKRDvdFile* dvdFile, u8* dst, JKRExpandSwitch
 
 static u8 lit_491[12];
 
-JSUList<JKRDMCommand> JKRDvdRipper::sDvdAsyncList;
+DUSK_GAME_DATA JSUList<JKRDMCommand> JKRDvdRipper::sDvdAsyncList;
 
 static OSMutex decompMutex;
 
-u32 JKRDvdRipper::sSZSBufferSize = 0x00000400;
+DUSK_GAME_DATA u32 JKRDvdRipper::sSZSBufferSize = 0x00000400;
 
-JKRHeap* JKRDvdRipper::sHeap = NULL;
+DUSK_GAME_DATA JKRHeap* JKRDvdRipper::sHeap = NULL;
 
 static u8* szpBuf;
 
diff --git a/libs/JSystem/src/JKernel/JKRFileCache.cpp b/libs/JSystem/src/JKernel/JKRFileCache.cpp
index 1a97ddefa3..a4795602c0 100644
--- a/libs/JSystem/src/JKernel/JKRFileCache.cpp
+++ b/libs/JSystem/src/JKernel/JKRFileCache.cpp
@@ -8,7 +8,7 @@
 
 #include <cctype>
 #include <cstring>
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 #include "global.h"
 
 JKRFileCache* JKRFileCache::mount(const char* path, JKRHeap* heap, const char* param_3) {
diff --git a/libs/JSystem/src/JKernel/JKRFileLoader.cpp b/libs/JSystem/src/JKernel/JKRFileLoader.cpp
index 4a7fa00d10..0ff00f5f84 100644
--- a/libs/JSystem/src/JKernel/JKRFileLoader.cpp
+++ b/libs/JSystem/src/JKernel/JKRFileLoader.cpp
@@ -8,11 +8,11 @@
 #include <cstring>
 #include <string>
 #include "JSystem/JKernel/JKRHeap.h"
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 #include "global.h"
 
-JKRFileLoader* JKRFileLoader::sCurrentVolume;
-JSUList<JKRFileLoader> JKRFileLoader::sVolumeList;
+DUSK_GAME_DATA JKRFileLoader* JKRFileLoader::sCurrentVolume;
+DUSK_GAME_DATA JSUList<JKRFileLoader> JKRFileLoader::sVolumeList;
 
 JKRFileLoader::JKRFileLoader(void)
     : mFileLoaderLink(this), mVolumeName(NULL), mVolumeType(0), mMountCount(0) {}
diff --git a/libs/JSystem/src/JKernel/JKRHeap.cpp b/libs/JSystem/src/JKernel/JKRHeap.cpp
index c4849437ac..3c329e0a43 100644
--- a/libs/JSystem/src/JKernel/JKRHeap.cpp
+++ b/libs/JSystem/src/JKernel/JKRHeap.cpp
@@ -15,7 +15,7 @@
 
 #include "JSystem/JUtility/JUTAssert.h"
 #include "JSystem/JUtility/JUTException.h"
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 #ifdef __MWERKS__
 #include <stdint.h>
 #else
@@ -28,14 +28,14 @@
 #include "os_report.h"
 
 #if DEBUG
-u8 JKRValue_DEBUGFILL_NOTUSE = 0xFD;
-u8 JKRValue_DEBUGFILL_NEW = 0xCD;
-u8 JKRValue_DEBUGFILL_DELETE = 0xDD;
+DUSK_GAME_DATA u8 JKRValue_DEBUGFILL_NOTUSE = 0xFD;
+DUSK_GAME_DATA u8 JKRValue_DEBUGFILL_NEW = 0xCD;
+DUSK_GAME_DATA u8 JKRValue_DEBUGFILL_DELETE = 0xDD;
 #endif
 
-bool JKRHeap::sDefaultFillFlag = true;
+DUSK_GAME_DATA bool JKRHeap::sDefaultFillFlag = true;
 
-JKRHeap* JKRHeap::sSystemHeap;
+DUSK_GAME_DATA JKRHeap* JKRHeap::sSystemHeap;
 
 #if TARGET_PC
 // JSystem normally has a thread switch callback to track the correct heap.
@@ -52,13 +52,13 @@ static thread_local TLS_GLOBAL_DYNAMIC JKRHeap* sCurrentHeap;
 JKRHeap* JKRHeap::sCurrentHeap;
 #endif
 
-JKRHeap* JKRHeap::sRootHeap;
+DUSK_GAME_DATA JKRHeap* JKRHeap::sRootHeap;
 
 #if PLATFORM_WII || PLATFORM_SHIELD
 JKRHeap* JKRHeap::sRootHeap2;
 #endif
 
-JKRErrorHandler JKRHeap::mErrorHandler;
+DUSK_GAME_DATA JKRErrorHandler JKRHeap::mErrorHandler;
 
 static bool data_80451380;
 
@@ -111,19 +111,19 @@ JKRHeap::~JKRHeap() {
     }
 }
 
-void* JKRHeap::mCodeStart;
+DUSK_GAME_DATA void* JKRHeap::mCodeStart;
 
-void* JKRHeap::mCodeEnd;
+DUSK_GAME_DATA void* JKRHeap::mCodeEnd;
 
-void* JKRHeap::mUserRamStart;
+DUSK_GAME_DATA void* JKRHeap::mUserRamStart;
 
-void* JKRHeap::mUserRamEnd;
+DUSK_GAME_DATA void* JKRHeap::mUserRamEnd;
 
-u32 JKRHeap::mMemorySize;
+DUSK_GAME_DATA u32 JKRHeap::mMemorySize;
 
-JKRHeap::JKRAllocCallback JKRHeap::sAllocCallback;
+DUSK_GAME_DATA JKRHeap::JKRAllocCallback JKRHeap::sAllocCallback;
 
-JKRHeap::JKRFreeCallback JKRHeap::sFreeCallback;
+DUSK_GAME_DATA JKRHeap::JKRFreeCallback JKRHeap::sFreeCallback;
 
 bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
     void* arenaLo = OSGetArenaLo();
@@ -661,8 +661,8 @@ void operator delete[](void* ptr JKR_HEAP_TOKEN_PARAM) IF_DUSK(noexcept) {
 }
 #endif
 
-s32 fillcheck_dispcount = 100;
-bool data_8074A8D0_debug = true;
+DUSK_GAME_DATA s32 fillcheck_dispcount = 100;
+DUSK_GAME_DATA bool data_8074A8D0_debug = true;
 
 void JKRHeap::state_register(JKRHeap::TState* p, u32 id) const {
     JUT_ASSERT(1213, p != NULL);
@@ -680,7 +680,7 @@ void JKRHeap::state_dump(const JKRHeap::TState& p) const {
     JUT_LOG(1248, "used size  : %u", p.getUsedSize());
 }
 
-void* ARALT_AramStartAdr = (void*)0x90000000;
+DUSK_GAME_DATA void* ARALT_AramStartAdr = (void*)0x90000000;
 
 void* JKRHeap::getAltAramStartAdr() { return ARALT_AramStartAdr; }
 
@@ -702,7 +702,7 @@ JKRHeap* JKRHeap::getCurrentHeap() {
 }
 
 void JKRHeap::setName(const char* name) {
-    dusk::SafeStringCopyTruncate(mName, name);
+    SafeStringCopyTruncate(mName, name);
 }
 
 void JKRHeap::setNamef(const char* fmt, ...) {
diff --git a/libs/JSystem/src/JKernel/JKRMemArchive.cpp b/libs/JSystem/src/JKernel/JKRMemArchive.cpp
index d3b17d8a63..f0feabe3be 100644
--- a/libs/JSystem/src/JKernel/JKRMemArchive.cpp
+++ b/libs/JSystem/src/JKernel/JKRMemArchive.cpp
@@ -135,6 +135,13 @@ bool JKRMemArchive::open(void* buffer, u32 bufferSize, JKRMemBreakFlag flag) {
 
 void* JKRMemArchive::fetchResource(SDIFileEntry* fileEntry, u32* resourceSize) {
     JUT_ASSERT(555, isMounted());
+
+#if TARGET_PC
+    if (void* data = getOverlayData(fileEntry, resourceSize); data != nullptr) {
+        return data;
+    }
+#endif
+
     if (!JKAR_DATA(fileEntry)) {
         JKAR_DATA(fileEntry) = mArchiveData + fileEntry->data_offset;
     }
@@ -149,6 +156,13 @@ void* JKRMemArchive::fetchResource(SDIFileEntry* fileEntry, u32* resourceSize) {
 void* JKRMemArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* fileEntry,
                                    u32* resourceSize) {
     JUT_ASSERT(595, isMounted());
+
+#if TARGET_PC
+    if (copyOverlayData(buffer, bufferSize, fileEntry, resourceSize)) {
+        return buffer;
+    }
+#endif
+
     u32 srcLength = fileEntry->data_size;
     if (srcLength > bufferSize) {
         srcLength = bufferSize;
@@ -173,6 +187,8 @@ void* JKRMemArchive::fetchResource(void* buffer, u32 bufferSize, SDIFileEntry* f
 void JKRMemArchive::removeResourceAll(void) {
     JUT_ASSERT(642, isMounted());
 
+    IF_DUSK(removeAllOverlayResources();)
+
     if (mArcInfoBlock == NULL)
         return;
     if (mMountMode == MOUNT_MEM)
@@ -192,6 +208,12 @@ void JKRMemArchive::removeResourceAll(void) {
 bool JKRMemArchive::removeResource(void* resource) {
     JUT_ASSERT(673, isMounted());
 
+#if TARGET_PC
+    if (removeOverlayResource(resource, true)) {
+        return true;
+    }
+#endif
+
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (!fileEntry)
         return false;
@@ -231,6 +253,12 @@ u32 JKRMemArchive::fetchResource_subroutine(u8* src, u32 srcLength, u8* dst, u32
 }
 
 u32 JKRMemArchive::getExpandedResSize(const void* resource) const {
+#if TARGET_PC
+    if (u32 overlaySize; getOverlayResourceSize(resource, &overlaySize)) {
+        return overlaySize;
+    }
+#endif
+
     SDIFileEntry* fileEntry = findPtrResource(resource);
     if (fileEntry == NULL)
         return -1;
diff --git a/libs/JSystem/src/JKernel/JKRThread.cpp b/libs/JSystem/src/JKernel/JKRThread.cpp
index 8c945aba32..73135381eb 100644
--- a/libs/JSystem/src/JKernel/JKRThread.cpp
+++ b/libs/JSystem/src/JKernel/JKRThread.cpp
@@ -7,25 +7,25 @@
 #include "global.h"
 #include <stdint.h>
 
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 
 #if TARGET_PC
 #include "dusk/os.h"
 #endif
 
-JSUList<JKRThread> JKRThread::sThreadList(0);
+DUSK_GAME_DATA JSUList<JKRThread> JKRThread::sThreadList(0);
 
-void* JKRIdleThread::sThread;
+DUSK_GAME_DATA void* JKRIdleThread::sThread;
 
-JKRThreadSwitch* JKRThreadSwitch::sManager;
+DUSK_GAME_DATA JKRThreadSwitch* JKRThreadSwitch::sManager;
 
-u32 JKRThreadSwitch::sTotalCount;
+DUSK_GAME_DATA u32 JKRThreadSwitch::sTotalCount;
 
-u64 JKRThreadSwitch::sTotalStart;
+DUSK_GAME_DATA u64 JKRThreadSwitch::sTotalStart;
 
-JKRThreadSwitch_PreCallback JKRThreadSwitch::mUserPreCallback;
+DUSK_GAME_DATA JKRThreadSwitch_PreCallback JKRThreadSwitch::mUserPreCallback;
 
-JKRThreadSwitch_PostCallback JKRThreadSwitch::mUserPostCallback;
+DUSK_GAME_DATA JKRThreadSwitch_PostCallback JKRThreadSwitch::mUserPostCallback;
 
 JKRThread::JKRThread(u32 stack_size, int message_count, int param_3) : mThreadListLink(this) {
     JKRHeap* heap = JKRHeap::findFromRoot(this);
@@ -358,10 +358,10 @@ static void dummy(JKRIdleThread* thread) {
 
 #pragma push
 #pragma force_active on
-JSUList<JKRTask> JKRTask::sTaskList;
+DUSK_GAME_DATA JSUList<JKRTask> JKRTask::sTaskList;
 #pragma pop
 
 #pragma push
 #pragma force_active on
-u8 JKRTask::sEndMesgQueue[32];
+DUSK_GAME_DATA u8 JKRTask::sEndMesgQueue[32];
 #pragma pop
diff --git a/libs/JSystem/src/JMath/JMATrigonometric.cpp b/libs/JSystem/src/JMath/JMATrigonometric.cpp
index 5d394ac9c2..cc8ce129e6 100644
--- a/libs/JSystem/src/JMath/JMATrigonometric.cpp
+++ b/libs/JSystem/src/JMath/JMATrigonometric.cpp
@@ -16,10 +16,10 @@ inline f64 getConst2() {
     return 9.765625E-4;
 }
 
-TSinCosTable<13, f32> sincosTable_ ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) DUSK_GAME_DATA TSinCosTable<13, f32> sincosTable_;
 
-TAtanTable<1024, f32> atanTable_ ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) DUSK_GAME_DATA TAtanTable<1024, f32> atanTable_;
 
-TAsinAcosTable<1024, f32> asinAcosTable_ ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) DUSK_GAME_DATA TAsinAcosTable<1024, f32> asinAcosTable_;
 
 }  // namespace JMath
diff --git a/libs/JSystem/src/JMessage/control.cpp b/libs/JSystem/src/JMessage/control.cpp
index acd5387f77..e739d2f672 100644
--- a/libs/JSystem/src/JMessage/control.cpp
+++ b/libs/JSystem/src/JMessage/control.cpp
@@ -7,6 +7,10 @@
 
 #include "JSystem/JMessage/control.h"
 
+#if TARGET_PC
+#include "dusk/mods/svc/flow.hpp"
+#endif
+
 JMessage::TControl::TControl()
     : pSequenceProcessor_(NULL),
       pRenderingProcessor_(NULL),
@@ -19,9 +23,16 @@ JMessage::TControl::TControl()
       pMessageText_current_(NULL)
       {}
 
-JMessage::TControl::~TControl() {}
+JMessage::TControl::~TControl() {
+#if TARGET_PC
+    dusk::flow::release_message_control(this);
+#endif
+}
 
 void JMessage::TControl::reset() {
+#if TARGET_PC
+    dusk::flow::release_message_control(this);
+#endif
     pEntry_ = NULL;
     pMessageText_begin_ = NULL;
     pszText_update_current_ = NULL;
@@ -78,18 +89,57 @@ int JMessage::TControl::setMessageID(u32 uMsgID, u32 param_1, bool* pbValid) {
 }
 
 bool JMessage::TControl::setMessageCode_inSequence_(JMessage::TProcessor const* pProcessor, u16 u16GroupID, u16 u16Index) {
+#if TARGET_PC
+    const TResource* resource = NULL;
+    const void* resolvedEntry = NULL;
+    const char* resolvedText = NULL;
+    if (u16Index >= dusk::flow::kCustomMessageMin) {
+        if (!dusk::flow::custom_message_for_processor(
+                this, pProcessor, u16Index, resource, resolvedEntry, resolvedText))
+        {
+            return false;
+        }
+        const_cast<TProcessor*>(pProcessor)->setResourceCache(const_cast<TResource*>(resource));
+    } else {
+        resource = pProcessor->getResource_groupID(u16GroupID);
+        if (resource == NULL) {
+            return false;
+        }
+        const void* nativeEntry = resource->getMessageEntry_messageIndex(u16Index);
+        const char* nativeText =
+            nativeEntry != NULL ? resource->getMessageText_messageEntry(nativeEntry) : NULL;
+        resolvedEntry = nativeEntry;
+        resolvedText = nativeText;
+        dusk::flow::resolve_message_for_control(this, resource->oParse_THeader_.getRaw(), u16Index,
+            nativeEntry, nativeText, resolvedEntry, resolvedText);
+    }
+    pEntry_ = const_cast<void*>(resolvedEntry);
+    if (pEntry_ == NULL || resolvedText == NULL) {
+        return false;
+    }
+#else
     pEntry_ = pProcessor->getMessageEntry_messageCode(u16GroupID, u16Index);
     if (pEntry_ == NULL) {
         return false;
     }
+#endif
 
+#if TARGET_PC
+    uMessageGroupID_ = resource->getGroupID();
+    pResourceCache_ = resource;
+#else
     uMessageGroupID_ = u16GroupID;
-    uMessageID_ = u16Index;
-    
     pResourceCache_ = pProcessor->getResourceCache();
+#endif
+    uMessageID_ = u16Index;
+
     JUT_ASSERT(155, pResourceCache_!=NULL);
 
+#if TARGET_PC
+    pMessageText_begin_ = resolvedText;
+#else
     pMessageText_begin_ = pResourceCache_->getMessageText_messageEntry(pEntry_);
+#endif
     pMessageText_current_ = pMessageText_begin_;
     oStack_renderingProcessor_.clear();
     return true;
diff --git a/libs/JSystem/src/JMessage/data.cpp b/libs/JSystem/src/JMessage/data.cpp
index 29c96c18c7..4ff9919594 100644
--- a/libs/JSystem/src/JMessage/data.cpp
+++ b/libs/JSystem/src/JMessage/data.cpp
@@ -2,6 +2,6 @@
 
 #include "JSystem/JMessage/data.h"
 
-const BE(u32) JMessage::data::ga4cSignature = 'MESG';
+DUSK_GAME_DATA const BE(u32) JMessage::data::ga4cSignature = 'MESG';
 
-const BE(u32) JMessage::data::ga4cSignature_color = 'MGCL';
+DUSK_GAME_DATA const BE(u32) JMessage::data::ga4cSignature_color = 'MGCL';
diff --git a/libs/JSystem/src/JMessage/processor.cpp b/libs/JSystem/src/JMessage/processor.cpp
index eef50e7516..08b0af0b7a 100644
--- a/libs/JSystem/src/JMessage/processor.cpp
+++ b/libs/JSystem/src/JMessage/processor.cpp
@@ -5,15 +5,26 @@
 #include "JSystem/JUtility/JUTAssert.h"
 #include <cstdint>
 
+#if TARGET_PC
+#include "dusk/mods/svc/flow.hpp"
+#endif
+
 JMessage::TReference::~TReference() {}
 
 const char* JMessage::TReference::do_word(u32 param_0) const {
     return NULL;
 }
 
-JMessage::TProcessor::~TProcessor() {}
+JMessage::TProcessor::~TProcessor() {
+#if TARGET_PC
+    dusk::flow::release_message_processor(this);
+#endif
+}
 
 void JMessage::TProcessor::reset() {
+#if TARGET_PC
+    dusk::flow::release_message_processor(this);
+#endif
     on_resetStatus_(NULL);
     do_reset();
 }
@@ -44,6 +55,15 @@ const JMessage::TResource* JMessage::TProcessor::getResource_groupID(u16 u16Grou
 }
 
 u32 JMessage::TProcessor::toMessageCode_messageID(u32 uMsgID, u32 param_1, bool* pbValid) const {
+#if TARGET_PC
+    u32 customCode = 0;
+    if (dusk::flow::message_code_for_id(this, uMsgID, customCode)) {
+        if (pbValid != NULL) {
+            *pbValid = true;
+        }
+        return customCode;
+    }
+#endif
     const TResource* pResourceCache = (const TResource*)getResourceCache();
     if (pResourceCache != NULL) {
         u16 u16Index = pResourceCache->toMessageIndex_messageID(uMsgID, param_1, pbValid);
@@ -73,6 +93,74 @@ u32 JMessage::TProcessor::toMessageCode_messageID(u32 uMsgID, u32 param_1, bool*
     return 0xFFFFFFFF;
 }
 
+#if TARGET_PC
+void* JMessage::TProcessor::getMessageEntry_messageCode(u16 groupId, u16 index) const {
+    if (index >= dusk::flow::kCustomMessageMin) {
+        const TResource* customResource = NULL;
+        const void* customEntry = NULL;
+        const char* customText = NULL;
+        if (!dusk::flow::custom_message_for_processor(
+                NULL, this, index, customResource, customEntry, customText))
+        {
+            return NULL;
+        }
+        const_cast<TProcessor*>(this)->setResourceCache(const_cast<TResource*>(customResource));
+        return const_cast<void*>(customEntry);
+    }
+    const TResource* resource = getResource_groupID(groupId);
+    if (resource == NULL) {
+        return NULL;
+    }
+    void* nativeEntry = resource->getMessageEntry_messageIndex(index);
+    const char* nativeText =
+        nativeEntry != NULL ? resource->getMessageText_messageEntry(nativeEntry) : NULL;
+    const void* resolvedEntry = nativeEntry;
+    const char* resolvedText = nativeText;
+    dusk::flow::resolve_message(this, resource->oParse_THeader_.getRaw(), index, nativeEntry,
+        nativeText, resolvedEntry, resolvedText);
+    return const_cast<void*>(resolvedEntry);
+}
+
+const char* JMessage::TProcessor::getMessageText_messageCode(u16 groupId, u16 index) const {
+    if (index >= dusk::flow::kCustomMessageMin) {
+        const TResource* customResource = NULL;
+        const void* customEntry = NULL;
+        const char* customText = NULL;
+        if (!dusk::flow::custom_message_for_processor(
+                NULL, this, index, customResource, customEntry, customText))
+        {
+            return NULL;
+        }
+        const_cast<TProcessor*>(this)->setResourceCache(const_cast<TResource*>(customResource));
+        return customText;
+    }
+    const TResource* resource = getResource_groupID(groupId);
+    if (resource == NULL) {
+        return NULL;
+    }
+    const void* nativeEntry = resource->getMessageEntry_messageIndex(index);
+    const char* nativeText =
+        nativeEntry != NULL ? resource->getMessageText_messageEntry(nativeEntry) : NULL;
+    const void* resolvedEntry = nativeEntry;
+    const char* resolvedText = nativeText;
+    dusk::flow::resolve_message(this, resource->oParse_THeader_.getRaw(), index, nativeEntry,
+        nativeText, resolvedEntry, resolvedText);
+    return resolvedText;
+}
+
+const char* JMessage::TProcessor::on_message_limited(u16 index) const {
+    JUT_ASSERT(482, pResourceCache_!=NULL);
+    const void* nativeEntry = pResourceCache_->getMessageEntry_messageIndex(index);
+    const char* nativeText =
+        nativeEntry != NULL ? pResourceCache_->getMessageText_messageEntry(nativeEntry) : NULL;
+    const void* resolvedEntry = nativeEntry;
+    const char* resolvedText = nativeText;
+    dusk::flow::resolve_message(this, pResourceCache_->oParse_THeader_.getRaw(), index,
+        nativeEntry, nativeText, resolvedEntry, resolvedText);
+    return resolvedText;
+}
+#endif
+
 void JMessage::TProcessor::on_select_begin(char const* (*pfn)(JMessage::TProcessor*),
                                            void const* pOffset, char const* pcBase, u32 uNumber) {
     JUT_ASSERT(191, uNumber>0);
diff --git a/libs/JSystem/src/JMessage/resource.cpp b/libs/JSystem/src/JMessage/resource.cpp
index 4e48701c11..fc8d011af7 100644
--- a/libs/JSystem/src/JMessage/resource.cpp
+++ b/libs/JSystem/src/JMessage/resource.cpp
@@ -89,7 +89,7 @@ u16 JMessage::TResource::toMessageIndex_messageID(u32 uMsgID, u32 upperHalf, boo
     return nIndex;
 }
 
-JMessage::locale::parseCharacter_function JMessage::TResourceContainer::sapfnParseCharacter_[5] = {
+DUSK_GAME_DATA JMessage::locale::parseCharacter_function JMessage::TResourceContainer::sapfnParseCharacter_[5] = {
     NULL,
     JMessage::locale::parseCharacter_1Byte,
     JMessage::locale::parseCharacter_2Byte,
diff --git a/libs/JSystem/src/JParticle/JPABaseShape.cpp b/libs/JSystem/src/JParticle/JPABaseShape.cpp
index a569d96842..bebf947fec 100644
--- a/libs/JSystem/src/JParticle/JPABaseShape.cpp
+++ b/libs/JSystem/src/JParticle/JPABaseShape.cpp
@@ -10,9 +10,10 @@
 #include <gx.h>
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
+
+#include <tracy/Tracy.hpp>
 #endif
-#include "tracy/Tracy.hpp"
 
 #if TARGET_PC
 #define JPA_DRAW_CTX_PARAM , ParticleDrawCtx* ctx
@@ -551,7 +552,7 @@ static void submit_particle_quad(
 void JPAInterpBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
     Mtx ptclPosMtx;
     MTXTrans(ptclPosMtx, ptcl->mPosition.x, ptcl->mPosition.y, ptcl->mPosition.z);
-    dusk::frame_interp::record_final_mtx(ptclPosMtx, ptcl);
+    dusk::interp::record_final_mtx(ptclPosMtx, ptcl);
 }
 
 void JPAInterpRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
@@ -563,7 +564,7 @@ void JPAInterpRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
     ptclPosMtx[0][1] = -sinRot;
     ptclPosMtx[1][0] = sinRot;
     ptclPosMtx[1][1] = cosRot;
-    dusk::frame_interp::record_final_mtx(ptclPosMtx, ptcl);
+    dusk::interp::record_final_mtx(ptclPosMtx, ptcl);
 }
 #endif
 
@@ -576,7 +577,7 @@ void JPADrawBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl JPA_DRAW_C
     JGeometry::TVec3<f32> pos;
 #if TARGET_PC
     Mtx ptclPosMtx;
-    if (dusk::frame_interp::lookup_replacement(ptcl, ptclPosMtx)) {
+    if (dusk::interp::lookup_replacement(ptcl, ptclPosMtx)) {
         pos.set(ptclPosMtx[0][3], ptclPosMtx[1][3], ptclPosMtx[2][3]);
         MTXMultVec(work->mPosCamMtx, &pos, &pos);
     } else
@@ -616,7 +617,7 @@ void JPADrawRotBillboard(JPAEmitterWorkData* work, JPABaseParticle* ptcl JPA_DRA
 #if TARGET_PC
     Mtx ptclPosMtx;
     MTXTrans(ptclPosMtx, ptcl->mPosition.x, ptcl->mPosition.y, ptcl->mPosition.z);
-    if (dusk::frame_interp::lookup_replacement(ptcl, ptclPosMtx)) {
+    if (dusk::interp::lookup_replacement(ptcl, ptclPosMtx)) {
         pos.set(ptclPosMtx[0][3], ptclPosMtx[1][3], ptclPosMtx[2][3]);
         sinRot = ptclPosMtx[1][0];
         cosRot = ptclPosMtx[0][0];
@@ -993,7 +994,7 @@ void JPAInterpDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
     posMtx[2][2] = axisZ.z;
     posMtx[2][3] = ptcl->mPosition.z;
     p_plane[work->mPlaneType](posMtx, scaleX, scaleY);
-    dusk::frame_interp::record_final_mtx(posMtx, ptcl);
+    dusk::interp::record_final_mtx(posMtx, ptcl);
 }
 
 void JPAInterpRotDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
@@ -1036,7 +1037,7 @@ void JPAInterpRotDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl) {
     mtx2[2][2] = axisZ.z;
     mtx2[2][3] = ptcl->mPosition.z;
     MTXConcat(mtx2, mtx1, mtx1);
-    dusk::frame_interp::record_final_mtx(mtx1, ptcl);
+    dusk::interp::record_final_mtx(mtx1, ptcl);
 }
 #endif
 
@@ -1049,7 +1050,7 @@ void JPADrawDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl JPA_DRAW_C
 
     Mtx posMtx;
 #if TARGET_PC
-    if (!dusk::frame_interp::lookup_replacement(ptcl, posMtx) &&
+    if (!dusk::interp::lookup_replacement(ptcl, posMtx) &&
         !make_direction_mtx(work, ptcl, posMtx))
     {
         return;
@@ -1112,7 +1113,7 @@ void JPADrawRotDirection(JPAEmitterWorkData* work, JPABaseParticle* ptcl JPA_DRA
     Mtx mtx1;
     Mtx mtx2;
 #if TARGET_PC
-    if (!dusk::frame_interp::lookup_replacement(ptcl, mtx1) &&
+    if (!dusk::interp::lookup_replacement(ptcl, mtx1) &&
         !make_rot_direction_mtx(work, ptcl, mtx1))
     {
         return;
@@ -1580,36 +1581,36 @@ static void makeColorTable(GXColor** o_color_table, JPAClrAnmKeyData const* i_da
     *o_color_table = p_clr_tbl;
 }
 
-GXBlendMode JPABaseShape::st_bm[3] = {
+DUSK_GAME_DATA GXBlendMode JPABaseShape::st_bm[3] = {
     GX_BM_NONE,
     GX_BM_BLEND,
     GX_BM_LOGIC,
 };
 
-GXBlendFactor JPABaseShape::st_bf[10] = {
+DUSK_GAME_DATA GXBlendFactor JPABaseShape::st_bf[10] = {
     GX_BL_ZERO,      GX_BL_ONE,           GX_BL_SRCCLR, GX_BL_INVSRCCLR,
     GX_BL_DSTCLR, GX_BL_INVDSTCLR, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,
     GX_BL_DSTALPHA, GX_BL_INVDSTALPHA,
 };
 
-GXLogicOp JPABaseShape::st_lo[16] = {
+DUSK_GAME_DATA GXLogicOp JPABaseShape::st_lo[16] = {
     GX_LO_CLEAR,   GX_LO_SET,     GX_LO_COPY,   GX_LO_INVCOPY, GX_LO_NOOP, GX_LO_INV,
     GX_LO_AND,     GX_LO_NAND,    GX_LO_OR,     GX_LO_NOR,      GX_LO_XOR,  GX_LO_EQUIV,
     GX_LO_REVAND, GX_LO_INVAND, GX_LO_REVOR, GX_LO_INVOR,
 };
 
-GXCompare JPABaseShape::st_c[8] = {
+DUSK_GAME_DATA GXCompare JPABaseShape::st_c[8] = {
     GX_NEVER, GX_LESS, GX_LEQUAL, GX_EQUAL, GX_NEQUAL, GX_GEQUAL, GX_GREATER, GX_ALWAYS,
 };
 
-GXAlphaOp JPABaseShape::st_ao[4] = {
+DUSK_GAME_DATA GXAlphaOp JPABaseShape::st_ao[4] = {
     GX_AOP_AND,
     GX_AOP_OR,
     GX_AOP_XOR,
     GX_AOP_XNOR,
 };
 
-GXTevColorArg JPABaseShape::st_ca[6][4] = {
+DUSK_GAME_DATA GXTevColorArg JPABaseShape::st_ca[6][4] = {
     {
         GX_CC_ZERO,
         GX_CC_TEXC,
@@ -1648,7 +1649,7 @@ GXTevColorArg JPABaseShape::st_ca[6][4] = {
     },
 };
 
-GXTevAlphaArg JPABaseShape::st_aa[2][4] = {
+DUSK_GAME_DATA GXTevAlphaArg JPABaseShape::st_aa[2][4] = {
     {
         GX_CA_ZERO,
         GX_CA_TEXA,
diff --git a/libs/JSystem/src/JParticle/JPAEmitterManager.cpp b/libs/JSystem/src/JParticle/JPAEmitterManager.cpp
index 3a793000ed..0dcaa3b8b5 100644
--- a/libs/JSystem/src/JParticle/JPAEmitterManager.cpp
+++ b/libs/JSystem/src/JParticle/JPAEmitterManager.cpp
@@ -8,7 +8,9 @@
 #include "JSystem/JUtility/JUTAssert.h"
 #include <gx.h>
 
+#if TARGET_PC
 #include "tracy/Tracy.hpp"
+#endif
 
 JPAEmitterManager::JPAEmitterManager(u32 i_ptclNum, u32 i_emtrNum, JKRHeap* pHeap, u8 i_gidMax,
                                      u8 i_ridMax) {
diff --git a/libs/JSystem/src/JParticle/JPAParticle.cpp b/libs/JSystem/src/JParticle/JPAParticle.cpp
index eb2395e346..0bb03d607a 100644
--- a/libs/JSystem/src/JParticle/JPAParticle.cpp
+++ b/libs/JSystem/src/JParticle/JPAParticle.cpp
@@ -7,6 +7,10 @@
 #include "JSystem/JParticle/JPAEmitterManager.h"
 #include "JSystem/JParticle/JPAExtraShape.h"
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 JPAParticleCallBack::~JPAParticleCallBack() {
     /* empty function */
 }
@@ -206,7 +210,7 @@ void JPABaseParticle::init_c(JPAEmitterWorkData* work, JPABaseParticle* parent)
 
 #if TARGET_PC
 void JPABaseParticle::interp(JPAEmitterWorkData* work, void const* drawFunc) {
-    if (!dusk::frame_interp::is_enabled())
+    if (!dusk::interp::is_enabled())
         return;
 
     // don't interpolate the first frame
diff --git a/libs/JSystem/src/JParticle/JPAResource.cpp b/libs/JSystem/src/JParticle/JPAResource.cpp
index 2d5d872bac..8a4d931e16 100644
--- a/libs/JSystem/src/JParticle/JPAResource.cpp
+++ b/libs/JSystem/src/JParticle/JPAResource.cpp
@@ -1,10 +1,6 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
 
 #include "JSystem/JParticle/JPAResource.h"
-
-#include <cstring>
-
-#include <gx.h>
 #include "JSystem/JKernel/JKRHeap.h"
 #include "JSystem/JParticle/JPABaseShape.h"
 #include "JSystem/JParticle/JPAChildShape.h"
@@ -15,10 +11,14 @@
 #include "JSystem/JParticle/JPAKeyBlock.h"
 #include "JSystem/JParticle/JPAParticle.h"
 #include "JSystem/JParticle/JPAResourceManager.h"
+#include <gx.h>
 #include "global.h"
-#include "tracy/Tracy.hpp"
 
 #if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+
+#include <tracy/Tracy.hpp>
+
 #define JPA_DRAW_CTX_ARG , &ctx
 #else
 #define JPA_DRAW_CTX_ARG
@@ -44,7 +44,7 @@ JPAResource::JPAResource() {
     mUsrIdx = fldNum = keyNum = texNum = mpCalcEmitterFuncListNum = mpDrawEmitterFuncListNum = mpDrawEmitterChildFuncListNum = mpCalcParticleFuncListNum = mpDrawParticleFuncListNum = mpCalcParticleChildFuncListNum = mpDrawParticleChildFuncListNum = 0;
 }
 
-static u8 jpa_pos[324] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 jpa_pos[324] = {
     0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x32, 0xCE, 0x00, 0x00, 0xCE, 0x00, 0xE7, 0x00, 0x00, 0x19,
     0x00, 0x00, 0x19, 0xCE, 0x00, 0xE7, 0xCE, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xCE,
     0x00, 0xCE, 0xCE, 0x00, 0x00, 0x19, 0x00, 0x32, 0x19, 0x00, 0x32, 0xE7, 0x00, 0x00, 0xE7, 0x00,
@@ -68,7 +68,7 @@ static u8 jpa_pos[324] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0xCE,
 };
 
-static u8 jpa_crd[32] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 jpa_crd[32] = {
     0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x00, 0x02, 0x01, 0x00, 0x01,
     0x00, 0x00, 0x01, 0x00, 0x01, 0x02, 0x00, 0x02, 0x00, 0x00, 0x02, 0x00, 0x02, 0x02, 0x00, 0x02,
 };
@@ -839,7 +839,7 @@ bool JPAResource::calc(JPAEmitterWorkData* work, JPABaseEmitter* emtr) {
 
 #ifdef TARGET_PC
         if (((pBsp && pBsp->getDirType() == 3) || (pCsp && pCsp->getDirType() == 3)) &&
-            dusk::frame_interp::is_enabled())
+            dusk::interp::is_enabled())
         {
             // ensure mGlobalEmtrDir is valid
             calcWorkData_d(work);
diff --git a/libs/JSystem/src/JStudio/JStudio/ctb-data.cpp b/libs/JSystem/src/JStudio/JStudio/ctb-data.cpp
index 629d542457..8f7fa348ba 100644
--- a/libs/JSystem/src/JStudio/JStudio/ctb-data.cpp
+++ b/libs/JSystem/src/JStudio/JStudio/ctb-data.cpp
@@ -2,4 +2,4 @@
 
 #include "JSystem/JStudio/JStudio/ctb.h"
 
-const u32 JStudio::ctb::data::ga4cSignature = BSWAP32('CTB\0');
+DUSK_GAME_DATA const u32 JStudio::ctb::data::ga4cSignature = BSWAP32('CTB\0');
diff --git a/libs/JSystem/src/JStudio/JStudio/fvb-data.cpp b/libs/JSystem/src/JStudio/JStudio/fvb-data.cpp
index deee81198e..ef9f785165 100644
--- a/libs/JSystem/src/JStudio/JStudio/fvb-data.cpp
+++ b/libs/JSystem/src/JStudio/JStudio/fvb-data.cpp
@@ -2,4 +2,4 @@
 
 #include "JSystem/JStudio/JStudio/fvb-data.h"
 
-const char JStudio::fvb::data::ga4cSignature[4] = "FVB";
+DUSK_GAME_DATA const char JStudio::fvb::data::ga4cSignature[4] = "FVB";
diff --git a/libs/JSystem/src/JStudio/JStudio/jstudio-data.cpp b/libs/JSystem/src/JStudio/JStudio/jstudio-data.cpp
index c6f90bc45f..2d361f5acd 100644
--- a/libs/JSystem/src/JStudio/JStudio/jstudio-data.cpp
+++ b/libs/JSystem/src/JStudio/JStudio/jstudio-data.cpp
@@ -2,4 +2,4 @@
 
 #include "JSystem/JStudio/JStudio/jstudio-data.h"
 
-const char JStudio::data::ga8cSignature[8] = "jstudio";
+DUSK_GAME_DATA const char JStudio::data::ga8cSignature[8] = "jstudio";
diff --git a/libs/JSystem/src/JStudio/JStudio/jstudio-object.cpp b/libs/JSystem/src/JStudio/JStudio/jstudio-object.cpp
index 864dec39fc..b6f41098e5 100644
--- a/libs/JSystem/src/JStudio/JStudio/jstudio-object.cpp
+++ b/libs/JSystem/src/JStudio/JStudio/jstudio-object.cpp
@@ -4,7 +4,7 @@
 
 #if TARGET_PC
 #include "dusk/audio.h"
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/settings.h"
 #endif
 
@@ -326,19 +326,19 @@ JStudio::TObject_actor::TObject_actor(JStudio::stb::data::TParse_TBlock_object c
 
 }
 
-u32 const JStudio::TAdaptor_actor::sauVariableValue_3_TRANSLATION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_actor::sauVariableValue_3_TRANSLATION_XYZ[3] = {
     3, 4, 5,
 };
 
- u32 const JStudio::TAdaptor_actor::sauVariableValue_3_ROTATION_XYZ[3] = {
+ DUSK_GAME_DATA u32 const JStudio::TAdaptor_actor::sauVariableValue_3_ROTATION_XYZ[3] = {
     6, 7, 8,
 };
 
-u32 const JStudio::TAdaptor_actor::sauVariableValue_3_SCALING_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_actor::sauVariableValue_3_SCALING_XYZ[3] = {
     9, 10, 11,
 };
 
- JStudio::TVariableValue::TOutput_none_ JStudio::TVariableValue::soOutput_none_;
+ DUSK_GAME_DATA JStudio::TVariableValue::TOutput_none_ JStudio::TVariableValue::soOutput_none_;
 
 void JStudio::TObject_actor::do_paragraph(u32 param_1, void const* param_2, u32 param_3) {
     TAdaptor* adaptor = getAdaptor();
@@ -479,11 +479,11 @@ JStudio::TObject_ambientLight::TObject_ambientLight(
     JStudio::TAdaptor_ambientLight* param_1) : TObject(param_0, param_1) {
 }
 
-u32 const JStudio::TAdaptor_ambientLight::sauVariableValue_3_COLOR_RGB[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_ambientLight::sauVariableValue_3_COLOR_RGB[3] = {
     0, 1, 2,
 };
 
-u32 const JStudio::TAdaptor_ambientLight::sauVariableValue_4_COLOR_RGBA[4] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_ambientLight::sauVariableValue_4_COLOR_RGBA[4] = {
     0, 1, 2, 3,
 };
 
@@ -540,15 +540,15 @@ JStudio::TObject_camera::TObject_camera(JStudio::stb::data::TParse_TBlock_object
                                         JStudio::TAdaptor_camera* param_1)
     : TObject(param_0, param_1) {}
 
-u32 const JStudio::TAdaptor_camera::sauVariableValue_3_POSITION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_camera::sauVariableValue_3_POSITION_XYZ[3] = {
     0, 1, 2,
 };
 
-u32 const JStudio::TAdaptor_camera::sauVariableValue_3_TARGET_POSITION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_camera::sauVariableValue_3_TARGET_POSITION_XYZ[3] = {
     3, 4, 5,
 };
 
-u32 const JStudio::TAdaptor_camera::sauVariableValue_2_DISTANCE_NEAR_FAR[2] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_camera::sauVariableValue_2_DISTANCE_NEAR_FAR[2] = {
     8, 9,
 };
 
@@ -655,10 +655,10 @@ value_or_fun:
 
 value:
 #if TARGET_PC
-    if (dusk::frame_interp::is_enabled() && u <= 5 &&
+    if (dusk::interp::is_enabled() && u <= 5 &&
         (operation == data::UNK_0x2 || operation == data::UNK_0x3 || operation == data::UNK_0x12))
     {
-        dusk::frame_interp::request_presentation_sync();
+        dusk::interp::request_presentation_sync();
     }
 #endif
     adaptor->adaptor_setVariableValue(control, u, operation, param_2, param_3);
@@ -666,11 +666,11 @@ value:
 
 value_n:
 #if TARGET_PC
-    if (dusk::frame_interp::is_enabled() &&
+    if (dusk::interp::is_enabled() &&
         (pN == TAdaptor_camera::sauVariableValue_3_POSITION_XYZ || pN == TAdaptor_camera::sauVariableValue_3_TARGET_POSITION_XYZ) &&
         (operation == data::UNK_0x2 || operation == data::UNK_0x3 || operation == data::UNK_0x12))
     {
-        dusk::frame_interp::request_presentation_sync();
+        dusk::interp::request_presentation_sync();
     }
 #endif
     adaptor->adaptor_setVariableValue_n(control, pN, u, operation, param_2, param_3);
@@ -686,15 +686,15 @@ JStudio::TAdaptor_fog::~TAdaptor_fog() {}
 JStudio::TObject_fog::TObject_fog(JStudio::stb::data::TParse_TBlock_object const& param_0,
                                       JStudio::TAdaptor_fog* param_1) : TObject(param_0, param_1) {}
 
-u32 const JStudio::TAdaptor_fog::sauVariableValue_3_COLOR_RGB[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_fog::sauVariableValue_3_COLOR_RGB[3] = {
     0, 1, 2,
 };
 
-u32 const JStudio::TAdaptor_fog::sauVariableValue_4_COLOR_RGBA[4] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_fog::sauVariableValue_4_COLOR_RGBA[4] = {
     0, 1, 2, 3,
 };
 
-u32 const JStudio::TAdaptor_fog::sauVariableValue_2_RANGE_BEGIN_END[2] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_fog::sauVariableValue_2_RANGE_BEGIN_END[2] = {
     4, 5,
 };
 
@@ -759,23 +759,23 @@ JStudio::TAdaptor_light::~TAdaptor_light() {}
 JStudio::TObject_light::TObject_light(JStudio::stb::data::TParse_TBlock_object const& param_0,
                                           JStudio::TAdaptor_light* param_1) : TObject(param_0, param_1) {}
 
-u32 const JStudio::TAdaptor_light::sauVariableValue_2_DIRECTION_THETA_PHI[2] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_light::sauVariableValue_2_DIRECTION_THETA_PHI[2] = {
     10, 11,
 };
 
- u32 const JStudio::TAdaptor_light::sauVariableValue_3_COLOR_RGB[3] = {
+ DUSK_GAME_DATA u32 const JStudio::TAdaptor_light::sauVariableValue_3_COLOR_RGB[3] = {
     0, 1, 2,
 };
 
-u32 const JStudio::TAdaptor_light::sauVariableValue_4_COLOR_RGBA[4] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_light::sauVariableValue_4_COLOR_RGBA[4] = {
     0, 1, 2, 3,
 };
 
-u32 const JStudio::TAdaptor_light::sauVariableValue_3_POSITION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_light::sauVariableValue_3_POSITION_XYZ[3] = {
     4, 5, 6,
 };
 
-u32 const JStudio::TAdaptor_light::sauVariableValue_3_TARGET_POSITION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_light::sauVariableValue_3_TARGET_POSITION_XYZ[3] = {
     7, 8, 9,
 };
 
@@ -921,31 +921,31 @@ JStudio::TAdaptor_particle::~TAdaptor_particle() {}
 JStudio::TObject_particle::TObject_particle(
     JStudio::stb::data::TParse_TBlock_object const& param_0, JStudio::TAdaptor_particle* param_1) : TObject(param_0, param_1) {}
 
- u32 const JStudio::TAdaptor_particle::sauVariableValue_3_TRANSLATION_XYZ[3] = {
+ DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_3_TRANSLATION_XYZ[3] = {
     0, 1, 2,
 };
 
-u32 const JStudio::TAdaptor_particle::sauVariableValue_3_ROTATION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_3_ROTATION_XYZ[3] = {
     3, 4, 5,
 };
 
-u32 const JStudio::TAdaptor_particle::sauVariableValue_3_SCALING_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_3_SCALING_XYZ[3] = {
     6, 7, 8,
 };
 
-u32 const JStudio::TAdaptor_particle::sauVariableValue_3_COLOR_RGB[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_3_COLOR_RGB[3] = {
     9, 10, 11,
 };
 
-u32 const JStudio::TAdaptor_particle::sauVariableValue_4_COLOR_RGBA[4] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_4_COLOR_RGBA[4] = {
     9, 10, 11, 12,
 };
 
-u32 const JStudio::TAdaptor_particle::sauVariableValue_3_COLOR1_RGB[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_3_COLOR1_RGB[3] = {
     9, 10, 11,
 };
 
-u32 const JStudio::TAdaptor_particle::sauVariableValue_4_COLOR1_RGBA[4] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_particle::sauVariableValue_4_COLOR1_RGBA[4] = {
     9, 10, 11, 12,
 };
 
@@ -1119,7 +1119,7 @@ JStudio::TAdaptor_sound::~TAdaptor_sound() {}
 JStudio::TObject_sound::TObject_sound(JStudio::stb::data::TParse_TBlock_object const& param_0,
                                           JStudio::TAdaptor_sound* param_1) : TObject(param_0, param_1) {}
 
-u32 const JStudio::TAdaptor_sound::sauVariableValue_3_POSITION_XYZ[3] = {
+DUSK_GAME_DATA u32 const JStudio::TAdaptor_sound::sauVariableValue_3_POSITION_XYZ[3] = {
     0, 1, 2,
 };
 
diff --git a/libs/JSystem/src/JStudio/JStudio/stb-data.cpp b/libs/JSystem/src/JStudio/JStudio/stb-data.cpp
index 79df1744d9..5de2b8f7bf 100644
--- a/libs/JSystem/src/JStudio/JStudio/stb-data.cpp
+++ b/libs/JSystem/src/JStudio/JStudio/stb-data.cpp
@@ -1,6 +1,6 @@
 #include "JSystem/JSystem.h" // IWYU pragma: keep
-#include "dusk/endian.h"
+#include "helpers/endian.h"
 #include "JSystem/JStudio/JStudio/stb-data.h"
 
-const s32 JStudio::stb::data::gauDataSize_TEParagraph_data[8] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40};
-const BE(u32) JStudio::stb::data::ga4cSignature = 'STB\0';
+DUSK_GAME_DATA const s32 JStudio::stb::data::gauDataSize_TEParagraph_data[8] = {0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40};
+DUSK_GAME_DATA const BE(u32) JStudio::stb::data::ga4cSignature = 'STB\0';
diff --git a/libs/JSystem/src/JStudio/JStudio_JAudio2/object-sound.cpp b/libs/JSystem/src/JStudio/JStudio_JAudio2/object-sound.cpp
index 9bdde8b5cc..14eb3a74a4 100644
--- a/libs/JSystem/src/JStudio/JStudio_JAudio2/object-sound.cpp
+++ b/libs/JSystem/src/JStudio/JStudio_JAudio2/object-sound.cpp
@@ -80,7 +80,7 @@ void JStudio_JAudio2::TAdaptor_sound::adaptor_do_prepare() {
     }
 }
 
-JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_ JStudio_JAudio2::TAdaptor_sound::saoVVOSetValue_[6] = {
+DUSK_GAME_DATA JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_ JStudio_JAudio2::TAdaptor_sound::saoVVOSetValue_[6] = {
     JStudio_JAudio2::TAdaptor_sound::TVVOSetValue_(
         JStudio_JAudio2::TAdaptor_sound::UNK_7, setValue_VOLUME_ 
     ),
diff --git a/libs/JSystem/src/JStudio/JStudio_JStage/object-actor.cpp b/libs/JSystem/src/JStudio/JStudio_JStage/object-actor.cpp
index 0ee7d53fb7..603cf30319 100644
--- a/libs/JSystem/src/JStudio/JStudio_JStage/object-actor.cpp
+++ b/libs/JSystem/src/JStudio/JStudio_JStage/object-actor.cpp
@@ -348,12 +348,12 @@ JStudio_JStage::TAdaptor_actor::TVVOutput_ANIMATION_FRAME_::~TVVOutput_ANIMATION
 
 namespace JStudio_JStage {
     
-const TAdaptor_actor::TVVOutputObject TAdaptor_actor::saoVVOutput_[] = {
+DUSK_GAME_DATA const TAdaptor_actor::TVVOutputObject TAdaptor_actor::saoVVOutput_[] = {
     TVVOutputObject(TAdaptor_actor::TEACTOR_1, &JStage::TActor::JSGSetAnimationTransition, &JStage::TActor::JSGGetAnimationTransition),
     TVVOutputObject()
 };
 
-const TAdaptor_actor::TVVOutput_ANIMATION_FRAME_ TAdaptor_actor::saoVVOutput_ANIMATION_FRAME_[] = {
+DUSK_GAME_DATA const TAdaptor_actor::TVVOutput_ANIMATION_FRAME_ TAdaptor_actor::saoVVOutput_ANIMATION_FRAME_[] = {
     TVVOutput_ANIMATION_FRAME_(0, 305, &JStage::TActor::JSGSetAnimationFrame, &JStage::TActor::JSGGetAnimationFrame, &JStage::TActor::JSGGetAnimationFrameMax),
     TVVOutput_ANIMATION_FRAME_(2, 309, &JStage::TActor::JSGSetTextureAnimationFrame, &JStage::TActor::JSGGetTextureAnimationFrame, &JStage::TActor::JSGGetTextureAnimationFrameMax),
     TVVOutput_ANIMATION_FRAME_()
diff --git a/libs/JSystem/src/JStudio/JStudio_JStage/object-camera.cpp b/libs/JSystem/src/JStudio/JStudio_JStage/object-camera.cpp
index afa1fb8ab4..c29aea47fa 100644
--- a/libs/JSystem/src/JStudio/JStudio_JStage/object-camera.cpp
+++ b/libs/JSystem/src/JStudio/JStudio_JStage/object-camera.cpp
@@ -22,7 +22,7 @@ JStudio_JStage::TAdaptor_camera::~TAdaptor_camera() {
     adaptor_do_end();
 }
 
-JStudio_JStage::TAdaptor_camera::TVVOutput JStudio_JStage::TAdaptor_camera::saoVVOutput_[5] = {
+DUSK_GAME_DATA JStudio_JStage::TAdaptor_camera::TVVOutput JStudio_JStage::TAdaptor_camera::saoVVOutput_[5] = {
     TVVOutput(JStudio_JStage::TAdaptor_camera::TECAMERA_7, &JStage::TCamera::JSGSetViewRoll,
               &JStage::TCamera::JSGGetViewRoll),
     TVVOutput(JStudio_JStage::TAdaptor_camera::TECAMERA_6, &JStage::TCamera::JSGSetProjectionFovy,
diff --git a/libs/JSystem/src/JStudio/JStudio_JStage/object-fog.cpp b/libs/JSystem/src/JStudio/JStudio_JStage/object-fog.cpp
index ba1f2391e3..43cd94229a 100644
--- a/libs/JSystem/src/JStudio/JStudio_JStage/object-fog.cpp
+++ b/libs/JSystem/src/JStudio/JStudio_JStage/object-fog.cpp
@@ -13,7 +13,7 @@ JStudio_JStage::TAdaptor_fog::~TAdaptor_fog() {
     adaptor_do_end();
 }
 
-JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog> JStudio_JStage::TAdaptor_fog::saoVVOutput_[3] = {
+DUSK_GAME_DATA JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog> JStudio_JStage::TAdaptor_fog::saoVVOutput_[3] = {
     JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>(JStudio_JStage::TAdaptor_fog::TEFOG_4, &JStage::TFog::JSGSetStartZ, &JStage::TFog::JSGGetStartZ),
     JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>(JStudio_JStage::TAdaptor_fog::TEFOG_5, &JStage::TFog::JSGSetEndZ, &JStage::TFog::JSGGetEndZ),
     JStudio_JStage::TVariableValueOutput_object_<JStudio_JStage::TAdaptor_fog, JStage::TFog>(),
diff --git a/libs/JSystem/src/JStudio/JStudio_JStage/object-light.cpp b/libs/JSystem/src/JStudio/JStudio_JStage/object-light.cpp
index 19a02f09df..9b3b2e608d 100644
--- a/libs/JSystem/src/JStudio/JStudio_JStage/object-light.cpp
+++ b/libs/JSystem/src/JStudio/JStudio_JStage/object-light.cpp
@@ -12,7 +12,7 @@ JStudio_JStage::TAdaptor_light::~TAdaptor_light() {
     adaptor_do_end();
 }
 
-JStudio_JStage::TAdaptor_light::TVVOutput_direction_
+DUSK_GAME_DATA JStudio_JStage::TAdaptor_light::TVVOutput_direction_
     JStudio_JStage::TAdaptor_light::saoVVOutput_direction_[6] = {
         JStudio_JStage::TAdaptor_light::TVVOutput_direction_(
             JStudio_JStage::TAdaptor_light::TE_VALUE_10,
diff --git a/libs/JSystem/src/JUtility/JUTCacheFont.cpp b/libs/JSystem/src/JUtility/JUTCacheFont.cpp
index 81b9f252f1..3fd02a1232 100644
--- a/libs/JSystem/src/JUtility/JUTCacheFont.cpp
+++ b/libs/JSystem/src/JUtility/JUTCacheFont.cpp
@@ -56,6 +56,10 @@ void JUTCacheFont::initialize_state() {
     mCacheBuffer = NULL;
     field_0x9c = NULL;
     field_0xa0 = NULL;
+
+#if TARGET_PC
+    mJoinedTextureHeight = 0;
+#endif
 }
 
 int JUTCacheFont::getMemorySize(ResFONT const* p_font, u16* o_widCount, u32* o_widSize,
@@ -203,7 +207,7 @@ bool JUTCacheFont::allocArea(void* cacheBuffer, u32 param_1, JKRHeap* heap) {
         }
     }
 
-    field_0x94 = mMaxSheetSize + 0x40;
+    field_0x94 = mMaxSheetSize + sizeof(TCachePage);
     mCachePage = param_1 / field_0x94;
     u32 v1 = field_0x94 * mCachePage;
     if (mCachePage == 0) {
@@ -346,7 +350,23 @@ void JUTCacheFont::getGlyphFromAram(JUTCacheFont::TGlyphCacheInfo* param_0,
                                     JUTCacheFont::TCachePage* pCachePage, int* param_2, int* param_3) {
     TGlyphCacheInfo* pGylphCacheInfo = pCachePage;
     int* r30 = param_2;
+#if TARGET_PC
+    // TODO: proper fix to account for 64bit ptr sizes
+    ResFONT::GLY1* glyph = (ResFONT::GLY1*)param_0;
+    pGylphCacheInfo->field_0x8 = glyph->startCode;
+    pGylphCacheInfo->field_0xa = glyph->endCode;
+    pGylphCacheInfo->field_0xc = glyph->cellWidth;
+    pGylphCacheInfo->field_0xe = glyph->cellHeight;
+    pGylphCacheInfo->field_0x10 = glyph->textureSize;
+    pGylphCacheInfo->mTexFormat = glyph->textureFormat;
+    pGylphCacheInfo->field_0x16 = glyph->numRows;
+    pGylphCacheInfo->field_0x18 = glyph->numColumns;
+    pGylphCacheInfo->mWidth = glyph->textureWidth;
+    pGylphCacheInfo->mHeight = glyph->textureHeight;
+    pGylphCacheInfo->field_0x1e = 0;
+#else
     memcpy(pGylphCacheInfo, param_0, sizeof(TGlyphCacheInfo));
+#endif
     prepend(pGylphCacheInfo);
     int iVar3 = pGylphCacheInfo->field_0x16 * pGylphCacheInfo->field_0x18;
     int iVar2 = *r30 / iVar3;
@@ -364,7 +384,11 @@ void JUTCacheFont::getGlyphFromAram(JUTCacheFont::TGlyphCacheInfo* param_0,
                     GX_ANISO_1);
 }
 
+#if TARGET_PC
+void JUTCacheFont::loadImage(int param_0, GXTexMapID texMapId FONT_DRAW_CTX) {
+#else
 void JUTCacheFont::loadImage(int param_0, GXTexMapID texMapId) {
+#endif
     TCachePage* cachePage = loadCache_char_subroutine(&param_0, false);
     if (cachePage != NULL) {
         mWidth = cachePage->field_0xc * (param_0 % (int)cachePage->field_0x16);
@@ -421,6 +445,16 @@ JUTCacheFont::TCachePage* JUTCacheFont::loadCache_char_subroutine(int* param_0,
 }
 
 void JUTCacheFont::invalidiateAllCache() {
+#if TARGET_PC
+    u8* cacheBuffer = (u8*)mCacheBuffer;
+    for (int i = 0; i < mCachePage; i++) {
+        TGlyphCacheInfo* current = (TGlyphCacheInfo*)cacheBuffer;
+        current->mPrev = i == 0 ? NULL : (TGlyphCacheInfo*)(cacheBuffer - field_0x94);
+        current->mNext = i == mCachePage - 1 ? NULL : (TGlyphCacheInfo*)(cacheBuffer + field_0x94);
+        cacheBuffer = cacheBuffer + field_0x94;
+    }
+    field_0xa8 = (intptr_t)cacheBuffer - field_0x94;
+#else
     int* cacheBuffer = (int*)mCacheBuffer;
     for (int i = 0; i < mCachePage; i++) {
         *cacheBuffer = i == 0 ? 0 : (intptr_t)cacheBuffer - field_0x94;
@@ -428,6 +462,7 @@ void JUTCacheFont::invalidiateAllCache() {
         cacheBuffer = (int*)((intptr_t)cacheBuffer + field_0x94);
     }
     field_0xa8 = (intptr_t)cacheBuffer - field_0x94;
+#endif
     field_0xa4 = (TGlyphCacheInfo*)mCacheBuffer;
     field_0x9c = NULL;
     field_0xa0 = NULL;
diff --git a/libs/JSystem/src/JUtility/JUTConsole.cpp b/libs/JSystem/src/JUtility/JUTConsole.cpp
index c2c023a2d8..75150cb498 100644
--- a/libs/JSystem/src/JUtility/JUTConsole.cpp
+++ b/libs/JSystem/src/JUtility/JUTConsole.cpp
@@ -8,10 +8,10 @@
 #include "JSystem/JUtility/JUTConsole.h"
 #include "JSystem/JUtility/JUTDirectPrint.h"
 #include "JSystem/JUtility/JUTVideo.h"
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 #include "global.h"
 
-JUTConsoleManager* JUTConsoleManager::sManager;
+DUSK_GAME_DATA JUTConsoleManager* JUTConsoleManager::sManager;
 
 JUTConsole* JUTConsole::create(unsigned int param_0, unsigned int maxLines, JKRHeap* pHeap) {
     JUTConsoleManager* pManager = JUTConsoleManager::getManager();
diff --git a/libs/JSystem/src/JUtility/JUTDbPrint.cpp b/libs/JSystem/src/JUtility/JUTDbPrint.cpp
index cdf4c08d29..03535f2d15 100644
--- a/libs/JSystem/src/JUtility/JUTDbPrint.cpp
+++ b/libs/JSystem/src/JUtility/JUTDbPrint.cpp
@@ -16,7 +16,7 @@ JUTDbPrint::JUTDbPrint(JUTFont* pFont, JKRHeap* pHeap) {
     mVisible = true;
 }
 
-JUTDbPrint* JUTDbPrint::sDebugPrint;
+DUSK_GAME_DATA JUTDbPrint* JUTDbPrint::sDebugPrint;
 
 JUTDbPrint* JUTDbPrint::start(JUTFont* pFont, JKRHeap* pHeap) {
     if (sDebugPrint == NULL) {
diff --git a/libs/JSystem/src/JUtility/JUTDirectPrint.cpp b/libs/JSystem/src/JUtility/JUTDirectPrint.cpp
index 1b5993c5bd..745862dfbc 100644
--- a/libs/JSystem/src/JUtility/JUTDirectPrint.cpp
+++ b/libs/JSystem/src/JUtility/JUTDirectPrint.cpp
@@ -7,7 +7,7 @@
 #include "global.h"
 #include "angle_utils.h"
 
-JUTDirectPrint* JUTDirectPrint::sDirectPrint;
+DUSK_GAME_DATA JUTDirectPrint* JUTDirectPrint::sDirectPrint;
 
 JUTDirectPrint::JUTDirectPrint() {
     changeFrameBuffer(NULL, 0, 0);
@@ -48,7 +48,7 @@ void JUTDirectPrint::erase(int x, int y, int width, int height) {
     }
 }
 
-u8 JUTDirectPrint::sAsciiTable[128] = {
+DUSK_GAME_DATA u8 JUTDirectPrint::sAsciiTable[128] = {
     0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A, 0xFD, 0xFE, 0x7A, 0x7A, 0x7A, 0x7A, 0x7A,
     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
     0xFF, 0x29, 0x64, 0x65, 0x66, 0x2B, 0x67, 0x68, 0x25, 0x26, 0x69, 0x2A, 0x6A, 0x27, 0x2C, 0x6B,
@@ -59,7 +59,7 @@ u8 JUTDirectPrint::sAsciiTable[128] = {
     0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x76, 0x77, 0x78, 0x79, 0x7A,
 };
 
-u32 JUTDirectPrint::sFontData[64] = {
+DUSK_GAME_DATA u32 JUTDirectPrint::sFontData[64] = {
     0x70871C30, 0x8988A250, 0x88808290, 0x88830C90, 0x888402F8, 0x88882210, 0x71CF9C10, 0xF9CF9C70,
     0x8208A288, 0xF200A288, 0x0BC11C78, 0x0A222208, 0x8A222208, 0x71C21C70, 0x23C738F8, 0x5228A480,
     0x8A282280, 0x8BC822F0, 0xFA282280, 0x8A28A480, 0x8BC738F8, 0xF9C89C08, 0x82288808, 0x82088808,
@@ -70,7 +70,7 @@ u32 JUTDirectPrint::sFontData[64] = {
     0x70800000, 0x88822200, 0x08820400, 0x108F8800, 0x20821000, 0x00022200, 0x20800020, 0x00000000,
 };
 
-u32 JUTDirectPrint::sFontData2[77] = {
+DUSK_GAME_DATA u32 JUTDirectPrint::sFontData2[77] = {
     0x51421820, 0x53E7A420, 0x014A2C40, 0x01471000, 0x0142AA00, 0x03EAA400, 0x01471A78, 0x00000000,
     0x50008010, 0x20010820, 0xF8020040, 0x20420820, 0x50441010, 0x00880000, 0x00070E00, 0x01088840,
     0x78898820, 0x004A8810, 0x788A8810, 0x01098808, 0x00040E04, 0x70800620, 0x11400820, 0x12200820,
diff --git a/libs/JSystem/src/JUtility/JUTException.cpp b/libs/JSystem/src/JUtility/JUTException.cpp
index 54b234118c..9e00bce739 100644
--- a/libs/JSystem/src/JUtility/JUTException.cpp
+++ b/libs/JSystem/src/JUtility/JUTException.cpp
@@ -10,7 +10,7 @@
 #include <cstdio>
 #include <cstdlib>
 
-#include "dusk/string.hpp"
+#include "helpers/string.hpp"
 #ifdef __REVOLUTION_SDK__
 #include <revolution.h>
 #else
@@ -27,16 +27,16 @@ struct CallbackObject {
     /* 0x10 */ int param_4;
 };
 
-OSMessageQueue JUTException::sMessageQueue = {0};
+DUSK_GAME_DATA OSMessageQueue JUTException::sMessageQueue = {0};
 
 STATIC_ASSERT(sizeof(CallbackObject) == 0x14);
 static CallbackObject exCallbackObject;
 
-JSUList<JUTException::JUTExMapFile> JUTException::sMapFileList(false);
+DUSK_GAME_DATA JSUList<JUTException::JUTExMapFile> JUTException::sMapFileList(false);
 
 static OSTime c3bcnt[4] = {0, 0, 0, 0};
 
-const char* JUTException::sCpuExpName[17] = {
+DUSK_GAME_DATA const char* JUTException::sCpuExpName[17] = {
     "SYSTEM RESET",
     "MACHINE CHECK",
     "DSI",
@@ -56,11 +56,11 @@ const char* JUTException::sCpuExpName[17] = {
     "FLOATING POINT",
 };
 
-JUTException* JUTException::sErrorManager;
+DUSK_GAME_DATA JUTException* JUTException::sErrorManager;
 
-JUTExceptionUserCallback JUTException::sPreUserCallback;
+DUSK_GAME_DATA JUTExceptionUserCallback JUTException::sPreUserCallback;
 
-JUTExceptionUserCallback JUTException::sPostUserCallback;
+DUSK_GAME_DATA JUTExceptionUserCallback JUTException::sPostUserCallback;
 
 #if PLATFORM_GCN
 const int stack_size = 0x1C00;
@@ -100,7 +100,7 @@ JUTException* JUTException::create(JUTDirectPrint* directPrint) {
     return sErrorManager;
 }
 
-OSMessage JUTException::sMessageBuffer[1] = {0};
+DUSK_GAME_DATA OSMessage JUTException::sMessageBuffer[1] = {0};
 
 void* JUTException::run() {
 #ifdef TARGET_PC
@@ -140,15 +140,15 @@ void* JUTException::run() {
 #endif
 }
 
-void* JUTException::sConsoleBuffer;
+DUSK_GAME_DATA void* JUTException::sConsoleBuffer;
 
-u32 JUTException::sConsoleBufferSize;
+DUSK_GAME_DATA u32 JUTException::sConsoleBufferSize;
 
-JUTConsole* JUTException::sConsole;
+DUSK_GAME_DATA JUTConsole* JUTException::sConsole;
 
-u32 JUTException::msr;
+DUSK_GAME_DATA u32 JUTException::msr;
 
-u32 JUTException::fpscr;
+DUSK_GAME_DATA u32 JUTException::fpscr;
 
 void JUTException::errorHandler(OSError error, OSContext* context, u32 param_3, u32 param_4) {
 #ifndef TARGET_PC
diff --git a/libs/JSystem/src/JUtility/JUTFader.cpp b/libs/JSystem/src/JUtility/JUTFader.cpp
index e7d33454b7..2e937b176e 100644
--- a/libs/JSystem/src/JUtility/JUTFader.cpp
+++ b/libs/JSystem/src/JUtility/JUTFader.cpp
@@ -9,6 +9,8 @@
 #include "JSystem/J2DGraph/J2DOrthoGraph.h"
 
 #ifdef TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+
 #include <algorithm>
 #endif
 
@@ -73,8 +75,8 @@ void JUTFader::control() {
 void JUTFader::draw() {
     if (mColor.a != 0) {
 #ifdef TARGET_PC
-        if (dusk::frame_interp::is_enabled() && mDuration != 0) {
-            const auto step = dusk::frame_interp::get_interpolation_step();
+        if (dusk::interp::is_enabled() && mDuration != 0) {
+            const auto step = dusk::interp::get_interpolation_step();
             const auto progress = static_cast<f32>(mTimer) / static_cast<f32>(mDuration);
             const auto timer = mTimer - 1 + step + progress;
             auto alpha = timer / mDuration;
diff --git a/libs/JSystem/src/JUtility/JUTFontData_Ascfont_fix12.cpp b/libs/JSystem/src/JUtility/JUTFontData_Ascfont_fix12.cpp
index 35979ebc9f..0e500e377c 100644
--- a/libs/JSystem/src/JUtility/JUTFontData_Ascfont_fix12.cpp
+++ b/libs/JSystem/src/JUtility/JUTFontData_Ascfont_fix12.cpp
@@ -8,7 +8,7 @@
 #endif
 #include "global.h"
 
-u8 const JUTResFONT_Ascfont_fix12[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) DUSK_GAME_DATA u8 const JUTResFONT_Ascfont_fix12[] = {
     0x46, 0x4F, 0x4E, 0x54, 0x62, 0x66, 0x6E, 0x31, 0x00, 0x00, 0x41, 0x60, 0x00, 0x00, 0x00, 0x04,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x49, 0x4E, 0x46, 0x31, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x0C,
diff --git a/libs/JSystem/src/JUtility/JUTGamePad.cpp b/libs/JSystem/src/JUtility/JUTGamePad.cpp
index 48ed5f130e..c7e078b893 100644
--- a/libs/JSystem/src/JUtility/JUTGamePad.cpp
+++ b/libs/JSystem/src/JUtility/JUTGamePad.cpp
@@ -8,7 +8,7 @@
 #include "dusk/action_bindings.h"
 #endif
 
-u32 JUTGamePad::CRumble::sChannelMask[4] = {
+DUSK_GAME_DATA u32 JUTGamePad::CRumble::sChannelMask[4] = {
     PAD_CHAN0_BIT,
     PAD_CHAN1_BIT,
     PAD_CHAN2_BIT,
@@ -17,11 +17,11 @@ u32 JUTGamePad::CRumble::sChannelMask[4] = {
 
 static u32 channel_mask[4] = {PAD_CHAN0_BIT, PAD_CHAN1_BIT, PAD_CHAN2_BIT, PAD_CHAN3_BIT};
 
-JSUList<JUTGamePad> JUTGamePad::mPadList(false);
+DUSK_GAME_DATA JSUList<JUTGamePad> JUTGamePad::mPadList(false);
 
-bool JUTGamePad::mListInitialized;
+DUSK_GAME_DATA bool JUTGamePad::mListInitialized;
 
-u8 JUTGamePad::mPadAssign[4];
+DUSK_GAME_DATA u8 JUTGamePad::mPadAssign[4];
 
 JUTGamePad::JUTGamePad(EPadPort port) : mRumble(this), mLink(this) {
     mPortNum = port;
@@ -53,11 +53,11 @@ void JUTGamePad::initList() {
     }
 }
 
-u32 JUTGamePad::sSuppressPadReset;
+DUSK_GAME_DATA u32 JUTGamePad::sSuppressPadReset;
 
-u8 data_8074CFA4_debug;
+DUSK_GAME_DATA u8 data_8074CFA4_debug;
 
-s32 JUTGamePad::sAnalogMode;
+DUSK_GAME_DATA s32 JUTGamePad::sAnalogMode;
 
 BOOL JUTGamePad::init() {
     PADSetSpec(PAD_SPEC_5);
@@ -73,19 +73,19 @@ void JUTGamePad::clear() {
 #endif
 }
 
-PADStatus JUTGamePad::mPadStatus[4];
+DUSK_GAME_DATA PADStatus JUTGamePad::mPadStatus[4];
 
-JUTGamePad::CButton JUTGamePad::mPadButton[4];
+DUSK_GAME_DATA JUTGamePad::CButton JUTGamePad::mPadButton[4];
 
-JUTGamePad::CStick JUTGamePad::mPadMStick[4];
+DUSK_GAME_DATA JUTGamePad::CStick JUTGamePad::mPadMStick[4];
 
-JUTGamePad::CStick JUTGamePad::mPadSStick[4];
+DUSK_GAME_DATA JUTGamePad::CStick JUTGamePad::mPadSStick[4];
 
-JUTGamePad::EStickMode JUTGamePad::sStickMode = EStickMode1;
+DUSK_GAME_DATA JUTGamePad::EStickMode JUTGamePad::sStickMode = EStickMode1;
 
-int JUTGamePad::sClampMode = EClampStick;
+DUSK_GAME_DATA int JUTGamePad::sClampMode = EClampStick;
 
-u32 JUTGamePad::sRumbleSupported;
+DUSK_GAME_DATA u32 JUTGamePad::sRumbleSupported;
 
 u32 JUTGamePad::read() {
     sRumbleSupported = PADRead(mPadStatus);
@@ -181,21 +181,21 @@ void JUTGamePad::assign() {
     }
 }
 
-u8 JUTGamePad::CRumble::mStatus[4];
+DUSK_GAME_DATA u8 JUTGamePad::CRumble::mStatus[4];
 
-u32 JUTGamePad::CRumble::mEnabled;
+DUSK_GAME_DATA u32 JUTGamePad::CRumble::mEnabled;
 
-callbackFn JUTGamePad::C3ButtonReset::sCallback;
+DUSK_GAME_DATA callbackFn JUTGamePad::C3ButtonReset::sCallback;
 
-void* JUTGamePad::C3ButtonReset::sCallbackArg;
+DUSK_GAME_DATA void* JUTGamePad::C3ButtonReset::sCallbackArg;
 
-OSTime JUTGamePad::C3ButtonReset::sThreshold = (OSTime)(OS_TIMER_CLOCK / 60) * 30;
+DUSK_GAME_DATA OSTime JUTGamePad::C3ButtonReset::sThreshold = (OSTime)(OS_TIMER_CLOCK / 60) * 30;
 
-bool JUTGamePad::C3ButtonReset::sResetSwitchPushing;
+DUSK_GAME_DATA bool JUTGamePad::C3ButtonReset::sResetSwitchPushing;
 
-bool JUTGamePad::C3ButtonReset::sResetOccurred;
+DUSK_GAME_DATA bool JUTGamePad::C3ButtonReset::sResetOccurred;
 
-s32 JUTGamePad::C3ButtonReset::sResetOccurredPort;
+DUSK_GAME_DATA s32 JUTGamePad::C3ButtonReset::sResetOccurredPort;
 
 void JUTGamePad::checkResetCallback(OSTime holdTime) {
     if (holdTime >= JUTGamePad::C3ButtonReset::sThreshold) {
@@ -208,13 +208,13 @@ void JUTGamePad::checkResetCallback(OSTime holdTime) {
     }
 }
 
-f32 JUTGamePad::CStick::sPressPoint = 0.5f;
+DUSK_GAME_DATA f32 JUTGamePad::CStick::sPressPoint = 0.5f;
 
-f32 JUTGamePad::CStick::sReleasePoint = 0.25f;
+DUSK_GAME_DATA f32 JUTGamePad::CStick::sReleasePoint = 0.25f;
 
-u32 JUTGamePad::C3ButtonReset::sResetPattern = PAD_BUTTON_START | PAD_BUTTON_X | PAD_BUTTON_B;
+DUSK_GAME_DATA u32 JUTGamePad::C3ButtonReset::sResetPattern = PAD_BUTTON_START | PAD_BUTTON_X | PAD_BUTTON_B;
 
-u32 JUTGamePad::C3ButtonReset::sResetMaskPattern = 0x0000FFFF;
+DUSK_GAME_DATA u32 JUTGamePad::C3ButtonReset::sResetMaskPattern = 0x0000FFFF;
 
 void JUTGamePad::update() {
     if (mPortNum != EPortInvalid) {
@@ -269,7 +269,7 @@ void JUTGamePad::update() {
     }
 }
 
-JSUList<JUTGamePadLongPress> JUTGamePadLongPress::sPatternList(false);
+DUSK_GAME_DATA JSUList<JUTGamePadLongPress> JUTGamePadLongPress::sPatternList(false);
 
 void JUTGamePad::checkResetSwitch() {
     if (!JUTGamePad::C3ButtonReset::sResetOccurred) {
diff --git a/libs/JSystem/src/JUtility/JUTGraphFifo.cpp b/libs/JSystem/src/JUtility/JUTGraphFifo.cpp
index 1ffc0da27d..99bbfe7156 100644
--- a/libs/JSystem/src/JUtility/JUTGraphFifo.cpp
+++ b/libs/JSystem/src/JUtility/JUTGraphFifo.cpp
@@ -6,7 +6,7 @@
 
 static bool data_804514B8;
 
-JUTGraphFifo* JUTGraphFifo::sCurrentFifo;
+DUSK_GAME_DATA JUTGraphFifo* JUTGraphFifo::sCurrentFifo;
 
 JUTGraphFifo::JUTGraphFifo(u32 size) {
     mSize = ROUND(size, 0x20);
@@ -26,7 +26,7 @@ JUTGraphFifo::JUTGraphFifo(u32 size) {
     }
 }
 
-bool JUTGraphFifo::mGpStatus[5];
+DUSK_GAME_DATA bool JUTGraphFifo::mGpStatus[5];
 
 JUTGraphFifo::~JUTGraphFifo() {
     sCurrentFifo->save();
diff --git a/libs/JSystem/src/JUtility/JUTProcBar.cpp b/libs/JSystem/src/JUtility/JUTProcBar.cpp
index 81d55ed3f1..cfcf58fb5c 100644
--- a/libs/JSystem/src/JUtility/JUTProcBar.cpp
+++ b/libs/JSystem/src/JUtility/JUTProcBar.cpp
@@ -27,7 +27,7 @@ JUTProcBar::JUTProcBar() {
     mWatchHeap = NULL;
 }
 
-JUTProcBar* JUTProcBar::sManager;
+DUSK_GAME_DATA JUTProcBar* JUTProcBar::sManager;
 
 JUTProcBar::~JUTProcBar() {
     sManager = NULL;
diff --git a/libs/JSystem/src/JUtility/JUTResFont.cpp b/libs/JSystem/src/JUtility/JUTResFont.cpp
index 63afbc29aa..3f31961d1f 100644
--- a/libs/JSystem/src/JUtility/JUTResFont.cpp
+++ b/libs/JSystem/src/JUtility/JUTResFont.cpp
@@ -7,6 +7,8 @@
 #include "JSystem/JUtility/JUTConsole.h"
 #include <gx.h>
 
+#include "dusk/version.hpp"
+
 JUTResFont::JUTResFont() {
     initialize_state();
     JUTFont::initialize_state();
@@ -68,8 +70,16 @@ void JUTResFont::initJoinedTexture() {
 
     int pageCount = 0;
     u32 pageNumCells = block.numRows * block.numColumns;
-    for (u32 code = block.startCode; code < block.endCode; code += pageNumCells) {
-        pageCount += 1;
+
+    if (dusk::version::isRegionJpn()) {
+        pageCount = 1;
+        if (pageNumCells > 0 && block.endCode > block.startCode) {
+            pageCount = (block.endCode - block.startCode + pageNumCells - 1) / pageNumCells;
+        }
+    } else {
+        for (u32 code = block.startCode; code < block.endCode; code += pageNumCells) {
+            pageCount += 1;
+        }
     }
 
     mJoinedTextureHeight = block.textureHeight * pageCount;
@@ -143,7 +153,7 @@ void JUTResFont::countBlock() {
     }
 }
 
-IsLeadByte_func const JUTResFont::saoAboutEncoding_[3] = {
+DUSK_GAME_DATA IsLeadByte_func const JUTResFont::saoAboutEncoding_[3] = {
     JUTFont::isLeadByte_1Byte,
     JUTFont::isLeadByte_2Byte,
     JUTFont::isLeadByte_ShiftJIS,
@@ -273,12 +283,19 @@ f32 JUTResFont::drawChar_scale(f32 pos_x, f32 pos_y, f32 scale_x, f32 scale_y, i
 
     u16 texW  = mpGlyphBlocks[field_0x66]->textureWidth;
 #if TARGET_PC
-    u16 texH  = mJoinedTextureHeight;
+    // JUTCacheFont does not set mJoinedTextureHeight (it uses per-page textures via loadImage override).
+    // Fall back to the individual glyph block's textureHeight in that case.
+    u16 texH  = mJoinedTextureHeight > 0 ? (u16)mJoinedTextureHeight : (u16)mpGlyphBlocks[field_0x66]->textureHeight;
 #else
     u16 texH  = mpGlyphBlocks[field_0x66]->textureHeight;
 #endif
-    u16 cellW = mpGlyphBlocks[field_0x66]->cellWidth;
 
+#if AVOID_UB
+    if (texW == 0) texW = 1;
+    if (texH == 0) texH = 1;
+#endif
+
+    u16 cellW = mpGlyphBlocks[field_0x66]->cellWidth;
     u16 cellH = mpGlyphBlocks[field_0x66]->cellHeight;
     s32 u1 = (mWidth * 0x8000) / texW;
     s32 v1 = (mHeight * 0x8000) / texH;
diff --git a/libs/JSystem/src/JUtility/JUTVideo.cpp b/libs/JSystem/src/JUtility/JUTVideo.cpp
index 5586342f0e..663c357e17 100644
--- a/libs/JSystem/src/JUtility/JUTVideo.cpp
+++ b/libs/JSystem/src/JUtility/JUTVideo.cpp
@@ -8,11 +8,11 @@
 
 #include "JSystem/JKernel/JKRHeap.h"
 
-JUTVideo* JUTVideo::sManager;
+DUSK_GAME_DATA JUTVideo* JUTVideo::sManager;
 
-OSTick JUTVideo::sVideoLastTick;
+DUSK_GAME_DATA OSTick JUTVideo::sVideoLastTick;
 
-OSTick JUTVideo::sVideoInterval;
+DUSK_GAME_DATA OSTick JUTVideo::sVideoInterval;
 
 static bool data_80451544;
 
@@ -42,7 +42,7 @@ JUTVideo::JUTVideo(GXRenderModeObj const* param_0) {
     mRetraceCount = VIGetRetraceCount();
     field_0x10 = 1;
     field_0x18 = 0;
-    sVideoLastTick = OSGetTick();
+    sVideoLastTick = DUSK_IF_ELSE(static_cast<OSTick>(OSGetNativeTime()), OSGetTick());
     sVideoInterval = 670000;
     mPreRetraceCallback = VISetPreRetraceCallback(preRetraceProc);
     mPostRetraceCallback = VISetPostRetraceCallback(postRetraceProc);
@@ -68,8 +68,13 @@ void JUTVideo::preRetraceProc(u32 retrace_count) {
         (*sManager->mPreCallback)(retrace_count);
     }
 
-    OSTick tick = OSGetTick();
+    OSTick tick = DUSK_IF_ELSE(static_cast<OSTick>(OSGetNativeTime()), OSGetTick());
     sVideoInterval = tick - sVideoLastTick;
+#if TARGET_PC
+    if (sVideoInterval <= 0) {
+        sVideoInterval = 1;
+    }
+#endif
     sVideoLastTick = tick;
 
     JUTXfb* xfb = JUTXfb::getManager();
diff --git a/libs/JSystem/src/JUtility/JUTXfb.cpp b/libs/JSystem/src/JUtility/JUTXfb.cpp
index f04a5e93fc..ac66621243 100644
--- a/libs/JSystem/src/JUtility/JUTXfb.cpp
+++ b/libs/JSystem/src/JUtility/JUTXfb.cpp
@@ -33,7 +33,7 @@ JUTXfb::JUTXfb(GXRenderModeObj const* pObj, JKRHeap* pHeap, JUTXfb::EXfbNumber x
     }
 }
 
-JUTXfb* JUTXfb::sManager;
+DUSK_GAME_DATA JUTXfb* JUTXfb::sManager;
 
 JUTXfb::~JUTXfb() {
     for (int i = 0; i < 3; i++) {
diff --git a/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Os/dolphin/dolphin_trk.c b/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Os/dolphin/dolphin_trk.c
index 13a30383ba..2564e1298c 100644
--- a/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Os/dolphin/dolphin_trk.c
+++ b/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Os/dolphin/dolphin_trk.c
@@ -136,7 +136,7 @@ void TRK__read_aram(__REGISTER int c, __REGISTER u32 p2, void* p3) {
 }
 
 void TRK__write_aram(__REGISTER int c, __REGISTER u32 p2, void* p3) {
-    u8 buff[32] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 buff[32];
     u32 err;
     __REGISTER int count = c;
     __REGISTER u32 bf;
diff --git a/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Portable/msghndlr.c b/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Portable/msghndlr.c
index 36a33d75fa..f3b5901d5b 100644
--- a/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Portable/msghndlr.c
+++ b/libs/TRK_MINNOW_DOLPHIN/debugger/embedded/MetroTRK/Portable/msghndlr.c
@@ -85,7 +85,7 @@ DSError TRKDoSupportMask(TRKBuffer*) {
 }
 
 DSError TRKDoReadMemory(TRKBuffer* buffer) {
-    u8 buf[0x820] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 buf[0x820];
     size_t tempLength;
     int result;
     int replyErr;
@@ -158,7 +158,7 @@ DSError TRKDoReadMemory(TRKBuffer* buffer) {
 }
 
 DSError TRKDoWriteMemory(TRKBuffer* b) {
-    u8 buf[0x820] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 buf[0x820];
     size_t tempLength;
     int options;
     int result;
diff --git a/libs/dolphin/src/ax/AXAux.c b/libs/dolphin/src/ax/AXAux.c
index 7d392d8f1c..cf469197ee 100644
--- a/libs/dolphin/src/ax/AXAux.c
+++ b/libs/dolphin/src/ax/AXAux.c
@@ -3,8 +3,8 @@
 
 #include "__ax.h"
 
-static s32 __AXBufferAuxA[3][480] ATTRIBUTE_ALIGN(32);
-static s32 __AXBufferAuxB[3][480] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static s32 __AXBufferAuxA[3][480];
+ATTRIBUTE_ALIGN(32) static s32 __AXBufferAuxB[3][480];
 
 static void (* __AXCallbackAuxA)(void*, void*);
 static void (* __AXCallbackAuxB)(void*, void*);
diff --git a/libs/dolphin/src/ax/AXSPB.c b/libs/dolphin/src/ax/AXSPB.c
index 3729589b62..6fad9bae4b 100644
--- a/libs/dolphin/src/ax/AXSPB.c
+++ b/libs/dolphin/src/ax/AXSPB.c
@@ -3,7 +3,7 @@
 
 #include "__ax.h"
 
-static AXSPB __AXStudio ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static AXSPB __AXStudio;
 
 static s32 __AXSpbAL;
 static s32 __AXSpbAR;
diff --git a/libs/dolphin/src/ax/AXVPB.c b/libs/dolphin/src/ax/AXVPB.c
index e8cf663470..02b9db2c63 100644
--- a/libs/dolphin/src/ax/AXVPB.c
+++ b/libs/dolphin/src/ax/AXVPB.c
@@ -35,9 +35,9 @@ static u32 __AXAuxMixCycles[32] = {
 	0x000009E2, 0x00000E97
 };
 
-static AXPB __AXPB[AX_MAX_VOICES] ATTRIBUTE_ALIGN(32);
-static AXPBITDBUFFER __AXITD[AX_MAX_VOICES] ATTRIBUTE_ALIGN(32);
-static AXPBU __AXUpdates[AX_MAX_VOICES] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static AXPB __AXPB[AX_MAX_VOICES];
+ATTRIBUTE_ALIGN(32) static AXPBITDBUFFER __AXITD[AX_MAX_VOICES];
+ATTRIBUTE_ALIGN(32) static AXPBU __AXUpdates[AX_MAX_VOICES];
 static AXVPB __AXVPB[AX_MAX_VOICES];
 
 static u32 __AXMaxDspCycles;
diff --git a/libs/dolphin/src/ax/DSPCode.c b/libs/dolphin/src/ax/DSPCode.c
index 7ca0d067ba..a2f77e2805 100644
--- a/libs/dolphin/src/ax/DSPCode.c
+++ b/libs/dolphin/src/ax/DSPCode.c
@@ -3,7 +3,7 @@
 
 u16 axDspSlaveLength = (AX_DSP_SLAVE_LENGTH * 2);
 
-u16 axDspSlave[AX_DSP_SLAVE_LENGTH] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) u16 axDspSlave[AX_DSP_SLAVE_LENGTH] = {
 	0x0000, 0x0000, 0x029F, 0x0E88, 0x029F, 0x0E97,
 	0x029F, 0x0EB3, 0x029F, 0x0ED3, 0x029F, 0x0ED9,
 	0x029F, 0x0F0B, 0x029F, 0x0F11, 0x1302, 0x1303,
diff --git a/libs/dolphin/src/card/CARDUnlock.c b/libs/dolphin/src/card/CARDUnlock.c
index 48f64e500a..31138c2995 100644
--- a/libs/dolphin/src/card/CARDUnlock.c
+++ b/libs/dolphin/src/card/CARDUnlock.c
@@ -4,7 +4,7 @@
 
 #include "__card.h"
 
-static u8 CardData[352] ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT) = {
+ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT) static u8 CardData[352] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x02, 0xFF, 0x00, 0x21, 0x13, 0x06, 0x12, 0x03, 0x12, 0x04,
     0x13, 0x05, 0x00, 0x92, 0x00, 0xFF, 0x00, 0x88, 0xFF, 0xFF, 0x00, 0x89, 0xFF, 0xFF, 0x00, 0x8A, 0xFF, 0xFF, 0x00,
diff --git a/libs/dolphin/src/demo/DEMOAVX.c b/libs/dolphin/src/demo/DEMOAVX.c
index 39f5d8f554..6de1cfd01d 100644
--- a/libs/dolphin/src/demo/DEMOAVX.c
+++ b/libs/dolphin/src/demo/DEMOAVX.c
@@ -3,7 +3,7 @@
 #include <dolphin/demo.h>
 #include "sdk_math.h"
 
-static s16 __AVX_internal_buffer[3200] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static s16 __AVX_internal_buffer[3200];
 
 static void (*__AVX_save_isr)(void);
 
diff --git a/libs/dolphin/src/demo/DEMOFont.c b/libs/dolphin/src/demo/DEMOFont.c
index 48299131d9..3ea63d291e 100644
--- a/libs/dolphin/src/demo/DEMOFont.c
+++ b/libs/dolphin/src/demo/DEMOFont.c
@@ -1,7 +1,7 @@
 #include <dolphin/dolphin.h>
 #include <dolphin/demo.h>
 
-u32 DEMOFontBitmap[768] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) u32 DEMOFontBitmap[768] = {
     0x00000000,
     0x00000000,
     0x00000000,
diff --git a/libs/dolphin/src/gx/GXInit.c b/libs/dolphin/src/gx/GXInit.c
index c22f5acbd8..639c990d72 100644
--- a/libs/dolphin/src/gx/GXInit.c
+++ b/libs/dolphin/src/gx/GXInit.c
@@ -43,7 +43,7 @@ void* __piReg;
 GXBool __GXinBegin;
 #endif
 
-static u16 DefaultTexData[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u16 DefaultTexData[] = {
     0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
     0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
 };
diff --git a/libs/dolphin/src/mcc/mcc.c b/libs/dolphin/src/mcc/mcc.c
index fa75efe415..1d05d947a6 100644
--- a/libs/dolphin/src/mcc/mcc.c
+++ b/libs/dolphin/src/mcc/mcc.c
@@ -7,11 +7,11 @@ const char* __MCCVersion = "<< Dolphin SDK - MCC\tdebug build: Apr  5 2004 03:57
 const char* __MCCVersion = "<< Dolphin SDK - MCC\trelease build: Apr  5 2004 04:15:49 (0x2301) >>";
 #endif
 
-static MCC_ChannelInfo gChannelInfo[16] ATTRIBUTE_ALIGN(32);
-static char gStreamWork[32] ATTRIBUTE_ALIGN(32);
-static char m_szAdapterMode[32] ATTRIBUTE_ALIGN(32);
-static char m_szInitCode[32] ATTRIBUTE_ALIGN(32);
-static MCC_Info channelInfo[16] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static MCC_ChannelInfo gChannelInfo[16];
+ATTRIBUTE_ALIGN(32) static char gStreamWork[32];
+ATTRIBUTE_ALIGN(32) static char m_szAdapterMode[32];
+ATTRIBUTE_ALIGN(32) static char m_szInitCode[32];
+ATTRIBUTE_ALIGN(32) static MCC_Info channelInfo[16];
 
 volatile static BOOL gIsChannelinfoDirty = TRUE;
 
diff --git a/libs/dolphin/src/os/OSRtc.c b/libs/dolphin/src/os/OSRtc.c
index ee55fcc0e4..c4f9cb7233 100644
--- a/libs/dolphin/src/os/OSRtc.c
+++ b/libs/dolphin/src/os/OSRtc.c
@@ -3,7 +3,7 @@
 
 #include "__os.h"
 
-static SramControl Scb ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT);
+ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT) static SramControl Scb;
 
 // prototypes
 static int GetRTC(u32* rtc);
diff --git a/libs/freeverb/CMakeLists.txt b/libs/freeverb/CMakeLists.txt
index c0c12da293..d0275f62ac 100644
--- a/libs/freeverb/CMakeLists.txt
+++ b/libs/freeverb/CMakeLists.txt
@@ -7,3 +7,5 @@ add_library(freeverb
     allpass.cpp
     revmodel.cpp
 )
+target_include_directories(freeverb PRIVATE include/freeverb)
+target_include_directories(freeverb INTERFACE include)
diff --git a/libs/freeverb/allpass.hpp b/libs/freeverb/include/freeverb/allpass.hpp
similarity index 100%
rename from libs/freeverb/allpass.hpp
rename to libs/freeverb/include/freeverb/allpass.hpp
diff --git a/libs/freeverb/comb.hpp b/libs/freeverb/include/freeverb/comb.hpp
similarity index 100%
rename from libs/freeverb/comb.hpp
rename to libs/freeverb/include/freeverb/comb.hpp
diff --git a/libs/freeverb/denormals.h b/libs/freeverb/include/freeverb/denormals.h
similarity index 100%
rename from libs/freeverb/denormals.h
rename to libs/freeverb/include/freeverb/denormals.h
diff --git a/libs/freeverb/revmodel.hpp b/libs/freeverb/include/freeverb/revmodel.hpp
similarity index 100%
rename from libs/freeverb/revmodel.hpp
rename to libs/freeverb/include/freeverb/revmodel.hpp
diff --git a/libs/freeverb/tuning.h b/libs/freeverb/include/freeverb/tuning.h
similarity index 100%
rename from libs/freeverb/tuning.h
rename to libs/freeverb/include/freeverb/tuning.h
diff --git a/libs/revolution/src/card/CARDUnlock.c b/libs/revolution/src/card/CARDUnlock.c
index 93298297c8..1fad65efe4 100644
--- a/libs/revolution/src/card/CARDUnlock.c
+++ b/libs/revolution/src/card/CARDUnlock.c
@@ -3,7 +3,7 @@
 
 #include "__card.h"
 
-static u8 CardData[352] ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT) = {
+ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT) static u8 CardData[352] = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x02, 0xFF, 0x00, 0x21, 0x13, 0x06, 0x12, 0x03, 0x12, 0x04,
     0x13, 0x05, 0x00, 0x92, 0x00, 0xFF, 0x00, 0x88, 0xFF, 0xFF, 0x00, 0x89, 0xFF, 0xFF, 0x00, 0x8A, 0xFF, 0xFF, 0x00,
diff --git a/libs/revolution/src/dvd/dvd.c b/libs/revolution/src/dvd/dvd.c
index 0e5dbd0945..9e91f6e3f3 100644
--- a/libs/revolution/src/dvd/dvd.c
+++ b/libs/revolution/src/dvd/dvd.c
@@ -44,7 +44,7 @@ static u32 LastError;
 static BOOL ResetRequired;
 static u32 MotorState;
 static volatile OSTime LastResetEnd;
-static u32 __DVDNumTmdBytes ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 __DVDNumTmdBytes;
 static DVDGameTOC* GameToc;
 static DVDPartitionInfo* PartInfo;
 static DVDPartitionInfo* BootGameInfo;
@@ -80,10 +80,10 @@ static DVDCommandBlock DummyCommandBlock;
 static OSAlarm ResetAlarm;
 static OSAlarm CoverAlarm;
 
-static u8 __DVDGameTocBuffer[OSRoundUp32B(sizeof(DVDGameTOC) * 4)] ATTRIBUTE_ALIGN(32);
-static u8 __DVDPartInfoBuffer[OSRoundUp32B(sizeof(DVDPartitionInfo) * 4)] ATTRIBUTE_ALIGN(32);
-static u8 __DVDTmdBuffer[OSRoundUp32B(sizeof(ESTitleMeta))]  ATTRIBUTE_ALIGN(32);
-static u8 __DVDTicketViewBuffer[OSRoundUp32B(sizeof(ESTicketView))] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 __DVDGameTocBuffer[OSRoundUp32B(sizeof(DVDGameTOC) * 4)];
+ATTRIBUTE_ALIGN(32) static u8 __DVDPartInfoBuffer[OSRoundUp32B(sizeof(DVDPartitionInfo) * 4)];
+ATTRIBUTE_ALIGN(32) static u8 __DVDTmdBuffer[OSRoundUp32B(sizeof(ESTitleMeta))];
+ATTRIBUTE_ALIGN(32) static u8 __DVDTicketViewBuffer[OSRoundUp32B(sizeof(ESTicketView))];
 
 static OSAlarm FatalAlarm;
 DVDCommandBlock __DVDStopMotorCommandBlock;
diff --git a/libs/revolution/src/dvd/dvdDeviceError.c b/libs/revolution/src/dvd/dvdDeviceError.c
index 316346461f..6fa74234ee 100644
--- a/libs/revolution/src/dvd/dvdDeviceError.c
+++ b/libs/revolution/src/dvd/dvdDeviceError.c
@@ -5,7 +5,7 @@
 #include "__os.h"
 #include "__dvd.h"
 
-static u8 CheckBuffer[32] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 CheckBuffer[32];
 
 static volatile BOOL lowDone = TRUE;
 static volatile u32 lowIntType = 0;
diff --git a/libs/revolution/src/dvd/dvd_broadway.c b/libs/revolution/src/dvd/dvd_broadway.c
index ab4840791f..c2e8aef89d 100644
--- a/libs/revolution/src/dvd/dvd_broadway.c
+++ b/libs/revolution/src/dvd/dvd_broadway.c
@@ -8,15 +8,15 @@ static volatile u8 requestInProgress = FALSE;
 static u8 breakRequested;
 static u8 callbackInProgress;
 
-static u32 registerBuf[8] ATTRIBUTE_ALIGN(32);
-static u32 statusRegister[8] ATTRIBUTE_ALIGN(32);
-static u32 controlRegister[8] ATTRIBUTE_ALIGN(32);
-static s32 lastTicketError[8] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 registerBuf[8];
+ATTRIBUTE_ALIGN(32) static u32 statusRegister[8];
+ATTRIBUTE_ALIGN(32) static u32 controlRegister[8];
+ATTRIBUTE_ALIGN(32) static s32 lastTicketError[8];
 
 static u32 readLength;
 static u32 spinUpValue;
 
-static diRegVals_t diRegValCache ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static diRegVals_t diRegValCache;
 
 static u8 DVDLowInitCalled = FALSE;
 
@@ -42,8 +42,8 @@ typedef struct dvdContext {
 
 static int freeDvdContext = 0;
 static u8 dvdContextsInited = FALSE;
-static dvdContext_t dvdContexts[4] ATTRIBUTE_ALIGN(32);
-static IOSIoVector ioVec[10] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static dvdContext_t dvdContexts[4];
+ATTRIBUTE_ALIGN(32) static IOSIoVector ioVec[10];
 
 static void* ddrAllocAligned32(const int size) {
     void* low, *high;
diff --git a/libs/revolution/src/dvd/dvderror.c b/libs/revolution/src/dvd/dvderror.c
index 7f1e8e52ad..8b12465825 100644
--- a/libs/revolution/src/dvd/dvderror.c
+++ b/libs/revolution/src/dvd/dvderror.c
@@ -11,8 +11,8 @@ static NANDCommandBlock NandCb;
 static NANDFileInfo NandInfo;
 static DVDCBCallback Callback;
 static u32 NextOffset;
-DVDErrorInfo __ErrorInfo ATTRIBUTE_ALIGN(32);
-DVDErrorInfo __FirstErrorInfo ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) DVDErrorInfo __ErrorInfo;
+ATTRIBUTE_ALIGN(32) DVDErrorInfo __FirstErrorInfo;
 
 void cbForNandClose(s32 result, NANDCommandBlock* block) {
     if (Callback) {
diff --git a/libs/revolution/src/esp/esp.c b/libs/revolution/src/esp/esp.c
index 68899e2598..aec3e862b1 100644
--- a/libs/revolution/src/esp/esp.c
+++ b/libs/revolution/src/esp/esp.c
@@ -33,7 +33,7 @@ s32 ESP_CloseLib(void) {
 
 s32 ESP_LaunchTitle(u64 titleID, ESTicketView* pTicketView) {
     s32 ret = 0;
-    u8 buf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 buf[256];
     IOSIoVector* vec = (IOSIoVector*)(buf + 208);
     u64* id = (u64*)buf;
 
@@ -63,7 +63,7 @@ out:
 
 s32 ESP_GetTicketViews(ESTitleId titleId, ESTicketView* ticketViewList, u32* ticketViewCnt) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
     ESTitleId* p1 = (ESTitleId*)__esBuf;
     u32* p2 = (u32*)(__esBuf + 32);
@@ -111,7 +111,7 @@ out:
 
 s32 ESP_DiGetTicketView(const void* ticket, ESTicketView* ticketView) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
 
     if (__esFd < 0 || ticketView == NULL) {
@@ -142,7 +142,7 @@ out:
 
 s32 ESP_DiGetTmd(ESTitleMeta* tmd, u32* tmdSize) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
     u32* p1 = (u32*)__esBuf;
 
@@ -184,7 +184,7 @@ out:
 
 s32 ESP_GetTmdView(ESTitleId titleId, ESTmdView* tmdView, u32* size) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
     ESTitleId* p1 = (ESTitleId*)__esBuf;
     u32* p2 = (u32*)(__esBuf + 32);
@@ -233,7 +233,7 @@ out:
 
 s32 ESP_GetDataDir(ESTitleId titleId, char* dataDir) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
     ESTitleId* p1 = (ESTitleId*)__esBuf;
 
@@ -260,7 +260,7 @@ out:
 
 s32 ESP_GetTitleId(ESTitleId* titleId) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
 
     if (__esFd < 0 || titleId == NULL) {
@@ -283,7 +283,7 @@ out:
 
 s32 ESP_GetConsumption(ESTicketId ticketId, ESLpEntry* entries, u32* nEntries) {
     s32 rv = 0;
-    u8 __esBuf[256] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 __esBuf[256];
     IOSIoVector* v = (IOSIoVector*)(__esBuf + 256 - 6 * sizeof(IOSIoVector));
     ESTicketId* p1 = (ESTicketId*)__esBuf;
     u32* p2 = (u32*)(__esBuf + 32);
diff --git a/libs/revolution/src/fs/fs.c b/libs/revolution/src/fs/fs.c
index 1e5f601198..34397254c1 100644
--- a/libs/revolution/src/fs/fs.c
+++ b/libs/revolution/src/fs/fs.c
@@ -25,7 +25,7 @@ typedef struct isfs_GetUsage {
 } isfs_GetUsage;
 
 typedef struct __isfsCtxt {
-    u8 ioBuf[ROUNDUP(256)] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 ioBuf[ROUNDUP(256)];
     ISFSCallback cb;
     void* ctxt;
     u32 func;
diff --git a/libs/revolution/src/gx/GXInit.c b/libs/revolution/src/gx/GXInit.c
index 0504827170..0ae463d84d 100644
--- a/libs/revolution/src/gx/GXInit.c
+++ b/libs/revolution/src/gx/GXInit.c
@@ -49,7 +49,7 @@ volatile void* __piReg;
 GXBool __GXinBegin;
 #endif
 
-static u16 DefaultTexData[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u16 DefaultTexData[] = {
     0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
     0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
 };
diff --git a/libs/revolution/src/homebuttonLib/nw4hbm/lyt/picture.h b/libs/revolution/src/homebuttonLib/nw4hbm/lyt/picture.h
index 4a77129ea7..c34a092a61 100644
--- a/libs/revolution/src/homebuttonLib/nw4hbm/lyt/picture.h
+++ b/libs/revolution/src/homebuttonLib/nw4hbm/lyt/picture.h
@@ -34,7 +34,7 @@ namespace nw4hbm {
 
         private:
             /* 0x00 (base) */
-            /* 0xD4 */ ut::Color mVtxColors[VERTEXCOLOR_MAX] ATTRIBUTE_ALIGN(4);
+            /* 0xD4 */ ATTRIBUTE_ALIGN(4) ut::Color mVtxColors[VERTEXCOLOR_MAX];
             /* 0xE4 */ detail::TexCoordAry mTexCoordAry;
         };
 
diff --git a/libs/revolution/src/homebuttonLib/nw4hbm/snd/StrmPlayer.h b/libs/revolution/src/homebuttonLib/nw4hbm/snd/StrmPlayer.h
index eae08ba82d..45f682b4b9 100644
--- a/libs/revolution/src/homebuttonLib/nw4hbm/snd/StrmPlayer.h
+++ b/libs/revolution/src/homebuttonLib/nw4hbm/snd/StrmPlayer.h
@@ -58,7 +58,7 @@ namespace nw4hbm {
                 public:
                     /* 0x14 */ ut::LinkListNode mLinkNode;
 
-                    static u8 mMramBuf[LOAD_BUFFER_SIZE] ATTRIBUTE_ALIGN(32);
+                    ATTRIBUTE_ALIGN(32) static u8 mMramBuf[LOAD_BUFFER_SIZE];
                 };
                 typedef ut::LinkList<LoadCommand, offsetof(LoadCommand, mLinkNode)> LoadCommandList;
 
diff --git a/libs/revolution/src/ipc/ipcclt.c b/libs/revolution/src/ipc/ipcclt.c
index 6976775218..449e94ecd0 100644
--- a/libs/revolution/src/ipc/ipcclt.c
+++ b/libs/revolution/src/ipc/ipcclt.c
@@ -24,7 +24,7 @@ static u32 __relnchFl = 0;
 
 typedef struct IOSRpcRequest {
     IOSResourceRequest request;
-    IOSIpcCb cb ATTRIBUTE_ALIGN(32); // I am assuming this is aligned due to where cbArg is stored, and I see nothing between cb and callback_arg?
+    ATTRIBUTE_ALIGN(32) IOSIpcCb cb; // I am assuming this is aligned due to where cbArg is stored, and I see nothing between cb and callback_arg?
     void* callback_arg;
     u32 relaunch_flag;
     OSThreadQueue thread_queue;
@@ -37,7 +37,7 @@ static IOSRpcRequest* __relnchRpcSave = 0;
 
 #define ROUNDUP(sz)     (((u32)(sz) + (IPC_BUF_CNT / 2 - 1)) & ~(u32)(IPC_BUF_CNT / 2 - 1))
 
-static u8 __rpcBuf[ROUNDUP(sizeof(IOSRpcRequest))] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 __rpcBuf[ROUNDUP(sizeof(IOSRpcRequest))];
 
 static struct {
     u32 rcount;
diff --git a/libs/revolution/src/nand/NANDCore.c b/libs/revolution/src/nand/NANDCore.c
index c93ec26c9c..8a9818197f 100644
--- a/libs/revolution/src/nand/NANDCore.c
+++ b/libs/revolution/src/nand/NANDCore.c
@@ -33,8 +33,8 @@ enum LibState {
 };
 
 static enum LibState s_libState = STATE_NOT_INITIALIZED;
-static char s_currentDir[64] ATTRIBUTE_ALIGN(32) = "/";
-static char s_homeDir[64] ATTRIBUTE_ALIGN(32) = "";
+ATTRIBUTE_ALIGN(32) static char s_currentDir[64] = "/";
+ATTRIBUTE_ALIGN(32) static char s_homeDir[64] = "";
 
 static BOOL nandOnShutdown(BOOL final, u32 event);
 void nandConvertPath(char* abspath, const char* wd, const char* relpath);
@@ -262,7 +262,7 @@ s32 nandConvertErrorCode(const ISFSError err) {
     for (; i < sizeof(ERRMAP) / 4; i = i + 2) {
         if (ERRMAP[i] == err) {
             if (err == ISFS_ERROR_ECC_CRIT || err == ISFS_ERROR_HMAC || err == ISFS_ERROR_UNKNOWN || err == IOS_ERROR_UNKNOWN || err == IOS_ERROR_ECC_CRIT) {
-                char buf[128] ATTRIBUTE_ALIGN(64);
+                ATTRIBUTE_ALIGN(64) char buf[128];
                 sprintf(buf, "ISFS error code: %d", err);
                 NANDLoggingAddMessageAsync(nandLoggingCallback, err, buf);
             }
@@ -279,7 +279,7 @@ s32 nandConvertErrorCode(const ISFSError err) {
 
     OSReport("CAUTION!  Unexpected error code [%d] was found.\n", err);
     {
-        char buf[128] ATTRIBUTE_ALIGN(64);
+        ATTRIBUTE_ALIGN(64) char buf[128];
         sprintf(buf, "ISFS unexpected error code: %d", err);
         NANDLoggingAddMessageAsync(nandLoggingCallback, err, buf);
     }
diff --git a/libs/revolution/src/nand/NANDLogging.c b/libs/revolution/src/nand/NANDLogging.c
index 8e620895d5..409fbad527 100644
--- a/libs/revolution/src/nand/NANDLogging.c
+++ b/libs/revolution/src/nand/NANDLogging.c
@@ -7,7 +7,7 @@
 static IOSFd s_fd = -255;
 static IOSError s_err = ISFS_ERROR_UNKNOWN;
 static int s_stage;
-static char s_message[256] ATTRIBUTE_ALIGN(64);
+ATTRIBUTE_ALIGN(64) static char s_message[256];
 static NANDLoggingCallback s_callback = 0;
 
 static void asyncRoutine(ISFSError, void*);
@@ -70,8 +70,8 @@ static void callbackRoutine(BOOL result) {
 
 static void asyncRoutine(ISFSError result, void *ctxt) {
     ISFSError ret = ISFS_ERROR_UNKNOWN;
-    static char s_rBuf[256] ATTRIBUTE_ALIGN(64);
-    static char s_wBuf[256] ATTRIBUTE_ALIGN(64);
+    ATTRIBUTE_ALIGN(64) static char s_rBuf[256];
+    ATTRIBUTE_ALIGN(64) static char s_wBuf[256];
     ++s_stage;
 
     if (s_stage == 2) {
diff --git a/libs/revolution/src/nand/nand.c b/libs/revolution/src/nand/nand.c
index 6155789690..1fd2640660 100644
--- a/libs/revolution/src/nand/nand.c
+++ b/libs/revolution/src/nand/nand.c
@@ -293,7 +293,7 @@ s32 NANDMove(const char* path, const char* destDir) {
 }
 
 static ISFSError nandGetFileStatus(IOSFd fd, u32* length, u32* pos) {
-    ISFSFileStats fstat ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) ISFSFileStats fstat;
     ISFSError result = ISFS_GetFileStats(fd, &fstat);
     if (result == ISFS_ERROR_OK) {
         if (length) {
diff --git a/libs/revolution/src/os/OSLaunch.c b/libs/revolution/src/os/OSLaunch.c
index 2c57906e95..f82f2ef19f 100644
--- a/libs/revolution/src/os/OSLaunch.c
+++ b/libs/revolution/src/os/OSLaunch.c
@@ -8,7 +8,7 @@ void __OSRelaunchTitle(u32 resetCode) {
     s32 rc = 0;
     u32 ticketCnt = 1;
     ESTicketView* tik = NULL;
-    ESTitleId titleId ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) ESTitleId titleId;
     __OSPlayTimeType type = OSPLAYTIME_PERMANENT;
     u32 remain = 0;
     u8* bi2 = NULL;
diff --git a/libs/revolution/src/os/OSNet.c b/libs/revolution/src/os/OSNet.c
index e68c789734..b749532494 100644
--- a/libs/revolution/src/os/OSNet.c
+++ b/libs/revolution/src/os/OSNet.c
@@ -85,7 +85,7 @@ NWC24Err NWC24iSynchronizeRtcCounter(BOOL param_0) {
 }
 
 NWC24Err NWC24SuspendScheduler(void) {
-    static u8 susResult[0x20] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) static u8 susResult[0x20];
     NWC24Err rt = NWC24_OK;
     NWC24Err closeRt = NWC24_OK;
     IOSFd fd;
diff --git a/libs/revolution/src/os/OSPlayRecord.c b/libs/revolution/src/os/OSPlayRecord.c
index a1499e71b7..b9743d9946 100644
--- a/libs/revolution/src/os/OSPlayRecord.c
+++ b/libs/revolution/src/os/OSPlayRecord.c
@@ -2,7 +2,7 @@
 #include <revolution/nand.h>
 
 static BOOL PlayRecordGet = FALSE;
-static OSPlayRecord PlayRecord ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static OSPlayRecord PlayRecord;
 static NANDFileInfo FileInfo;
 static NANDCommandBlock Block;
 static s32 PlayRecordState = 9;
diff --git a/libs/revolution/src/os/OSPlayTime.c b/libs/revolution/src/os/OSPlayTime.c
index 653afad7db..675d88d020 100644
--- a/libs/revolution/src/os/OSPlayTime.c
+++ b/libs/revolution/src/os/OSPlayTime.c
@@ -7,7 +7,7 @@
 
 #include "__os.h"
 
-OSAlarm __OSExpireAlarm ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) OSAlarm __OSExpireAlarm;
 OSTime __OSExpireTime;
 OSPlayTimeCallbackFunc __OSExpireCallback;
 BOOL __OSExpireSetExpiredFlag;
@@ -103,7 +103,7 @@ BOOL __OSWriteExpiredFlag(void) {
     s32 rv = 0;
     NANDFileInfo nInfo;
     BOOL openNInfo = FALSE;
-    u8 titleId[32] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 titleId[32];
 
     rv = NANDPrivateCreate("/shared2/expired", 63, 0);
 
@@ -162,7 +162,7 @@ BOOL __OSWriteExpiredFlagIfSet(void) {
 void* __OSPlayTimeRebootThread(void* args) {
     BOOL enabled;
     u32 frames, fadeShift = 1;
-    __OSExpireAIFadeStruct aiFade ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) __OSExpireAIFadeStruct aiFade;
 
     __OSExpireAIFade = &aiFade;
     memset(__OSExpireAIFade, 0, sizeof(__OSExpireAIFadeStruct));
@@ -227,9 +227,9 @@ out:
 s32 __OSGetPlayTime(ESTicketView* ticket, __OSPlayTimeType* type, u32* playTime) {
 	s32 rv;
 	u32 i;
-	ESLpEntry lpEntry[8] ATTRIBUTE_ALIGN(32);
+	ATTRIBUTE_ALIGN(32) ESLpEntry lpEntry[8];
 	u32 numCc = 0, seenOther = 0;
-	ESTicketView ticketAligned ATTRIBUTE_ALIGN(32);
+	ATTRIBUTE_ALIGN(32) ESTicketView ticketAligned;
 
     ASSERTLINE(601, ticket && type && playTime);
 
@@ -288,7 +288,7 @@ out:
 
 s32 __OSGetPlayTimeCurrent(__OSPlayTimeType* type, u32* playTime) {
     s32 rv;
-    ESTicketView ticket ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) ESTicketView ticket;
 
     ASSERTLINE(676, type && playTime);
 
diff --git a/libs/revolution/src/os/OSRtc.c b/libs/revolution/src/os/OSRtc.c
index 11fa04e05d..d5fa89ee54 100644
--- a/libs/revolution/src/os/OSRtc.c
+++ b/libs/revolution/src/os/OSRtc.c
@@ -3,7 +3,7 @@
 
 #include "__os.h"
 
-static SramControl Scb ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT);
+ATTRIBUTE_ALIGN(DOLPHIN_ALIGNMENT) static SramControl Scb;
 
 // prototypes
 static int GetRTC(u32* rtc);
diff --git a/libs/revolution/src/os/OSStateFlags.c b/libs/revolution/src/os/OSStateFlags.c
index 723069d5a6..9283c57499 100644
--- a/libs/revolution/src/os/OSStateFlags.c
+++ b/libs/revolution/src/os/OSStateFlags.c
@@ -2,7 +2,7 @@
 #include <revolution/nand.h>
 #include <cstring>
 
-static OSStateFlags StateFlags ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static OSStateFlags StateFlags;
 
 static u32 CheckSum(OSStateFlags* flags) {
     u32* ptr, i, sum;
diff --git a/libs/revolution/src/os/OSStateTM.c b/libs/revolution/src/os/OSStateTM.c
index a81de612cf..d08bf5e6f6 100644
--- a/libs/revolution/src/os/OSStateTM.c
+++ b/libs/revolution/src/os/OSStateTM.c
@@ -5,14 +5,14 @@
 
 #include <revolution/private/iosrestypes.h>
 
-static u32 StmImInBuf[8] ATTRIBUTE_ALIGN(32);
-static u32 StmImOutBuf[8] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 StmImInBuf[8];
+ATTRIBUTE_ALIGN(32) static u32 StmImOutBuf[8];
 
-static u32 StmVdInBuf[8] ATTRIBUTE_ALIGN(32);
-static u32 StmVdOutBuf[8] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 StmVdInBuf[8];
+ATTRIBUTE_ALIGN(32) static u32 StmVdOutBuf[8];
 
-static u32 StmEhInBuf[8] ATTRIBUTE_ALIGN(32);
-static u32 StmEhOutBuf[8] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 StmEhInBuf[8];
+ATTRIBUTE_ALIGN(32) static u32 StmEhOutBuf[8];
 
 static OSResetCallback ResetCallback;
 static OSPowerCallback PowerCallback;
diff --git a/libs/revolution/src/os/OSThread.c b/libs/revolution/src/os/OSThread.c
index dbe745d17a..447709a17d 100644
--- a/libs/revolution/src/os/OSThread.c
+++ b/libs/revolution/src/os/OSThread.c
@@ -873,4 +873,4 @@ void* OSGetThreadSpecific(s32 index) {
 
 #include "global.h"
 extern u8 Debug_BBA_804516D0;
-u8 Debug_BBA_804516D0 ATTRIBUTE_ALIGN(8);
+ATTRIBUTE_ALIGN(8) u8 Debug_BBA_804516D0;
diff --git a/libs/revolution/src/sc/scsystem.c b/libs/revolution/src/sc/scsystem.c
index 74d78e6bfc..a03fe7b3b7 100644
--- a/libs/revolution/src/sc/scsystem.c
+++ b/libs/revolution/src/sc/scsystem.c
@@ -75,8 +75,8 @@ static const char ConfDirName[] = "/shared2/sys";
 static const char ConfFileName[] = "/shared2/sys/SYSCONF";
 static const char ProductInfoFileName[] = "/title/00000001/00000002/data/setting.txt";
 
-static u8 ConfBuf[0x4000] ATTRIBUTE_ALIGN(32);
-static u8 ConfBufForFlush[0x4000] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 ConfBuf[0x4000];
+ATTRIBUTE_ALIGN(32) static u8 ConfBufForFlush[0x4000];
 
 static u8 Initialized;
 static u8 DirtyFlag;
diff --git a/libs/revolution/src/wpad/WPAD.c b/libs/revolution/src/wpad/WPAD.c
index 20e7509da3..3a0591f396 100644
--- a/libs/revolution/src/wpad/WPAD.c
+++ b/libs/revolution/src/wpad/WPAD.c
@@ -262,7 +262,7 @@ void WPADiManageHandler(OSAlarm*, OSContext*) {
     BTA_HhGetAclQueueInfo();
 }
 
-u8 __WPADiManageHandlerStack[4096] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) u8 __WPADiManageHandlerStack[4096];
 
 void WPADiManageHandler0(OSAlarm* alarm, OSContext* context) {
     OSSwitchFiberEx((u32)alarm, (u32)context, 0, 0, (u32)WPADiManageHandler, (u32)(__WPADiManageHandlerStack + sizeof(__WPADiManageHandlerStack)));
diff --git a/libs/revolution/src/wud/WUD.c b/libs/revolution/src/wud/WUD.c
index 72a2c9b60b..deef3b2624 100644
--- a/libs/revolution/src/wud/WUD.c
+++ b/libs/revolution/src/wud/WUD.c
@@ -41,7 +41,7 @@ WUDControlBlock _wcb;
 WUDDevInfo _work;
 static WUDDiscResp _discResp;
 SCBtDeviceInfoArray _scArray;
-u8 __WUDHandlerStack[0x1000] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) u8 __WUDHandlerStack[0x1000];
 
 extern u8 _scFlush;
 
diff --git a/mods/ao_mod/CMakeLists.txt b/mods/ao_mod/CMakeLists.txt
new file mode 100644
index 0000000000..7304654d0c
--- /dev/null
+++ b/mods/ao_mod/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.25)
+project(ao_mod CXX)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(DUSK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../.." CACHE PATH "Path to dusk source root")
+    option(DUSK_MOD_USE_FULL_TREE "Use full build instead of the minimal mod SDK" OFF)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    if (DUSK_MOD_USE_FULL_TREE)
+        add_subdirectory("${DUSK_DIR}" dusk EXCLUDE_FROM_ALL)
+    else ()
+        add_subdirectory("${DUSK_DIR}/sdk" dusk-sdk EXCLUDE_FROM_ALL)
+    endif ()
+endif ()
+
+add_mod(ao_mod
+    FEATURES webgpu
+    SOURCES  src/mod.cpp
+    MOD_JSON mod.json
+    RES_DIR  res
+)
diff --git a/mods/ao_mod/mod.json b/mods/ao_mod/mod.json
new file mode 100644
index 0000000000..9019cf335d
--- /dev/null
+++ b/mods/ao_mod/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "dev.twilitrealm.ao_mod",
+  "name": "[Demo] Ambient Occlusion",
+  "version": "1.0.0",
+  "author": "Twilit Realm",
+  "description": "Ground-truth ambient occlusion (GTAO) computed from the scene depth buffer and composited over the game. Ported from Bevy Engine's SSAO and Intel XeGTAO."
+}
diff --git a/mods/ao_mod/res/composite.wgsl b/mods/ao_mod/res/composite.wgsl
new file mode 100644
index 0000000000..fa3a0101b8
--- /dev/null
+++ b/mods/ao_mod/res/composite.wgsl
@@ -0,0 +1,161 @@
+// Fullscreen composite: multiplies the denoised ambient-occlusion visibility over the scene.
+//
+// Debug views:
+//   1 = raw AO visibility as grayscale
+//   2 = view-space normals reconstructed from depth (keep in sync with gtao.wgsl)
+//   3 = the preprocessed depth input
+//   4 = depth staircase detector
+
+struct Uniforms {
+    projection: mat4x4f,
+    inverse_projection: mat4x4f,
+    size: vec2f,        // AO texture size in pixels (may be half the render size)
+    inv_size: vec2f,
+    depth_scale: vec2f,
+    effect_radius: f32,
+    intensity: f32,
+    slice_count: f32,
+    samples_per_slice_side: f32,
+    debug_view: u32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var ambient_occlusion: texture_2d<f32>;
+@group(0) @binding(1) var preprocessed_depth: texture_2d<f32>;
+@group(0) @binding(2) var scene_depth_raw: texture_2d<f32>;
+@group(0) @binding(3) var<uniform> uniforms: Uniforms;
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) uv: vec2f,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) index: u32) -> VertexOutput {
+    // Fullscreen triangle
+    var out: VertexOutput;
+    let uv = vec2f(f32((index << 1u) & 2u), f32(index & 2u));
+    out.position = vec4f(uv * vec2f(2.0, -2.0) + vec2f(-1.0, 1.0), 0.0, 1.0);
+    out.uv = uv;
+    return out;
+}
+
+// Manual bilinear sample (r32float is unfilterable without optional device features)
+fn sample_visibility(uv: vec2f) -> f32 {
+    let coordinates = uv * uniforms.size - 0.5;
+    let base = floor(coordinates);
+    let fraction = coordinates - base;
+    let max_coordinates = vec2i(uniforms.size) - 1i;
+    let p00 = clamp(vec2i(base), vec2i(0i), max_coordinates);
+    let p11 = clamp(vec2i(base) + 1i, vec2i(0i), max_coordinates);
+    let v00 = textureLoad(ambient_occlusion, vec2i(p00.x, p00.y), 0i).r;
+    let v10 = textureLoad(ambient_occlusion, vec2i(p11.x, p00.y), 0i).r;
+    let v01 = textureLoad(ambient_occlusion, vec2i(p00.x, p11.y), 0i).r;
+    let v11 = textureLoad(ambient_occlusion, vec2i(p11.x, p11.y), 0i).r;
+    let top = mix(v00, v10, fraction.x);
+    let bottom = mix(v01, v11, fraction.x);
+    return mix(top, bottom, fraction.y);
+}
+
+fn load_depth(pixel_coordinates: vec2<i32>) -> f32 {
+    let coordinates = clamp(pixel_coordinates, vec2<i32>(0i), vec2<i32>(uniforms.size) - 1i);
+    return textureLoad(preprocessed_depth, coordinates, 0i).r;
+}
+
+fn reconstruct_view_space_position(depth: f32, uv: vec2f) -> vec3f {
+    let clip_xy = vec2f(uv.x * 2.0 - 1.0, 1.0 - 2.0 * uv.y);
+    let t = uniforms.inverse_projection * vec4f(clip_xy, depth, 1.0);
+    return t.xyz / t.w;
+}
+
+fn view_position_at(pixel_coordinates: vec2<i32>) -> vec3f {
+    let depth = load_depth(pixel_coordinates);
+    let uv = (vec2f(pixel_coordinates) + 0.5) * uniforms.inv_size;
+    return reconstruct_view_space_position(depth, uv);
+}
+
+fn reconstruct_normal(pixel_coordinates: vec2<i32>, pixel_position: vec3f, depth_center: f32) -> vec3f {
+    let depth_left1 = load_depth(pixel_coordinates + vec2<i32>(-1i, 0i));
+    let depth_left2 = load_depth(pixel_coordinates + vec2<i32>(-2i, 0i));
+    let depth_right1 = load_depth(pixel_coordinates + vec2<i32>(1i, 0i));
+    let depth_right2 = load_depth(pixel_coordinates + vec2<i32>(2i, 0i));
+    let depth_top1 = load_depth(pixel_coordinates + vec2<i32>(0i, -1i));
+    let depth_top2 = load_depth(pixel_coordinates + vec2<i32>(0i, -2i));
+    let depth_bottom1 = load_depth(pixel_coordinates + vec2<i32>(0i, 1i));
+    let depth_bottom2 = load_depth(pixel_coordinates + vec2<i32>(0i, 2i));
+
+    let use_left = abs(2.0 * depth_left1 - depth_left2 - depth_center) <
+        abs(2.0 * depth_right1 - depth_right2 - depth_center);
+    let use_top = abs(2.0 * depth_top1 - depth_top2 - depth_center) <
+        abs(2.0 * depth_bottom1 - depth_bottom2 - depth_center);
+
+    var ddx: vec3f;
+    if use_left {
+        ddx = pixel_position - view_position_at(pixel_coordinates + vec2<i32>(-1i, 0i));
+    } else {
+        ddx = view_position_at(pixel_coordinates + vec2<i32>(1i, 0i)) - pixel_position;
+    }
+    var ddy: vec3f;
+    if use_top {
+        ddy = pixel_position - view_position_at(pixel_coordinates + vec2<i32>(0i, -1i));
+    } else {
+        ddy = view_position_at(pixel_coordinates + vec2<i32>(0i, 1i)) - pixel_position;
+    }
+
+    var normal = normalize(cross(ddy, ddx));
+    if dot(normal, pixel_position) > 0.0 {
+        normal = -normal;
+    }
+    return normal;
+}
+
+// Raw-snapshot variant of load_depth for the staircase view
+fn load_raw_depth(pixel_coordinates: vec2<i32>) -> f32 {
+    let size = vec2<i32>(textureDimensions(scene_depth_raw));
+    let coordinates = clamp(pixel_coordinates, vec2<i32>(0i), size - 1i);
+    return textureLoad(scene_depth_raw, coordinates, 0i).r;
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4f {
+    if uniforms.debug_view == 2u {
+        // Reconstructed view-space normals, [-1,1] -> RGB
+        let pixel = vec2<i32>(in.uv * uniforms.size);
+        let depth = load_depth(pixel);
+        let uv = (vec2f(pixel) + 0.5) * uniforms.inv_size;
+        let position = reconstruct_view_space_position(depth, uv);
+        let normal = reconstruct_normal(pixel, position, depth);
+        return vec4f(normal * 0.5 + 0.5, 1.0);
+    }
+    if uniforms.debug_view == 3u {
+        // Preprocessed depth as an exponential distance gradient (white = near, black = far)
+        let pixel = vec2<i32>(in.uv * uniforms.size);
+        let position = view_position_at(pixel);
+        let value = exp(-max(-position.z, 0.0) * 0.0003);
+        return vec4f(value, value, value, 1.0);
+    }
+    if uniforms.debug_view == 4u {
+        // Staircase detector on the raw snapshot depth
+        let size = vec2f(textureDimensions(scene_depth_raw));
+        let pixel = vec2<i32>(in.uv * size);
+        let d_center = load_raw_depth(pixel);
+        let d_left = load_raw_depth(pixel + vec2<i32>(-1i, 0i));
+        let d_right = load_raw_depth(pixel + vec2<i32>(1i, 0i));
+        let d_top = load_raw_depth(pixel + vec2<i32>(0i, -1i));
+        let d_bottom = load_raw_depth(pixel + vec2<i32>(0i, 1i));
+        let gradient_x = abs(d_right - d_left) * 0.5;
+        let curvature_x = abs(d_right - 2.0 * d_center + d_left);
+        let gradient_y = abs(d_bottom - d_top) * 0.5;
+        let curvature_y = abs(d_bottom - 2.0 * d_center + d_top);
+        let ratio_x = curvature_x / max(gradient_x, 1e-12);
+        let ratio_y = curvature_y / max(gradient_y, 1e-12);
+        return vec4f(saturate(ratio_x), saturate(ratio_y), 0.0, 1.0);
+    }
+
+    let visibility = sample_visibility(in.uv);
+    if uniforms.debug_view == 1u {
+        return vec4f(visibility, visibility, visibility, 1.0);
+    }
+    let value = mix(1.0, visibility, uniforms.intensity);
+    return vec4f(value, value, value, 1.0);
+}
diff --git a/mods/ao_mod/res/denoise.wgsl b/mods/ao_mod/res/denoise.wgsl
new file mode 100644
index 0000000000..b947b1bd04
--- /dev/null
+++ b/mods/ao_mod/res/denoise.wgsl
@@ -0,0 +1,108 @@
+// 3x3 bilaterial filter (edge-preserving blur)
+// https://people.csail.mit.edu/sparis/bf_course/course_notes.pdf
+//
+// Note: Does not use the Gaussian kernel part of a typical bilateral blur
+// From the paper: "use the information gathered on a neighborhood of 4 x 4 using a bilateral filter for
+// reconstruction, using _uniform_ convolution weights"
+//
+// Note: The paper does a 4x4 (not quite centered) filter, offset by +/- 1 pixel every other frame
+// XeGTAO does a 3x3 filter, on two pixels at a time per compute thread, applied twice
+// We do a 3x3 filter, on 1 pixel per compute thread, applied once
+//
+// Ported from Bevy Engine, crates/bevy_pbr/src/ssao/spatial_denoise.wgsl (v0.13.2), licensed
+// MIT OR Apache-2.0 (see res/licenses/), itself derived from Intel XeGTAO (MIT).
+//
+// PORT: the textureGather calls are rewritten as explicit per-neighbor textureLoads (r32float
+// and r32uint are unfilterable); Bevy view uniforms -> the mod's uniform block; r16float -> r32float.
+
+struct Uniforms {
+    projection: mat4x4f,
+    inverse_projection: mat4x4f,
+    size: vec2f,
+    inv_size: vec2f,
+    depth_scale: vec2f,
+    effect_radius: f32,
+    intensity: f32,
+    slice_count: f32,
+    samples_per_slice_side: f32,
+    debug_view: u32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var ambient_occlusion_noisy: texture_2d<f32>;
+@group(0) @binding(1) var depth_differences: texture_2d<u32>;
+@group(0) @binding(2) var ambient_occlusion: texture_storage_2d<r32float, write>;
+@group(0) @binding(3) var<uniform> uniforms: Uniforms;
+
+fn clamp_coordinates(pixel_coordinates: vec2<i32>) -> vec2<i32> {
+    return clamp(pixel_coordinates, vec2<i32>(0i), vec2<i32>(uniforms.size) - 1i);
+}
+
+// Each pixel's packed edge info is (left, right, top, bottom) weights, packed by the GTAO pass.
+fn load_edges(pixel_coordinates: vec2<i32>) -> vec4<f32> {
+    return unpack4x8unorm(textureLoad(depth_differences, clamp_coordinates(pixel_coordinates), 0i).r);
+}
+
+fn load_visibility(pixel_coordinates: vec2<i32>) -> f32 {
+    return textureLoad(ambient_occlusion_noisy, clamp_coordinates(pixel_coordinates), 0i).r;
+}
+
+@compute
+@workgroup_size(8, 8, 1)
+fn spatial_denoise(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let pixel_coordinates = vec2<i32>(global_id.xy);
+
+    let left_edges = load_edges(pixel_coordinates + vec2<i32>(-1i, 0i));
+    let right_edges = load_edges(pixel_coordinates + vec2<i32>(1i, 0i));
+    let top_edges = load_edges(pixel_coordinates + vec2<i32>(0i, -1i));
+    let bottom_edges = load_edges(pixel_coordinates + vec2<i32>(0i, 1i));
+    var center_edges = load_edges(pixel_coordinates);
+    // Cross-check each edge against the neighbor's opposing edge weight.
+    center_edges *= vec4<f32>(left_edges.y, right_edges.x, top_edges.w, bottom_edges.z);
+
+    let center_weight = 1.2;
+    let left_weight = center_edges.x;
+    let right_weight = center_edges.y;
+    let top_weight = center_edges.z;
+    let bottom_weight = center_edges.w;
+    let top_left_weight = 0.425 * (top_weight * top_edges.x + left_weight * left_edges.z);
+    let top_right_weight = 0.425 * (top_weight * top_edges.y + right_weight * right_edges.z);
+    let bottom_left_weight = 0.425 * (bottom_weight * bottom_edges.x + left_weight * left_edges.w);
+    let bottom_right_weight = 0.425 * (bottom_weight * bottom_edges.y + right_weight * right_edges.w);
+
+    let center_visibility = load_visibility(pixel_coordinates);
+    let left_visibility = load_visibility(pixel_coordinates + vec2<i32>(-1i, 0i));
+    let right_visibility = load_visibility(pixel_coordinates + vec2<i32>(1i, 0i));
+    let top_visibility = load_visibility(pixel_coordinates + vec2<i32>(0i, -1i));
+    let bottom_visibility = load_visibility(pixel_coordinates + vec2<i32>(0i, 1i));
+    let top_left_visibility = load_visibility(pixel_coordinates + vec2<i32>(-1i, -1i));
+    let top_right_visibility = load_visibility(pixel_coordinates + vec2<i32>(1i, -1i));
+    let bottom_left_visibility = load_visibility(pixel_coordinates + vec2<i32>(-1i, 1i));
+    let bottom_right_visibility = load_visibility(pixel_coordinates + vec2<i32>(1i, 1i));
+
+    // PORT: Bevy sums the center sample unweighted while still counting center_weight in the
+    // denominator; XeGTAO's original weights the value too, which is what we do here.
+    var sum = center_visibility * center_weight;
+    sum += left_visibility * left_weight;
+    sum += right_visibility * right_weight;
+    sum += top_visibility * top_weight;
+    sum += bottom_visibility * bottom_weight;
+    sum += top_left_visibility * top_left_weight;
+    sum += top_right_visibility * top_right_weight;
+    sum += bottom_left_visibility * bottom_left_weight;
+    sum += bottom_right_visibility * bottom_right_weight;
+
+    var sum_weight = center_weight;
+    sum_weight += left_weight;
+    sum_weight += right_weight;
+    sum_weight += top_weight;
+    sum_weight += bottom_weight;
+    sum_weight += top_left_weight;
+    sum_weight += top_right_weight;
+    sum_weight += bottom_left_weight;
+    sum_weight += bottom_right_weight;
+
+    let denoised_visibility = sum / sum_weight;
+
+    textureStore(ambient_occlusion, pixel_coordinates, vec4<f32>(denoised_visibility, 0.0, 0.0, 0.0));
+}
diff --git a/mods/ao_mod/res/gtao.wgsl b/mods/ao_mod/res/gtao.wgsl
new file mode 100644
index 0000000000..ee23774681
--- /dev/null
+++ b/mods/ao_mod/res/gtao.wgsl
@@ -0,0 +1,247 @@
+// Ground Truth-based Ambient Occlusion (GTAO)
+// Paper: https://www.activision.com/cdn/research/Practical_Real_Time_Strategies_for_Accurate_Indirect_Occlusion_NEW%20VERSION_COLOR.pdf
+// Presentation: https://blog.selfshadow.com/publications/s2016-shading-course/activision/s2016_pbs_activision_occlusion.pdf
+//
+// Ported from Bevy Engine, crates/bevy_pbr/src/ssao/gtao.wgsl (v0.13.2), licensed
+// MIT OR Apache-2.0 (see res/licenses/), itself heavily based on XeGTAO v1.30 from Intel (MIT):
+// https://github.com/GameTechDev/XeGTAO/blob/0d177ce06bfa642f64d8af4de1197ad1bcb862d4/Source/Rendering/Shaders/XeGTAO.hlsli
+//
+// PORT:
+// - Bevy view/globals bindings -> the mod's own uniform block (matrices from Dusklight's
+//   CameraService, WebGPU clip convention, reversed-Z - the same convention Bevy uses).
+// - Prepass normals -> normals reconstructed from depth (atyuwen's accurate 5-tap method,
+//   https://atyuwen.github.io/posts/normal-reconstruction/).
+// - Sampler-based reads -> textureLoad (r32float is unfilterable without optional features);
+//   the mip level for the XeGTAO bandwidth optimization is selected explicitly per load.
+// - effect_radius and slice/sample counts come from uniforms instead of constants/shader defs
+//   (game world units are ~100x larger than Bevy's meters, and quality is a live setting).
+// - No TEMPORAL_JITTER: the noise index is pinned (no TAA; the spatial denoiser is the only
+//   filter, a configuration XeGTAO supports).
+// - Storage format r16float -> r32float (core WebGPU storage format).
+
+struct Uniforms {
+    projection: mat4x4f,
+    inverse_projection: mat4x4f,
+    size: vec2f,
+    inv_size: vec2f,
+    depth_scale: vec2f,
+    effect_radius: f32,
+    intensity: f32,
+    slice_count: f32,
+    samples_per_slice_side: f32,
+    debug_view: u32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var preprocessed_depth: texture_2d<f32>;
+@group(0) @binding(1) var hilbert_index_lut: texture_2d<u32>;
+@group(0) @binding(2) var ambient_occlusion: texture_storage_2d<r32float, write>;
+@group(0) @binding(3) var depth_differences: texture_storage_2d<r32uint, write>;
+@group(0) @binding(4) var<uniform> uniforms: Uniforms;
+
+const PI: f32 = 3.141592653589793;
+const HALF_PI: f32 = 1.5707963267948966;
+
+fn fast_sqrt(x: f32) -> f32 {
+    return bitcast<f32>(0x1fbd1df5 + (bitcast<i32>(x) >> 1u));
+}
+
+fn fast_acos(in_x: f32) -> f32 {
+    let x = abs(in_x);
+    var res = -0.156583 * x + HALF_PI;
+    res *= fast_sqrt(1.0 - x);
+    return select(PI - res, res, in_x >= 0.0);
+}
+
+fn load_noise(pixel_coordinates: vec2<i32>) -> vec2<f32> {
+    let index = textureLoad(hilbert_index_lut, pixel_coordinates % 64, 0).r;
+    // R2 sequence - http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences
+    return fract(0.5 + f32(index) * vec2<f32>(0.75487766624669276005, 0.5698402909980532659114));
+}
+
+fn load_depth(pixel_coordinates: vec2<i32>, mip_level: i32) -> f32 {
+    let mip_size = max(vec2<i32>(uniforms.size) >> vec2<u32>(u32(mip_level)), vec2<i32>(1i));
+    let coordinates = clamp(pixel_coordinates, vec2<i32>(0i), mip_size - 1i);
+    return textureLoad(preprocessed_depth, coordinates, mip_level).r;
+}
+
+// Calculate differences in depth between neighbor pixels (later used by the spatial denoiser pass to preserve object edges)
+fn calculate_neighboring_depth_differences(pixel_coordinates: vec2<i32>) -> f32 {
+    // Sample the pixel's depth and 4 depths around it
+    // PORT: explicit loads instead of two textureGathers.
+    let depth_center = load_depth(pixel_coordinates, 0i);
+    let depth_left = load_depth(pixel_coordinates + vec2<i32>(-1i, 0i), 0i);
+    let depth_top = load_depth(pixel_coordinates + vec2<i32>(0i, -1i), 0i);
+    let depth_bottom = load_depth(pixel_coordinates + vec2<i32>(0i, 1i), 0i);
+    let depth_right = load_depth(pixel_coordinates + vec2<i32>(1i, 0i), 0i);
+
+    // Calculate the depth differences (large differences represent object edges)
+    var edge_info = vec4<f32>(depth_left, depth_right, depth_top, depth_bottom) - depth_center;
+    let slope_left_right = (edge_info.y - edge_info.x) * 0.5;
+    let slope_top_bottom = (edge_info.w - edge_info.z) * 0.5;
+    let edge_info_slope_adjusted = edge_info + vec4<f32>(slope_left_right, -slope_left_right, slope_top_bottom, -slope_top_bottom);
+    edge_info = min(abs(edge_info), abs(edge_info_slope_adjusted));
+    let bias = 0.25; // Using the bias and then saturating nudges the values a bit
+    let scale = depth_center * 0.011; // Weight the edges by their distance from the camera
+    edge_info = saturate((1.0 + bias) - edge_info / scale); // Apply the bias and scale, and invert edge_info so that small values become large, and vice versa
+
+    // Pack the edge info into the texture
+    let edge_info_packed = vec4<u32>(pack4x8unorm(edge_info), 0u, 0u, 0u);
+    textureStore(depth_differences, pixel_coordinates, edge_info_packed);
+
+    return depth_center;
+}
+
+fn reconstruct_view_space_position(depth: f32, uv: vec2<f32>) -> vec3<f32> {
+    let clip_xy = vec2<f32>(uv.x * 2.0 - 1.0, 1.0 - 2.0 * uv.y);
+    let t = uniforms.inverse_projection * vec4<f32>(clip_xy, depth, 1.0);
+    let view_xyz = t.xyz / t.w;
+    return view_xyz;
+}
+
+fn view_position_at(pixel_coordinates: vec2<i32>) -> vec3<f32> {
+    let depth = load_depth(pixel_coordinates, 0i);
+    let uv = (vec2<f32>(pixel_coordinates) + 0.5) * uniforms.inv_size;
+    return reconstruct_view_space_position(depth, uv);
+}
+
+// PORT: replaces Bevy's load_normal_view_space (which reads a prepass normal texture we do
+// not have). Accurate view-space normal reconstruction from depth, atyuwen's 5-tap method:
+// for each axis, extrapolate the center depth from the two taps on each side and derive the
+// tangent from whichever side predicts it better. This keeps normals stable across depth
+// discontinuities where naive derivatives smear.
+fn reconstruct_normal(pixel_coordinates: vec2<i32>, pixel_position: vec3<f32>, depth_center: f32) -> vec3<f32> {
+    let depth_left1 = load_depth(pixel_coordinates + vec2<i32>(-1i, 0i), 0i);
+    let depth_left2 = load_depth(pixel_coordinates + vec2<i32>(-2i, 0i), 0i);
+    let depth_right1 = load_depth(pixel_coordinates + vec2<i32>(1i, 0i), 0i);
+    let depth_right2 = load_depth(pixel_coordinates + vec2<i32>(2i, 0i), 0i);
+    let depth_top1 = load_depth(pixel_coordinates + vec2<i32>(0i, -1i), 0i);
+    let depth_top2 = load_depth(pixel_coordinates + vec2<i32>(0i, -2i), 0i);
+    let depth_bottom1 = load_depth(pixel_coordinates + vec2<i32>(0i, 1i), 0i);
+    let depth_bottom2 = load_depth(pixel_coordinates + vec2<i32>(0i, 2i), 0i);
+
+    let use_left = abs(2.0 * depth_left1 - depth_left2 - depth_center) <
+        abs(2.0 * depth_right1 - depth_right2 - depth_center);
+    let use_top = abs(2.0 * depth_top1 - depth_top2 - depth_center) <
+        abs(2.0 * depth_bottom1 - depth_bottom2 - depth_center);
+
+    var ddx: vec3<f32>;
+    if use_left {
+        ddx = pixel_position - view_position_at(pixel_coordinates + vec2<i32>(-1i, 0i));
+    } else {
+        ddx = view_position_at(pixel_coordinates + vec2<i32>(1i, 0i)) - pixel_position;
+    }
+    var ddy: vec3<f32>;
+    if use_top {
+        ddy = pixel_position - view_position_at(pixel_coordinates + vec2<i32>(0i, -1i));
+    } else {
+        ddy = view_position_at(pixel_coordinates + vec2<i32>(0i, 1i)) - pixel_position;
+    }
+
+    var normal = normalize(cross(ddy, ddx));
+    // Guard the orientation: the normal must face the camera.
+    if dot(normal, pixel_position) > 0.0 {
+        normal = -normal;
+    }
+    return normal;
+}
+
+fn load_and_reconstruct_view_space_position(uv: vec2<f32>, sample_mip_level: f32) -> vec3<f32> {
+    // PORT: point-sample the selected mip explicitly instead of textureSampleLevel.
+    let mip_level = i32(sample_mip_level + 0.5);
+    let mip_size = max(vec2<i32>(uniforms.size) >> vec2<u32>(u32(mip_level)), vec2<i32>(1i));
+    let depth = load_depth(vec2<i32>(uv * vec2<f32>(mip_size)), mip_level);
+    return reconstruct_view_space_position(depth, uv);
+}
+
+@compute
+@workgroup_size(8, 8, 1)
+fn gtao(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let slice_count = uniforms.slice_count;
+    let samples_per_slice_side = uniforms.samples_per_slice_side;
+    let effect_radius = uniforms.effect_radius;
+    let falloff_range = 0.615 * effect_radius;
+    let falloff_from = effect_radius * (1.0 - 0.615);
+    let falloff_mul = -1.0 / falloff_range;
+    let falloff_add = falloff_from / falloff_range + 1.0;
+
+    let pixel_coordinates = vec2<i32>(global_id.xy);
+    let uv = (vec2<f32>(pixel_coordinates) + 0.5) * uniforms.inv_size;
+
+    var pixel_depth = calculate_neighboring_depth_differences(pixel_coordinates);
+    let raw_depth = pixel_depth;
+    pixel_depth += 0.00001; // Avoid depth precision issues
+
+    let pixel_position = reconstruct_view_space_position(pixel_depth, uv);
+    // PORT: the reconstruction differences the center position against neighbor positions
+    // built from unbiased depths, so its center must use the raw depth too: at this game's
+    // depth scale (far plane 200000 -> depth ~5e-3) Bevy's +0.00001 bias is comparable to a
+    // one-pixel depth step, and a biased center corrupts both tangents.
+    let pixel_normal = reconstruct_normal(
+        pixel_coordinates, reconstruct_view_space_position(raw_depth, uv), raw_depth);
+    let view_vec = normalize(-pixel_position);
+
+    let noise = load_noise(pixel_coordinates);
+    let sample_scale = (-0.5 * effect_radius * uniforms.projection[0][0]) / pixel_position.z;
+
+    var visibility = 0.0;
+    for (var slice_t = 0.0; slice_t < slice_count; slice_t += 1.0) {
+        let slice = slice_t + noise.x;
+        let phi = (PI / slice_count) * slice;
+        let omega = vec2<f32>(cos(phi), sin(phi));
+
+        let direction = vec3<f32>(omega.xy, 0.0);
+        let orthographic_direction = direction - (dot(direction, view_vec) * view_vec);
+        let axis = cross(direction, view_vec);
+        let projected_normal = pixel_normal - axis * dot(pixel_normal, axis);
+        let projected_normal_length = length(projected_normal);
+
+        let sign_norm = sign(dot(orthographic_direction, projected_normal));
+        let cos_norm = saturate(dot(projected_normal, view_vec) / projected_normal_length);
+        let n = sign_norm * fast_acos(cos_norm);
+
+        let min_cos_horizon_1 = cos(n + HALF_PI);
+        let min_cos_horizon_2 = cos(n - HALF_PI);
+        var cos_horizon_1 = min_cos_horizon_1;
+        var cos_horizon_2 = min_cos_horizon_2;
+        let sample_mul = vec2<f32>(omega.x, -omega.y) * sample_scale;
+        for (var sample_t = 0.0; sample_t < samples_per_slice_side; sample_t += 1.0) {
+            var sample_noise = (slice_t + sample_t * samples_per_slice_side) * 0.6180339887498948482;
+            sample_noise = fract(noise.y + sample_noise);
+
+            var s = (sample_t + sample_noise) / samples_per_slice_side;
+            s *= s; // https://github.com/GameTechDev/XeGTAO#sample-distribution
+            let sample = s * sample_mul;
+
+            // * uniforms.size gets us from [0, 1] to [0, viewport_size], which is needed for this to get the correct mip levels
+            let sample_mip_level = clamp(log2(length(sample * uniforms.size)) - 3.3, 0.0, 4.0); // https://github.com/GameTechDev/XeGTAO#memory-bandwidth-bottleneck
+            let sample_position_1 = load_and_reconstruct_view_space_position(uv + sample, sample_mip_level);
+            let sample_position_2 = load_and_reconstruct_view_space_position(uv - sample, sample_mip_level);
+
+            let sample_difference_1 = sample_position_1 - pixel_position;
+            let sample_difference_2 = sample_position_2 - pixel_position;
+            let sample_distance_1 = length(sample_difference_1);
+            let sample_distance_2 = length(sample_difference_2);
+            var sample_cos_horizon_1 = dot(sample_difference_1 / sample_distance_1, view_vec);
+            var sample_cos_horizon_2 = dot(sample_difference_2 / sample_distance_2, view_vec);
+
+            let weight_1 = saturate(sample_distance_1 * falloff_mul + falloff_add);
+            let weight_2 = saturate(sample_distance_2 * falloff_mul + falloff_add);
+            sample_cos_horizon_1 = mix(min_cos_horizon_1, sample_cos_horizon_1, weight_1);
+            sample_cos_horizon_2 = mix(min_cos_horizon_2, sample_cos_horizon_2, weight_2);
+
+            cos_horizon_1 = max(cos_horizon_1, sample_cos_horizon_1);
+            cos_horizon_2 = max(cos_horizon_2, sample_cos_horizon_2);
+        }
+
+        let horizon_1 = fast_acos(cos_horizon_1);
+        let horizon_2 = -fast_acos(cos_horizon_2);
+        let v1 = (cos_norm + 2.0 * horizon_1 * sin(n) - cos(2.0 * horizon_1 - n)) / 4.0;
+        let v2 = (cos_norm + 2.0 * horizon_2 * sin(n) - cos(2.0 * horizon_2 - n)) / 4.0;
+        visibility += projected_normal_length * (v1 + v2);
+    }
+    visibility /= slice_count;
+    visibility = clamp(visibility, 0.03, 1.0);
+
+    textureStore(ambient_occlusion, pixel_coordinates, vec4<f32>(visibility, 0.0, 0.0, 0.0));
+}
diff --git a/mods/ao_mod/res/licenses/BEVY-APACHE-2.0.txt b/mods/ao_mod/res/licenses/BEVY-APACHE-2.0.txt
new file mode 100644
index 0000000000..d9a10c0d8e
--- /dev/null
+++ b/mods/ao_mod/res/licenses/BEVY-APACHE-2.0.txt
@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/mods/ao_mod/res/licenses/BEVY-MIT.txt b/mods/ao_mod/res/licenses/BEVY-MIT.txt
new file mode 100644
index 0000000000..9cf106272a
--- /dev/null
+++ b/mods/ao_mod/res/licenses/BEVY-MIT.txt
@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/mods/ao_mod/res/licenses/XEGTAO-MIT.txt b/mods/ao_mod/res/licenses/XEGTAO-MIT.txt
new file mode 100644
index 0000000000..2b1bd1561b
--- /dev/null
+++ b/mods/ao_mod/res/licenses/XEGTAO-MIT.txt
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2016-2021, Intel Corporation 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/mods/ao_mod/res/preprocess_depth.wgsl b/mods/ao_mod/res/preprocess_depth.wgsl
new file mode 100644
index 0000000000..98fe1d5400
--- /dev/null
+++ b/mods/ao_mod/res/preprocess_depth.wgsl
@@ -0,0 +1,138 @@
+// Inputs a depth texture and outputs a MIP-chain of depths.
+//
+// Because SSAO's performance is bound by texture reads, this increases
+// performance over using the full resolution depth for every sample.
+//
+// Reference: https://research.nvidia.com/sites/default/files/pubs/2012-06_Scalable-Ambient-Obscurance/McGuire12SAO.pdf, section 2.2
+//
+// Ported from Bevy Engine, crates/bevy_pbr/src/ssao/preprocess_depth.wgsl (v0.13.2),
+// licensed MIT OR Apache-2.0 (see res/licenses/), itself derived from Intel XeGTAO (MIT).
+//
+// PORT: sampler-based gathers replaced with textureLoad (r32float is not filterable without
+// optional device features), Bevy view uniforms replaced with the mod's own uniform block,
+// storage format r16float -> r32float (core WebGPU storage format). MIP 4 moved into its own
+// entry point (core WebGPU limit is 4 storage textures per stage).
+
+struct Uniforms {
+    projection: mat4x4f,
+    inverse_projection: mat4x4f,
+    size: vec2f,        // AO chain size in pixels (MIP 0 of the preprocessed depth)
+    inv_size: vec2f,
+    depth_scale: vec2f, // input depth snapshot pixels per chain pixel (1 or 2)
+    effect_radius: f32, // view-space units
+    intensity: f32,
+    slice_count: f32,
+    samples_per_slice_side: f32,
+    debug_view: u32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var input_depth: texture_2d<f32>;
+@group(0) @binding(1) var preprocessed_depth_mip0: texture_storage_2d<r32float, write>;
+@group(0) @binding(2) var preprocessed_depth_mip1: texture_storage_2d<r32float, write>;
+@group(0) @binding(3) var preprocessed_depth_mip2: texture_storage_2d<r32float, write>;
+@group(0) @binding(4) var preprocessed_depth_mip3: texture_storage_2d<r32float, write>;
+@group(0) @binding(5) var<uniform> uniforms: Uniforms;
+// downsample_mip4 entry point only (disjoint subresources of the same texture).
+@group(0) @binding(6) var preprocessed_depth_mip3_in: texture_2d<f32>;
+@group(0) @binding(7) var preprocessed_depth_mip4: texture_storage_2d<r32float, write>;
+
+// PORT: replaces the textureGather of the input depth with explicit loads (also handles the
+// half-resolution case, where one chain texel covers depth_scale snapshot texels).
+fn load_input_depth(pixel_coordinates: vec2<i32>) -> f32 {
+    let input_size = vec2<i32>(uniforms.size * uniforms.depth_scale);
+    let coordinates = clamp(vec2<i32>(vec2<f32>(pixel_coordinates) * uniforms.depth_scale),
+        vec2<i32>(0i), input_size - 1i);
+    return textureLoad(input_depth, coordinates, 0i).r;
+}
+
+// Using 4 depths from the previous MIP, compute a weighted average for the depth of the current MIP
+fn weighted_average(depth0: f32, depth1: f32, depth2: f32, depth3: f32) -> f32 {
+    let depth_range_scale_factor = 0.75;
+    let effect_radius = depth_range_scale_factor * 0.5 * 1.457;
+    let falloff_range = 0.615 * effect_radius;
+    let falloff_from = effect_radius * (1.0 - 0.615);
+    let falloff_mul = -1.0 / falloff_range;
+    let falloff_add = falloff_from / falloff_range + 1.0;
+
+    let min_depth = min(min(depth0, depth1), min(depth2, depth3));
+    let weight0 = saturate((depth0 - min_depth) * falloff_mul + falloff_add);
+    let weight1 = saturate((depth1 - min_depth) * falloff_mul + falloff_add);
+    let weight2 = saturate((depth2 - min_depth) * falloff_mul + falloff_add);
+    let weight3 = saturate((depth3 - min_depth) * falloff_mul + falloff_add);
+    let weight_total = weight0 + weight1 + weight2 + weight3;
+
+    return ((weight0 * depth0) + (weight1 * depth1) + (weight2 * depth2) + (weight3 * depth3)) / weight_total;
+}
+
+// Used to share the depths from the previous MIP level between all invocations in a workgroup
+var<workgroup> previous_mip_depth: array<array<f32, 8>, 8>;
+
+@compute
+@workgroup_size(8, 8, 1)
+fn preprocess_depth(@builtin(global_invocation_id) global_id: vec3<u32>, @builtin(local_invocation_id) local_id: vec3<u32>) {
+    let base_coordinates = vec2<i32>(global_id.xy);
+
+    // MIP 0 - Copy 4 texels from the input depth (per invocation, 8x8 invocations per workgroup)
+    let pixel_coordinates0 = base_coordinates * 2i;
+    let pixel_coordinates1 = pixel_coordinates0 + vec2<i32>(1i, 0i);
+    let pixel_coordinates2 = pixel_coordinates0 + vec2<i32>(0i, 1i);
+    let pixel_coordinates3 = pixel_coordinates0 + vec2<i32>(1i, 1i);
+    let depth0 = load_input_depth(pixel_coordinates0);
+    let depth1 = load_input_depth(pixel_coordinates1);
+    let depth2 = load_input_depth(pixel_coordinates2);
+    let depth3 = load_input_depth(pixel_coordinates3);
+    textureStore(preprocessed_depth_mip0, pixel_coordinates0, vec4<f32>(depth0, 0.0, 0.0, 0.0));
+    textureStore(preprocessed_depth_mip0, pixel_coordinates1, vec4<f32>(depth1, 0.0, 0.0, 0.0));
+    textureStore(preprocessed_depth_mip0, pixel_coordinates2, vec4<f32>(depth2, 0.0, 0.0, 0.0));
+    textureStore(preprocessed_depth_mip0, pixel_coordinates3, vec4<f32>(depth3, 0.0, 0.0, 0.0));
+
+    // MIP 1 - Weighted average of MIP 0's depth values (per invocation, 8x8 invocations per workgroup)
+    let depth_mip1 = weighted_average(depth0, depth1, depth2, depth3);
+    textureStore(preprocessed_depth_mip1, base_coordinates, vec4<f32>(depth_mip1, 0.0, 0.0, 0.0));
+    previous_mip_depth[local_id.x][local_id.y] = depth_mip1;
+
+    workgroupBarrier();
+
+    // MIP 2 - Weighted average of MIP 1's depth values (per invocation, 4x4 invocations per workgroup)
+    if all(local_id.xy % vec2<u32>(2u) == vec2<u32>(0u)) {
+        let mip2_depth0 = previous_mip_depth[local_id.x + 0u][local_id.y + 0u];
+        let mip2_depth1 = previous_mip_depth[local_id.x + 1u][local_id.y + 0u];
+        let mip2_depth2 = previous_mip_depth[local_id.x + 0u][local_id.y + 1u];
+        let mip2_depth3 = previous_mip_depth[local_id.x + 1u][local_id.y + 1u];
+        let depth_mip2 = weighted_average(mip2_depth0, mip2_depth1, mip2_depth2, mip2_depth3);
+        textureStore(preprocessed_depth_mip2, base_coordinates / 2i, vec4<f32>(depth_mip2, 0.0, 0.0, 0.0));
+        previous_mip_depth[local_id.x][local_id.y] = depth_mip2;
+    }
+
+    workgroupBarrier();
+
+    // MIP 3 - Weighted average of MIP 2's depth values (per invocation, 2x2 invocations per workgroup)
+    if all(local_id.xy % vec2<u32>(4u) == vec2<u32>(0u)) {
+        let mip3_depth0 = previous_mip_depth[local_id.x + 0u][local_id.y + 0u];
+        let mip3_depth1 = previous_mip_depth[local_id.x + 2u][local_id.y + 0u];
+        let mip3_depth2 = previous_mip_depth[local_id.x + 0u][local_id.y + 2u];
+        let mip3_depth3 = previous_mip_depth[local_id.x + 2u][local_id.y + 2u];
+        let depth_mip3 = weighted_average(mip3_depth0, mip3_depth1, mip3_depth2, mip3_depth3);
+        textureStore(preprocessed_depth_mip3, base_coordinates / 4i, vec4<f32>(depth_mip3, 0.0, 0.0, 0.0));
+        previous_mip_depth[local_id.x][local_id.y] = depth_mip3;
+    }
+}
+
+// MIP 4: weighted average of MIP 3's depth values, as a second (tiny) dispatch.
+@compute
+@workgroup_size(8, 8, 1)
+fn downsample_mip4(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    let base_coordinates = vec2<i32>(global_id.xy);
+    let mip3_size = max(vec2<i32>(textureDimensions(preprocessed_depth_mip3_in)), vec2<i32>(1i));
+    let coordinates0 = clamp(base_coordinates * 2i, vec2<i32>(0i), mip3_size - 1i);
+    let coordinates1 = clamp(base_coordinates * 2i + vec2<i32>(1i, 0i), vec2<i32>(0i), mip3_size - 1i);
+    let coordinates2 = clamp(base_coordinates * 2i + vec2<i32>(0i, 1i), vec2<i32>(0i), mip3_size - 1i);
+    let coordinates3 = clamp(base_coordinates * 2i + vec2<i32>(1i, 1i), vec2<i32>(0i), mip3_size - 1i);
+    let depth0 = textureLoad(preprocessed_depth_mip3_in, coordinates0, 0i).r;
+    let depth1 = textureLoad(preprocessed_depth_mip3_in, coordinates1, 0i).r;
+    let depth2 = textureLoad(preprocessed_depth_mip3_in, coordinates2, 0i).r;
+    let depth3 = textureLoad(preprocessed_depth_mip3_in, coordinates3, 0i).r;
+    let depth_mip4 = weighted_average(depth0, depth1, depth2, depth3);
+    textureStore(preprocessed_depth_mip4, base_coordinates, vec4<f32>(depth_mip4, 0.0, 0.0, 0.0));
+}
diff --git a/mods/ao_mod/src/mod.cpp b/mods/ao_mod/src/mod.cpp
new file mode 100644
index 0000000000..8a96ae3c95
--- /dev/null
+++ b/mods/ao_mod/src/mod.cpp
@@ -0,0 +1,933 @@
+// Ambient occlusion (GTAO) example mod.
+//
+// Showcases the gfx service's compute tasks and the camera service: after opaque scene draws,
+// before translucent/fog overlays, the scene depth is resolved and a three-dispatch compute
+// chain (depth MIP prefilter, GTAO, spatial denoise) produces a visibility texture that a
+// fullscreen draw multiplies over the world.
+//
+// The WGSL in res/ is ported from Bevy Engine's SSAO implementation (MIT OR Apache-2.0),
+// itself based on Intel XeGTAO (MIT); see res/licenses/ and the `PORT:` notes in the shaders.
+
+#include "mods/service.hpp"
+#include "mods/svc/camera.h"
+#include "mods/svc/config.h"
+#include "mods/svc/gfx.h"
+#include "mods/svc/log.h"
+#include "mods/svc/resource.h"
+#include "mods/svc/ui.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cstring>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include <webgpu/webgpu.h>
+
+DEFINE_MOD();
+IMPORT_SERVICE(LogService, svc_log);
+IMPORT_SERVICE(ConfigService, svc_config);
+IMPORT_SERVICE(ResourceService, svc_resource);
+IMPORT_SERVICE(UiService, svc_ui);
+IMPORT_SERVICE(GfxService, svc_gfx);
+IMPORT_SERVICE(CameraService, svc_camera);
+
+namespace {
+
+ConfigVarHandle g_cvarEnabled = 0;
+ConfigVarHandle g_cvarQuality = 0;
+ConfigVarHandle g_cvarRadius = 0;
+ConfigVarHandle g_cvarIntensity = 0;
+ConfigVarHandle g_cvarHalfRes = 0;
+ConfigVarHandle g_cvarDebugView = 0;
+
+GfxComputeTypeHandle g_computeType = 0;
+GfxDrawTypeHandle g_drawType = 0;
+GfxStageHookHandle g_afterOpaqueHook = 0;
+UiWindowHandle g_controlsWindow = 0;
+
+ResourceBuffer g_preprocessSource = RESOURCE_BUFFER_INIT;
+ResourceBuffer g_gtaoSource = RESOURCE_BUFFER_INIT;
+ResourceBuffer g_denoiseSource = RESOURCE_BUFFER_INIT;
+ResourceBuffer g_compositeSource = RESOURCE_BUFFER_INIT;
+
+GfxDeviceInfo g_deviceInfo = GFX_DEVICE_INFO_INIT;
+GfxRenderTargetLayout g_sceneTargetLayout = GFX_RENDER_TARGET_LAYOUT_INIT;
+WGPUComputePipeline g_preprocessPipeline = nullptr;
+WGPUComputePipeline g_mip4Pipeline = nullptr;
+WGPUComputePipeline g_gtaoPipeline = nullptr;
+WGPUComputePipeline g_denoisePipeline = nullptr;
+WGPUBindGroupLayout g_preprocessLayout = nullptr;
+WGPUBindGroupLayout g_mip4Layout = nullptr;
+WGPUBindGroupLayout g_gtaoLayout = nullptr;
+WGPUBindGroupLayout g_denoiseLayout = nullptr;
+WGPURenderPipeline g_compositePipeline = nullptr;
+WGPURenderPipeline g_compositeDebugPipeline = nullptr;
+WGPUBindGroupLayout g_compositeLayout = nullptr;
+WGPUBindGroupLayout g_compositeDebugLayout = nullptr;
+WGPUTexture g_hilbertLut = nullptr;
+WGPUTextureView g_hilbertLutView = nullptr;
+
+// AO chain targets, recreated when the render size (or halfRes) changes. Old sets are retired
+// for a few frames instead of released immediately: payloads embedding their views may still
+// be in flight on the render worker.
+struct AoTargets {
+    uint32_t width = 0;
+    uint32_t height = 0;
+    WGPUTexture preprocessedDepth = nullptr;
+    WGPUTextureView preprocessedDepthMips[5] = {};
+    WGPUTextureView preprocessedDepthAll = nullptr;
+    WGPUTexture aoNoisy = nullptr;
+    WGPUTextureView aoNoisyView = nullptr;
+    WGPUTexture depthDifferences = nullptr;
+    WGPUTextureView depthDifferencesView = nullptr;
+    WGPUTexture aoFinal = nullptr;
+    WGPUTextureView aoFinalView = nullptr;
+};
+AoTargets g_targets;
+struct RetiredTargets {
+    AoTargets targets;
+    int framesLeft = 0;
+};
+std::vector<RetiredTargets> g_retiredTargets;
+
+bool g_warnedNoDepth = false;
+bool g_loggedChain = false;
+std::atomic g_chainExecuted{false};
+
+// Mirror of the WGSL Uniforms struct (keep in sync with res/*.wgsl).
+struct AoUniforms {
+    float projection[16];
+    float inverse_projection[16];
+    float size[2];
+    float inv_size[2];
+    float depth_scale[2];
+    float effect_radius;
+    float intensity;
+    float slice_count;
+    float samples_per_slice_side;
+    uint32_t debug_view;
+    float _pad;
+};
+static_assert(sizeof(AoUniforms) % 16 == 0);
+
+struct ComputePayload {
+    WGPUTextureView depth;  // frame-pooled scene depth snapshot
+    WGPUTextureView preprocessedDepthMips[5];
+    WGPUTextureView preprocessedDepthAll;
+    WGPUTextureView aoNoisy;
+    WGPUTextureView depthDifferences;
+    WGPUTextureView aoFinal;
+    uint32_t uniform_offset;
+    uint32_t uniform_size;
+    uint32_t width;
+    uint32_t height;
+};
+static_assert(sizeof(ComputePayload) <= GFX_INLINE_DRAW_PAYLOAD_SIZE);
+static_assert(std::is_trivially_copyable_v<ComputePayload>);
+
+struct CompositePayload {
+    WGPUTextureView aoFinal;
+    WGPUTextureView preprocessedDepth;  // debug views reconstruct normals/depth from it
+    WGPUTextureView sceneDepth;         // raw snapshot, for the bypass debug views
+    uint32_t uniform_offset;
+    uint32_t uniform_size;
+    uint32_t debug_view;
+};
+static_assert(sizeof(CompositePayload) <= GFX_INLINE_DRAW_PAYLOAD_SIZE);
+static_assert(std::is_trivially_copyable_v<CompositePayload>);
+
+int64_t get_int_option(ConfigVarHandle handle, int64_t fallback) {
+    int64_t value = fallback;
+    if (handle == 0 || svc_config->get_int(mod_ctx, handle, &value) != MOD_OK) {
+        return fallback;
+    }
+    return value;
+}
+
+bool get_bool_option(ConfigVarHandle handle, bool fallback) {
+    bool value = fallback;
+    if (handle == 0 || svc_config->get_bool(mod_ctx, handle, &value) != MOD_OK) {
+        return fallback;
+    }
+    return value;
+}
+
+// XeGTAO/Bevy quality presets: slices x (samples per slice side * 2).
+void quality_counts(int64_t quality, float& sliceCount, float& samplesPerSliceSide) {
+    switch (std::clamp<int64_t>(quality, 0, 3)) {
+    case 0:
+        sliceCount = 1.0f;
+        samplesPerSliceSide = 2.0f;
+        break;
+    case 1:
+        sliceCount = 2.0f;
+        samplesPerSliceSide = 2.0f;
+        break;
+    default:
+    case 2:
+        sliceCount = 3.0f;
+        samplesPerSliceSide = 3.0f;
+        break;
+    case 3:
+        sliceCount = 9.0f;
+        samplesPerSliceSide = 3.0f;
+        break;
+    }
+}
+
+WGPUShaderModule create_shader_module(const char* label, const ResourceBuffer& source) {
+    WGPUShaderSourceWGSL wgsl = WGPU_SHADER_SOURCE_WGSL_INIT;
+    wgsl.code = {static_cast<const char*>(source.data), source.size};
+    WGPUShaderModuleDescriptor moduleDesc = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
+    moduleDesc.nextInChain = &wgsl.chain;
+    moduleDesc.label = {label, WGPU_STRLEN};
+    return wgpuDeviceCreateShaderModule(g_deviceInfo.device, &moduleDesc);
+}
+
+bool build_compute_pipeline(const char* label, const ResourceBuffer& source, const char* entry,
+    WGPUComputePipeline& outPipeline, WGPUBindGroupLayout& outLayout) {
+    WGPUShaderModule module = create_shader_module(label, source);
+    if (module == nullptr) {
+        return false;
+    }
+    WGPUComputePipelineDescriptor pipelineDesc = WGPU_COMPUTE_PIPELINE_DESCRIPTOR_INIT;
+    pipelineDesc.label = {label, WGPU_STRLEN};
+    pipelineDesc.compute.module = module;
+    pipelineDesc.compute.entryPoint = {entry, WGPU_STRLEN};
+    outPipeline = wgpuDeviceCreateComputePipeline(g_deviceInfo.device, &pipelineDesc);
+    wgpuShaderModuleRelease(module);
+    if (outPipeline == nullptr) {
+        return false;
+    }
+    outLayout = wgpuComputePipelineGetBindGroupLayout(outPipeline, 0);
+    return outLayout != nullptr;
+}
+
+bool build_composite_pipeline(
+    bool blend, WGPURenderPipeline& outPipeline, WGPUBindGroupLayout& outLayout) {
+    WGPUShaderModule module = create_shader_module("AO composite", g_compositeSource);
+    if (module == nullptr) {
+        return false;
+    }
+
+    // Multiply blend
+    WGPUBlendState blendState{
+        .color =
+            {
+                .operation = WGPUBlendOperation_Add,
+                .srcFactor = WGPUBlendFactor_Dst,
+                .dstFactor = WGPUBlendFactor_Zero,
+            },
+        .alpha =
+            {
+                .operation = WGPUBlendOperation_Add,
+                .srcFactor = WGPUBlendFactor_Zero,
+                .dstFactor = WGPUBlendFactor_One,
+            },
+    };
+    WGPUColorTargetState colorTargets[GFX_MAX_COLOR_ATTACHMENTS];
+    const uint32_t colorTargetCount = gfx_init_color_target_states(
+        &g_sceneTargetLayout, colorTargets, blend ? &blendState : nullptr, WGPUColorWriteMask_All);
+    WGPUFragmentState fragment = WGPU_FRAGMENT_STATE_INIT;
+    fragment.module = module;
+    fragment.entryPoint = {"fs_main", WGPU_STRLEN};
+    fragment.targetCount = colorTargetCount;
+    fragment.targets = colorTargets;
+    // Depth state must match the EFB pass despite never touching depth.
+    WGPUDepthStencilState depthStencil = WGPU_DEPTH_STENCIL_STATE_INIT;
+    depthStencil.format = g_sceneTargetLayout.depth_stencil_format;
+    depthStencil.depthWriteEnabled = WGPUOptionalBool_False;
+    depthStencil.depthCompare = WGPUCompareFunction_Always;
+
+    WGPURenderPipelineDescriptor pipelineDesc = WGPU_RENDER_PIPELINE_DESCRIPTOR_INIT;
+    pipelineDesc.label = {blend ? "AO composite" : "AO composite (debug)", WGPU_STRLEN};
+    pipelineDesc.vertex.module = module;
+    pipelineDesc.vertex.entryPoint = {"vs_main", WGPU_STRLEN};
+    pipelineDesc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+    pipelineDesc.depthStencil = &depthStencil;
+    pipelineDesc.multisample.count = g_sceneTargetLayout.sample_count;
+    pipelineDesc.fragment = &fragment;
+    outPipeline = wgpuDeviceCreateRenderPipeline(g_deviceInfo.device, &pipelineDesc);
+    wgpuShaderModuleRelease(module);
+    if (outPipeline == nullptr) {
+        return false;
+    }
+    outLayout = wgpuRenderPipelineGetBindGroupLayout(outPipeline, 0);
+    return outLayout != nullptr;
+}
+
+// Hilbert curve index LUT for the R2 noise sequence, generated once at init.
+// Ported from Bevy's generate_hilbert_index_lut (https://www.shadertoy.com/view/3tB3z3).
+uint16_t hilbert_index(uint16_t x, uint16_t y) {
+    uint16_t index = 0;
+    for (uint16_t level = 32; level > 0; level /= 2) {
+        const uint16_t regionX = (x & level) > 0 ? 1 : 0;
+        const uint16_t regionY = (y & level) > 0 ? 1 : 0;
+        index += level * level * ((3 * regionX) ^ regionY);
+        if (regionY == 0) {
+            if (regionX == 1) {
+                x = 63 - x;
+                y = 63 - y;
+            }
+            std::swap(x, y);
+        }
+    }
+    return index;
+}
+
+bool build_hilbert_lut() {
+    WGPUTextureDescriptor texDesc = WGPU_TEXTURE_DESCRIPTOR_INIT;
+    texDesc.label = {"AO hilbert LUT", WGPU_STRLEN};
+    texDesc.usage = WGPUTextureUsage_TextureBinding | WGPUTextureUsage_CopyDst;
+    texDesc.size = {64, 64, 1};
+    texDesc.format = WGPUTextureFormat_R16Uint;
+    g_hilbertLut = wgpuDeviceCreateTexture(g_deviceInfo.device, &texDesc);
+    if (g_hilbertLut == nullptr) {
+        return false;
+    }
+    g_hilbertLutView = wgpuTextureCreateView(g_hilbertLut, nullptr);
+    if (g_hilbertLutView == nullptr) {
+        return false;
+    }
+
+    uint16_t lut[64 * 64];
+    for (uint16_t y = 0; y < 64; ++y) {
+        for (uint16_t x = 0; x < 64; ++x) {
+            lut[y * 64 + x] = hilbert_index(x, y);
+        }
+    }
+    WGPUTexelCopyTextureInfo dst = WGPU_TEXEL_COPY_TEXTURE_INFO_INIT;
+    dst.texture = g_hilbertLut;
+    WGPUTexelCopyBufferLayout layout{.offset = 0, .bytesPerRow = 64 * 2, .rowsPerImage = 64};
+    WGPUExtent3D extent{64, 64, 1};
+    wgpuQueueWriteTexture(g_deviceInfo.queue, &dst, lut, sizeof(lut), &layout, &extent);
+    return true;
+}
+
+void release_targets(AoTargets& targets) {
+    for (auto*& view : targets.preprocessedDepthMips) {
+        if (view != nullptr) {
+            wgpuTextureViewRelease(view);
+            view = nullptr;
+        }
+    }
+    const auto releaseView = [](WGPUTextureView& view) {
+        if (view != nullptr) {
+            wgpuTextureViewRelease(view);
+            view = nullptr;
+        }
+    };
+    const auto releaseTexture = [](WGPUTexture& texture) {
+        if (texture != nullptr) {
+            wgpuTextureRelease(texture);
+            texture = nullptr;
+        }
+    };
+    releaseView(targets.preprocessedDepthAll);
+    releaseView(targets.aoNoisyView);
+    releaseView(targets.depthDifferencesView);
+    releaseView(targets.aoFinalView);
+    releaseTexture(targets.preprocessedDepth);
+    releaseTexture(targets.aoNoisy);
+    releaseTexture(targets.depthDifferences);
+    releaseTexture(targets.aoFinal);
+    targets.width = targets.height = 0;
+}
+
+void tick_retired_targets() {
+    for (auto it = g_retiredTargets.begin(); it != g_retiredTargets.end();) {
+        if (--it->framesLeft <= 0) {
+            release_targets(it->targets);
+            it = g_retiredTargets.erase(it);
+        } else {
+            ++it;
+        }
+    }
+}
+
+bool ensure_targets(uint32_t width, uint32_t height) {
+    if (g_targets.width == width && g_targets.height == height) {
+        return true;
+    }
+    if (g_targets.width != 0) {
+        g_retiredTargets.push_back(RetiredTargets{std::exchange(g_targets, AoTargets{}), 4});
+    }
+
+    const auto createStorageTexture = [&](const char* label, WGPUTextureFormat format,
+                                          uint32_t mipCount, WGPUTexture& outTexture) {
+        WGPUTextureDescriptor texDesc = WGPU_TEXTURE_DESCRIPTOR_INIT;
+        texDesc.label = {label, WGPU_STRLEN};
+        texDesc.usage = WGPUTextureUsage_StorageBinding | WGPUTextureUsage_TextureBinding;
+        texDesc.size = {width, height, 1};
+        texDesc.format = format;
+        texDesc.mipLevelCount = mipCount;
+        outTexture = wgpuDeviceCreateTexture(g_deviceInfo.device, &texDesc);
+        return outTexture != nullptr;
+    };
+
+    bool ok = createStorageTexture("AO preprocessed depth", WGPUTextureFormat_R32Float, 5,
+                  g_targets.preprocessedDepth) &&
+              createStorageTexture("AO noisy", WGPUTextureFormat_R32Float, 1, g_targets.aoNoisy) &&
+              createStorageTexture("AO depth differences", WGPUTextureFormat_R32Uint, 1,
+                  g_targets.depthDifferences) &&
+              createStorageTexture("AO final", WGPUTextureFormat_R32Float, 1, g_targets.aoFinal);
+    if (ok) {
+        for (uint32_t mip = 0; mip < 5 && ok; ++mip) {
+            WGPUTextureViewDescriptor viewDesc = WGPU_TEXTURE_VIEW_DESCRIPTOR_INIT;
+            viewDesc.baseMipLevel = mip;
+            viewDesc.mipLevelCount = 1;
+            g_targets.preprocessedDepthMips[mip] =
+                wgpuTextureCreateView(g_targets.preprocessedDepth, &viewDesc);
+            ok = g_targets.preprocessedDepthMips[mip] != nullptr;
+        }
+    }
+    if (ok) {
+        g_targets.preprocessedDepthAll =
+            wgpuTextureCreateView(g_targets.preprocessedDepth, nullptr);
+        g_targets.aoNoisyView = wgpuTextureCreateView(g_targets.aoNoisy, nullptr);
+        g_targets.depthDifferencesView = wgpuTextureCreateView(g_targets.depthDifferences, nullptr);
+        g_targets.aoFinalView = wgpuTextureCreateView(g_targets.aoFinal, nullptr);
+        ok = g_targets.preprocessedDepthAll != nullptr && g_targets.aoNoisyView != nullptr &&
+             g_targets.depthDifferencesView != nullptr && g_targets.aoFinalView != nullptr;
+    }
+    if (!ok) {
+        release_targets(g_targets);
+        return false;
+    }
+    g_targets.width = width;
+    g_targets.height = height;
+    return true;
+}
+
+constexpr uint32_t div_ceil(uint32_t numerator, uint32_t denominator) {
+    return (numerator + denominator - 1) / denominator;
+}
+
+// Render worker thread: the AO chain as one compute pass with three dispatches.
+void on_compute(
+    ModContext*, const GfxComputeContext* ctx, const void* payload, size_t payloadSize, void*) {
+    if (payloadSize != sizeof(ComputePayload)) {
+        return;
+    }
+    ComputePayload data;
+    std::memcpy(&data, payload, sizeof(data));
+    if (data.depth == nullptr || g_preprocessPipeline == nullptr) {
+        return;
+    }
+
+    const auto makeBindGroup = [&](WGPUBindGroupLayout layout,
+                                   std::initializer_list<WGPUBindGroupEntry> entries) {
+        WGPUBindGroupDescriptor bindGroupDesc = WGPU_BIND_GROUP_DESCRIPTOR_INIT;
+        bindGroupDesc.layout = layout;
+        bindGroupDesc.entryCount = entries.size();
+        bindGroupDesc.entries = entries.begin();
+        return wgpuDeviceCreateBindGroup(ctx->device, &bindGroupDesc);
+    };
+    const auto textureEntry = [](uint32_t binding, WGPUTextureView view) {
+        WGPUBindGroupEntry entry = WGPU_BIND_GROUP_ENTRY_INIT;
+        entry.binding = binding;
+        entry.textureView = view;
+        return entry;
+    };
+    const auto uniformEntry = [&](uint32_t binding) {
+        WGPUBindGroupEntry entry = WGPU_BIND_GROUP_ENTRY_INIT;
+        entry.binding = binding;
+        entry.buffer = ctx->uniform_buffer;
+        entry.offset = data.uniform_offset;
+        entry.size = data.uniform_size;
+        return entry;
+    };
+
+    WGPUBindGroup preprocessGroup = makeBindGroup(g_preprocessLayout,
+        {textureEntry(0, data.depth), textureEntry(1, data.preprocessedDepthMips[0]),
+            textureEntry(2, data.preprocessedDepthMips[1]),
+            textureEntry(3, data.preprocessedDepthMips[2]),
+            textureEntry(4, data.preprocessedDepthMips[3]), uniformEntry(5)});
+    WGPUBindGroup mip4Group =
+        makeBindGroup(g_mip4Layout, {textureEntry(6, data.preprocessedDepthMips[3]),
+                                        textureEntry(7, data.preprocessedDepthMips[4])});
+    WGPUBindGroup gtaoGroup = makeBindGroup(
+        g_gtaoLayout, {textureEntry(0, data.preprocessedDepthAll),
+                          textureEntry(1, g_hilbertLutView), textureEntry(2, data.aoNoisy),
+                          textureEntry(3, data.depthDifferences), uniformEntry(4)});
+    WGPUBindGroup denoiseGroup = makeBindGroup(
+        g_denoiseLayout, {textureEntry(0, data.aoNoisy), textureEntry(1, data.depthDifferences),
+                             textureEntry(2, data.aoFinal), uniformEntry(3)});
+    if (preprocessGroup == nullptr || mip4Group == nullptr || gtaoGroup == nullptr ||
+        denoiseGroup == nullptr)
+    {
+        const auto release = [](WGPUBindGroup group) {
+            if (group != nullptr) {
+                wgpuBindGroupRelease(group);
+            }
+        };
+        release(preprocessGroup);
+        release(mip4Group);
+        release(gtaoGroup);
+        release(denoiseGroup);
+        return;
+    }
+
+    WGPUComputePassDescriptor passDesc = WGPU_COMPUTE_PASS_DESCRIPTOR_INIT;
+    passDesc.label = {"AO chain", WGPU_STRLEN};
+    WGPUComputePassEncoder pass = wgpuCommandEncoderBeginComputePass(ctx->encoder, &passDesc);
+    // Each preprocess workgroup covers 16x16 MIP-0 texels (8x8 invocations, 2x2 texels each).
+    wgpuComputePassEncoderSetPipeline(pass, g_preprocessPipeline);
+    wgpuComputePassEncoderSetBindGroup(pass, 0, preprocessGroup, 0, nullptr);
+    wgpuComputePassEncoderDispatchWorkgroups(
+        pass, div_ceil(data.width, 16), div_ceil(data.height, 16), 1);
+    wgpuComputePassEncoderSetPipeline(pass, g_mip4Pipeline);
+    wgpuComputePassEncoderSetBindGroup(pass, 0, mip4Group, 0, nullptr);
+    wgpuComputePassEncoderDispatchWorkgroups(pass, div_ceil(std::max(data.width >> 4, 1u), 8),
+        div_ceil(std::max(data.height >> 4, 1u), 8), 1);
+    wgpuComputePassEncoderSetPipeline(pass, g_gtaoPipeline);
+    wgpuComputePassEncoderSetBindGroup(pass, 0, gtaoGroup, 0, nullptr);
+    wgpuComputePassEncoderDispatchWorkgroups(
+        pass, div_ceil(data.width, 8), div_ceil(data.height, 8), 1);
+    wgpuComputePassEncoderSetPipeline(pass, g_denoisePipeline);
+    wgpuComputePassEncoderSetBindGroup(pass, 0, denoiseGroup, 0, nullptr);
+    wgpuComputePassEncoderDispatchWorkgroups(
+        pass, div_ceil(data.width, 8), div_ceil(data.height, 8), 1);
+    wgpuComputePassEncoderEnd(pass);
+    wgpuComputePassEncoderRelease(pass);
+
+    wgpuBindGroupRelease(preprocessGroup);
+    wgpuBindGroupRelease(mip4Group);
+    wgpuBindGroupRelease(gtaoGroup);
+    wgpuBindGroupRelease(denoiseGroup);
+    g_chainExecuted.store(true, std::memory_order_release);
+}
+
+// Render worker thread: composite the AO over the scene (or show it, in debug view).
+void on_draw(
+    ModContext*, const GfxDrawContext* ctx, const void* payload, size_t payloadSize, void*) {
+    if (payloadSize != sizeof(CompositePayload) || ctx->layout.key != g_sceneTargetLayout.key) {
+        return;
+    }
+    CompositePayload data;
+    std::memcpy(&data, payload, sizeof(data));
+    WGPURenderPipeline pipeline =
+        data.debug_view != 0 ? g_compositeDebugPipeline : g_compositePipeline;
+    WGPUBindGroupLayout layout = data.debug_view != 0 ? g_compositeDebugLayout : g_compositeLayout;
+    if (data.aoFinal == nullptr || data.preprocessedDepth == nullptr ||
+        data.sceneDepth == nullptr || pipeline == nullptr)
+    {
+        return;
+    }
+
+    WGPUBindGroupEntry entries[4] = {WGPU_BIND_GROUP_ENTRY_INIT, WGPU_BIND_GROUP_ENTRY_INIT,
+        WGPU_BIND_GROUP_ENTRY_INIT, WGPU_BIND_GROUP_ENTRY_INIT};
+    entries[0].binding = 0;
+    entries[0].textureView = data.aoFinal;
+    entries[1].binding = 1;
+    entries[1].textureView = data.preprocessedDepth;
+    entries[2].binding = 2;
+    entries[2].textureView = data.sceneDepth;
+    entries[3].binding = 3;
+    entries[3].buffer = ctx->uniform_buffer;
+    entries[3].offset = data.uniform_offset;
+    entries[3].size = data.uniform_size;
+    WGPUBindGroupDescriptor bindGroupDesc = WGPU_BIND_GROUP_DESCRIPTOR_INIT;
+    bindGroupDesc.layout = layout;
+    bindGroupDesc.entryCount = 4;
+    bindGroupDesc.entries = entries;
+    WGPUBindGroup bindGroup = wgpuDeviceCreateBindGroup(ctx->device, &bindGroupDesc);
+    if (bindGroup == nullptr) {
+        return;
+    }
+
+    wgpuRenderPassEncoderSetPipeline(ctx->pass, pipeline);
+    wgpuRenderPassEncoderSetBindGroup(ctx->pass, 0, bindGroup, 0, nullptr);
+    wgpuRenderPassEncoderDraw(ctx->pass, 3, 1, 0, 0);
+    wgpuBindGroupRelease(bindGroup);
+}
+
+// Game thread, after opaque scene draws and before translucent/fog overlay lists.
+void on_scene_after_opaque(ModContext*, const GfxStageContext* stageCtx, void*) {
+    tick_retired_targets();
+    if (!get_bool_option(g_cvarEnabled, true)) {
+        return;
+    }
+    if (stageCtx == nullptr || stageCtx->struct_size < sizeof(GfxStageContext) ||
+        stageCtx->game_view == nullptr)
+    {
+        return;
+    }
+
+    CameraInfo camera = CAMERA_INFO_INIT;
+    if (svc_camera->get_camera(mod_ctx, stageCtx->game_view, &camera) != MOD_OK) {
+        return;
+    }
+
+    GfxResolveDesc resolveDesc = GFX_RESOLVE_DESC_INIT;
+    resolveDesc.color = false;
+    resolveDesc.depth = true;
+    GfxResolvedTargets resolved = GFX_RESOLVED_TARGETS_INIT;
+    if (svc_gfx->resolve_pass(mod_ctx, &resolveDesc, &resolved) != MOD_OK ||
+        resolved.depth == nullptr)
+    {
+        if (!g_warnedNoDepth) {
+            g_warnedNoDepth = true;
+            svc_log->warn(mod_ctx, "depth snapshots unavailable; AO disabled");
+        }
+        return;
+    }
+
+    const bool halfRes = get_bool_option(g_cvarHalfRes, false);
+    const uint32_t divisor = halfRes ? 2 : 1;
+    const uint32_t width = resolved.width / divisor;
+    const uint32_t height = resolved.height / divisor;
+    if (width < 32 || height < 32 || !ensure_targets(width, height)) {
+        return;
+    }
+
+    AoUniforms uniforms{};
+    std::memcpy(uniforms.projection, camera.proj_from_view, sizeof(uniforms.projection));
+    std::memcpy(
+        uniforms.inverse_projection, camera.view_from_proj, sizeof(uniforms.inverse_projection));
+    uniforms.size[0] = static_cast<float>(width);
+    uniforms.size[1] = static_cast<float>(height);
+    uniforms.inv_size[0] = 1.0f / uniforms.size[0];
+    uniforms.inv_size[1] = 1.0f / uniforms.size[1];
+    uniforms.depth_scale[0] = static_cast<float>(resolved.width) / uniforms.size[0];
+    uniforms.depth_scale[1] = static_cast<float>(resolved.height) / uniforms.size[1];
+    uniforms.effect_radius =
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarRadius, 70), 10, 500));
+    uniforms.intensity =
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarIntensity, 100), 0, 100)) /
+        100.0f;
+    quality_counts(
+        get_int_option(g_cvarQuality, 2), uniforms.slice_count, uniforms.samples_per_slice_side);
+    const uint32_t debugMode =
+        static_cast<uint32_t>(std::clamp<int64_t>(get_int_option(g_cvarDebugView, 0), 0, 4));
+    uniforms.debug_view = debugMode;
+
+    GfxRange uniformRange{0, 0};
+    if (svc_gfx->push_uniform(mod_ctx, &uniforms, sizeof(uniforms), &uniformRange) != MOD_OK) {
+        return;
+    }
+
+    ComputePayload computePayload{};
+    computePayload.depth = resolved.depth;
+    for (int mip = 0; mip < 5; ++mip) {
+        computePayload.preprocessedDepthMips[mip] = g_targets.preprocessedDepthMips[mip];
+    }
+    computePayload.preprocessedDepthAll = g_targets.preprocessedDepthAll;
+    computePayload.aoNoisy = g_targets.aoNoisyView;
+    computePayload.depthDifferences = g_targets.depthDifferencesView;
+    computePayload.aoFinal = g_targets.aoFinalView;
+    computePayload.uniform_offset = uniformRange.offset;
+    computePayload.uniform_size = uniformRange.size;
+    computePayload.width = width;
+    computePayload.height = height;
+    if (svc_gfx->push_compute(mod_ctx, g_computeType, &computePayload, sizeof(computePayload)) !=
+        MOD_OK)
+    {
+        return;
+    }
+
+    const CompositePayload drawPayload{g_targets.aoFinalView, g_targets.preprocessedDepthAll,
+        resolved.depth, uniformRange.offset, uniformRange.size, debugMode};
+    svc_gfx->push_draw(mod_ctx, g_drawType, &drawPayload, sizeof(drawPayload));
+}
+
+void add_control(UiElementHandle pane, const UiControlDesc& desc) {
+    svc_ui->pane_add_control(mod_ctx, pane, &desc, nullptr);
+}
+
+void add_toggle(UiElementHandle pane, const char* label, ConfigVarHandle cvar, const char* help) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_TOGGLE;
+    control.label = label;
+    control.help_rml = help;
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = cvar;
+    add_control(pane, control);
+}
+
+ModResult build_controls_tab(
+    ModContext*, UiWindowHandle, UiElementHandle left, UiElementHandle right, void*, ModError*) {
+    (void)right;
+
+    svc_ui->pane_add_section(mod_ctx, left, "Ambient Occlusion");
+    add_toggle(left, "Enabled", g_cvarEnabled, "Enables the GTAO pass.");
+
+    static const char* kQualityOptions[] = {"Low", "Medium", "High", "Ultra"};
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_SELECT;
+    control.label = "Quality";
+    control.help_rml = "Horizon slices and samples per pixel (XeGTAO presets: 4/8/18/54 spp).";
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = g_cvarQuality;
+    control.options = kQualityOptions;
+    control.option_count = 4;
+    add_control(left, control);
+
+    control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_NUMBER;
+    control.label = "Radius";
+    control.help_rml = "Occlusion sampling radius in world units.";
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = g_cvarRadius;
+    control.min = 10;
+    control.max = 500;
+    control.step = 10;
+    add_control(left, control);
+
+    control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_NUMBER;
+    control.label = "Intensity";
+    control.help_rml = "How strongly occlusion darkens the scene.";
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = g_cvarIntensity;
+    control.min = 0;
+    control.max = 100;
+    control.step = 5;
+    control.suffix = "%";
+    add_control(left, control);
+
+    add_toggle(left, "Half Resolution", g_cvarHalfRes,
+        "Computes AO at half resolution and upscales; faster, slightly softer.");
+
+    static const char* kDebugOptions[] = {"Off", "AO", "Normals", "Depth", "Staircase"};
+    control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_SELECT;
+    control.label = "Debug View";
+    control.help_rml = "AO: raw visibility as grayscale.<br/>Normals: the view-space "
+                       "normals the GTAO pass consumes.<br/>Depth: the preprocessed depth "
+                       "as a distance gradient.<br/>Staircase: detects quantized depth - smooth "
+                       "depth is near-black with thin triangle edges, quantized depth lights "
+                       "up across surfaces.";
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = g_cvarDebugView;
+    control.options = kDebugOptions;
+    control.option_count = 5;
+    add_control(left, control);
+    return MOD_OK;
+}
+
+void on_controls_window_closed(ModContext*, UiWindowHandle, void*) {
+    g_controlsWindow = 0;
+}
+
+void on_open_controls(ModContext*, void*) {
+    if (g_controlsWindow != 0) {
+        return;
+    }
+    UiTabDesc tabs[1] = {UI_TAB_DESC_INIT};
+    tabs[0].title = "Controls";
+    tabs[0].build = build_controls_tab;
+    UiWindowDesc desc = UI_WINDOW_DESC_INIT;
+    desc.tabs = tabs;
+    desc.tab_count = 1;
+    desc.on_closed = on_controls_window_closed;
+    if (svc_ui->window_push(mod_ctx, &desc, &g_controlsWindow) != MOD_OK) {
+        svc_log->error(mod_ctx, "failed to open AO controls window");
+    }
+}
+
+ModResult build_panel(ModContext*, UiElementHandle panel, void*, ModError*) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_TOGGLE;
+    control.label = "Enabled";
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = g_cvarEnabled;
+    add_control(panel, control);
+
+    control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_BUTTON;
+    control.label = "Open Controls";
+    control.on_pressed = on_open_controls;
+    add_control(panel, control);
+    return MOD_OK;
+}
+
+ModResult register_bool_option(
+    const char* name, bool defaultValue, ConfigVarHandle& outHandle, ModError* error) {
+    ConfigVarDesc cvarDesc = CONFIG_VAR_DESC_INIT;
+    cvarDesc.name = name;
+    cvarDesc.type = CONFIG_VAR_BOOL;
+    cvarDesc.default_bool = defaultValue;
+    if (svc_config->register_var(mod_ctx, &cvarDesc, &outHandle) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register AO option");
+    }
+    return MOD_OK;
+}
+
+ModResult register_int_option(
+    const char* name, int64_t defaultValue, ConfigVarHandle& outHandle, ModError* error) {
+    ConfigVarDesc cvarDesc = CONFIG_VAR_DESC_INIT;
+    cvarDesc.name = name;
+    cvarDesc.type = CONFIG_VAR_INT;
+    cvarDesc.default_int = defaultValue;
+    if (svc_config->register_var(mod_ctx, &cvarDesc, &outHandle) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register AO option");
+    }
+    return MOD_OK;
+}
+
+}  // namespace
+
+extern "C" {
+
+MOD_EXPORT ModResult mod_initialize(ModError* error) {
+    ModResult result = svc_resource->load(mod_ctx, "preprocess_depth.wgsl", &g_preprocessSource);
+    if (result == MOD_OK) {
+        result = svc_resource->load(mod_ctx, "gtao.wgsl", &g_gtaoSource);
+    }
+    if (result == MOD_OK) {
+        result = svc_resource->load(mod_ctx, "denoise.wgsl", &g_denoiseSource);
+    }
+    if (result == MOD_OK) {
+        result = svc_resource->load(mod_ctx, "composite.wgsl", &g_compositeSource);
+    }
+    if (result != MOD_OK) {
+        return mods::set_error(error, result, "failed to load AO shaders");
+    }
+
+    result = register_bool_option("effectEnabled", false, g_cvarEnabled, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("quality", 2, g_cvarQuality, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("radius", 70, g_cvarRadius, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("intensity", 100, g_cvarIntensity, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_bool_option("halfRes", false, g_cvarHalfRes, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("debugMode", 0, g_cvarDebugView, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+
+    if (svc_gfx->get_device_info(mod_ctx, &g_deviceInfo) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to query device info");
+    }
+    if (svc_gfx->get_scene_target_layout(mod_ctx, &g_sceneTargetLayout) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to query scene target layout");
+    }
+    if (!build_compute_pipeline("AO preprocess depth", g_preprocessSource, "preprocess_depth",
+            g_preprocessPipeline, g_preprocessLayout) ||
+        !build_compute_pipeline("AO downsample mip4", g_preprocessSource, "downsample_mip4",
+            g_mip4Pipeline, g_mip4Layout) ||
+        !build_compute_pipeline("AO gtao", g_gtaoSource, "gtao", g_gtaoPipeline, g_gtaoLayout) ||
+        !build_compute_pipeline(
+            "AO denoise", g_denoiseSource, "spatial_denoise", g_denoisePipeline, g_denoiseLayout))
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to create AO compute pipelines");
+    }
+    if (!build_composite_pipeline(true, g_compositePipeline, g_compositeLayout) ||
+        !build_composite_pipeline(false, g_compositeDebugPipeline, g_compositeDebugLayout))
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to create AO composite pipeline");
+    }
+    if (!build_hilbert_lut()) {
+        return mods::set_error(error, MOD_ERROR, "failed to create AO noise LUT");
+    }
+
+    GfxComputeTypeDesc computeDesc = GFX_COMPUTE_TYPE_DESC_INIT;
+    computeDesc.label = "AO chain";
+    computeDesc.callback = on_compute;
+    if (svc_gfx->register_compute_type(mod_ctx, &computeDesc, &g_computeType) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register compute type");
+    }
+    GfxDrawTypeDesc drawDesc = GFX_DRAW_TYPE_DESC_INIT;
+    drawDesc.label = "AO composite";
+    drawDesc.draw = on_draw;
+    if (svc_gfx->register_draw_type(mod_ctx, &drawDesc, &g_drawType) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register draw type");
+    }
+    GfxStageHookDesc stageDesc = GFX_STAGE_HOOK_DESC_INIT;
+    stageDesc.callback = on_scene_after_opaque;
+    if (svc_gfx->register_stage_hook(
+            mod_ctx, GFX_STAGE_SCENE_AFTER_OPAQUE, &stageDesc, &g_afterOpaqueHook) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to register stage hook");
+    }
+
+    UiModsPanelDesc panelDesc = UI_MODS_PANEL_DESC_INIT;
+    panelDesc.build = build_panel;
+    svc_ui->register_mods_panel(mod_ctx, &panelDesc);
+
+    svc_log->info(mod_ctx, "ao_mod ready");
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    if (!g_loggedChain && g_chainExecuted.load(std::memory_order_acquire)) {
+        g_loggedChain = true;
+        svc_log->info(mod_ctx, "AO chain executed OK");
+    }
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_shutdown(ModError*) {
+    svc_resource->free(mod_ctx, &g_preprocessSource);
+    svc_resource->free(mod_ctx, &g_gtaoSource);
+    svc_resource->free(mod_ctx, &g_denoiseSource);
+    svc_resource->free(mod_ctx, &g_compositeSource);
+
+    release_targets(g_targets);
+    for (auto& retired : g_retiredTargets) {
+        release_targets(retired.targets);
+    }
+    g_retiredTargets.clear();
+
+    const auto releasePipeline = [](WGPUComputePipeline& pipeline) {
+        if (pipeline != nullptr) {
+            wgpuComputePipelineRelease(pipeline);
+            pipeline = nullptr;
+        }
+    };
+    const auto releaseLayout = [](WGPUBindGroupLayout& layout) {
+        if (layout != nullptr) {
+            wgpuBindGroupLayoutRelease(layout);
+            layout = nullptr;
+        }
+    };
+    releasePipeline(g_preprocessPipeline);
+    releasePipeline(g_mip4Pipeline);
+    releasePipeline(g_gtaoPipeline);
+    releasePipeline(g_denoisePipeline);
+    releaseLayout(g_preprocessLayout);
+    releaseLayout(g_mip4Layout);
+    releaseLayout(g_gtaoLayout);
+    releaseLayout(g_denoiseLayout);
+    if (g_compositePipeline != nullptr) {
+        wgpuRenderPipelineRelease(g_compositePipeline);
+        g_compositePipeline = nullptr;
+    }
+    if (g_compositeDebugPipeline != nullptr) {
+        wgpuRenderPipelineRelease(g_compositeDebugPipeline);
+        g_compositeDebugPipeline = nullptr;
+    }
+    releaseLayout(g_compositeLayout);
+    releaseLayout(g_compositeDebugLayout);
+    if (g_hilbertLutView != nullptr) {
+        wgpuTextureViewRelease(g_hilbertLutView);
+        g_hilbertLutView = nullptr;
+    }
+    if (g_hilbertLut != nullptr) {
+        wgpuTextureRelease(g_hilbertLut);
+        g_hilbertLut = nullptr;
+    }
+    g_cvarEnabled = g_cvarQuality = g_cvarRadius = g_cvarIntensity = 0;
+    g_cvarHalfRes = g_cvarDebugView = 0;
+    g_computeType = g_drawType = 0;
+    g_afterOpaqueHook = 0;
+    g_controlsWindow = 0;
+    return MOD_OK;
+}
+}
diff --git a/mods/cosmetics b/mods/cosmetics
new file mode 160000
index 0000000000..93971c38aa
--- /dev/null
+++ b/mods/cosmetics
@@ -0,0 +1 @@
+Subproject commit 93971c38aa7286c59be7c3874a95e12d1a37036a
diff --git a/mods/custom_actor_demo/CMakeLists.txt b/mods/custom_actor_demo/CMakeLists.txt
new file mode 100644
index 0000000000..d7e55536d4
--- /dev/null
+++ b/mods/custom_actor_demo/CMakeLists.txt
@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.25)
+project(custom_actor_demo CXX)
+set(CMAKE_CXX_STANDARD 20)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(DUSK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../.." CACHE PATH "Path to dusk source root")
+    option(DUSK_MOD_USE_FULL_TREE "Use full build instead of the minimal mod SDK" OFF)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    if (DUSK_MOD_USE_FULL_TREE)
+        add_subdirectory("${DUSK_DIR}" dusk EXCLUDE_FROM_ALL)
+    else ()
+        add_subdirectory("${DUSK_DIR}/sdk" dusk-sdk EXCLUDE_FROM_ALL)
+    endif ()
+endif ()
+
+add_mod(custom_actor_demo
+    FEATURES game fmt
+    SOURCES  src/mod.cpp src/m_a_obj_wrock.cpp src/m_a_mine.cpp
+    MOD_JSON mod.json
+    RES_DIR  res
+)
diff --git a/mods/custom_actor_demo/mod.json b/mods/custom_actor_demo/mod.json
new file mode 100644
index 0000000000..55f57c264d
--- /dev/null
+++ b/mods/custom_actor_demo/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "dev.twilitrealm.custom_actor_demo",
+  "name": "[Demo] Custom Actor",
+  "version": "1.0.0",
+  "author": "Twilit Realm",
+  "description": "A mod to demonstrate how to create and use custom actors. Spawns a \"wrock\" in South Faron Woods."
+}
diff --git a/tools/mod_template/res/.gitkeep b/mods/custom_actor_demo/res/.gitkeep
similarity index 100%
rename from tools/mod_template/res/.gitkeep
rename to mods/custom_actor_demo/res/.gitkeep
diff --git a/mods/custom_actor_demo/src/m_a_mine.cpp b/mods/custom_actor_demo/src/m_a_mine.cpp
new file mode 100644
index 0000000000..fd7fa77b65
--- /dev/null
+++ b/mods/custom_actor_demo/src/m_a_mine.cpp
@@ -0,0 +1,227 @@
+#include "m_a_mine.hpp"
+#include "d/d_com_inf_game.h"
+#include "res/Object/O_mD_jira.h"
+
+// The name of the archive in /res/Object/
+static const char* l_resName = "O_mD_jira";
+
+// The actor's heap (for resources) should be enough to hold the data for the model and collision
+static constexpr u32 heap_size = ALIGN_NEXT(16832, 0x20);
+
+ma_Mine_c::~ma_Mine_c() {
+    // Called every time the actor is deleted
+
+    // Delete the sound object
+    mSound.deleteObject();
+
+    // Request to unload the archive (the data acts as a shared pointer, and only gets deleted when
+    // the reference counter goes to zero)
+    dComIfG_resDelete(&mPhase, l_resName);
+}
+
+cPhs_Step ma_Mine_c::create() {
+    // Because of how the actor system works, an actor's constructor doesn't get called when an
+    // actor is created. We need to manually do it here with the following ma:
+    fopAcM_ct(this, ma_Mine_c);
+
+    // The create function gets called until we return cPhs_COMPLEATE_e while an actor is loading.
+    // We request to load the archive here, and wait until the dvd completes loading it
+    cPhs_Step step = dComIfG_resLoad(&mPhase, l_resName);
+    if (step == cPhs_COMPLEATE_e) {
+        // Initialize the solid heap for the actor's resources, if needed
+        if (!fopAcM_entrySolidHeap(this, createHeapCallBack, heap_size)) {
+            return cPhs_ERROR_e;
+        }
+
+        // Setup our collision sphere and register it to the world
+        // Set a circle "wall" of 30 units around the actor
+        mAcchCir.SetWall(30.0f, 30.0f);
+        mAcch.Set(this, 1, &mAcchCir);
+        mAcch.ClrWaterNone();
+        mAcch.SetRoofCrrHeight(60.0f);
+        mAcch.SetWaterCheckOffset(10000.0f);
+        mAcch.SetWtrChkMode(2);
+        mAcch.OnLineCheck();
+
+        mCcStts.Init(30, 0xFF, this);
+
+        // Collision Sphere for the actor (copied from Bomb Actor)
+        static const dCcD_SrcSph
+            l_sphSrc = {.mObjInf =
+                            {
+                                .mObj = {.mFlags = 0x0,
+                                    .mSrcObjHitInf = {.mObjAt = {.mType = AT_TYPE_BOMB,
+                                                          .mAtp = 0x4,
+                                                          .mBase = {.mSPrm = 0x1e}},
+                                        .mObjTg = {.mType = 0xd8fbffef, .mBase = {.mSPrm = 0x11}},
+                                        .mObjCo = {.mBase = {.mSPrm = 0x79}}}},
+                                .mGObjAt{.mSe = dCcD_SE_NONE,
+                                    .mHitMark = 0x0,
+                                    .mSpl = 0x1,
+                                    .mMtrl = 0x0,
+                                    .mBase = {.mGFlag = 0x0}},
+                                .mGObjTg{.mSe = dCcD_SE_NONE,
+                                    .mHitMark = 0x0,
+                                    .mSpl = 0x0,
+                                    .mMtrl = 0x0,
+                                    .mBase = {.mGFlag = 0x4}},
+                                .mGObjCo{.mBase = {.mGFlag = 0x0}},
+                            },
+                .mSphAttr = {.mSph = {.mCenter = {0.0f, 0.0f, 0.0f}, .mRadius = 80.0f}}};
+
+        mCollisionSphere.Set(l_sphSrc);
+        mCollisionSphere.SetStts(&mCcStts);
+
+        // We register a callback anytime the actor is hit (both attacks and is hit)
+        mCollisionSphere.SetAtHitCallback(atHitCallback);
+        mCollisionSphere.SetTgHitCallback(atHitCallback);
+        mCollisionSphere.OffTgSetBit();
+        mCollisionSphere.OffCoSetBit();
+        mCollisionSphere.OnAtSetBit();  // Enable the attack sphere
+
+        // Set the initial matrix and cull box for the actor
+        fopAcM_SetMtx(this, mpModel->getBaseTRMtx());
+        fopAcM_SetMin(this, -36.0f, 0.0f, -36.0f);
+        fopAcM_SetMax(this, 36.0f, 66.0f, 36.0f);
+
+        // Call execute so the actor's information in the world can be updated
+        Execute();
+    }
+    return step;
+}
+
+// Initializes the heap that all instances of this actor will use for resources
+// Gets called from the callback in fopAcM_entrySolidHeap
+int ma_Mine_c::CreateHeap() {
+    // Get the bmd data from the archive and initialize it
+    J3DModelData* model_data =
+        (J3DModelData*)dComIfG_getObjectRes(l_resName, dRes_INDEX_O_MD_JIRA_BMD_O_MD_JIRAI_e);
+    if (model_data == NULL) {
+        return 0;
+    }
+    mpModel = mDoExt_J3DModel__create(model_data, 0x80000, 0x11000084);
+    if (mpModel == NULL) {
+        return 0;
+    }
+
+    // Create the sound object the actor will use
+    mSound.init(&current.pos, 1);
+
+    return 1;
+}
+
+int ma_Mine_c::createHeapCallBack(fopAc_ac_c* i_this) {
+    return static_cast<ma_Mine_c*>(i_this)->CreateHeap();
+}
+
+int ma_Mine_c::Delete() {
+    // Call the destructor anytime we delete the actor
+    this->~ma_Mine_c();
+    return 1;
+}
+
+int ma_Mine_c::Execute() {
+    // Update collision with the world
+    mAcch.CrrPos(dComIfG_Bgsp());
+    mCollisionSphere.SetC(attention_info.position);
+    dComIfG_Ccsp()->Set(&mCollisionSphere);
+
+    // Get the collision below the actor
+    cBgS_GndChk groundChunk = mAcch.m_gnd;
+    f32 groundH = mAcch.GetGroundH();
+    if (groundH != -G_CM3D_F_INF) {
+        // Set the actor's environment colors to match the room's current ones
+        int roomNo = dComIfG_Bgsp().GetRoomId(groundChunk);
+        tevStr.YukaCol = dComIfG_Bgsp().GetPolyColor(groundChunk);
+        tevStr.room_no = roomNo;
+
+        // Set the actor's room to be where it is sitting
+        mCcStts.SetRoomId(roomNo);
+        fopAcM_SetRoomNo(this, roomNo);
+
+        // Get the reverb info here that the actor can use when exploding
+        mReverb = dComIfGp_getReverb(roomNo);
+    }
+
+    // Update the model's transformation matrix to match the actor's transform
+    mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
+    mDoMtx_stack_c::ZXYrotM(shape_angle);
+    mDoMtx_stack_c::scaleM(scale);
+    mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
+
+    // Set any attention flags (if needed)
+    eyePos = attention_info.position = current.pos;
+    attention_info.flags = 0;
+    return 1;
+}
+
+int ma_Mine_c::Draw() {
+    // Update the model's lighting with the scene
+    g_env_light.settingTevStruct(0x20, &current.pos, &tevStr);
+    g_env_light.setLightTevColorType_MAJI(mpModel, &tevStr);
+
+    // Set the bmd model to be drawn when the display list is executed
+    mDoExt_modelUpdateDL(mpModel);
+
+    return 1;
+}
+
+void ma_Mine_c::atHit(dCcD_GObjInf* i_atObjInf) {
+    // Create particles with these IDs at the actor's position
+    static const u16 normalNameID[] = {
+        0x161, 0x162, 0x163, 0x164, 0x165, 0x166, 0x167, 0x168, 0x1EC};
+    for (int i = 0; i < ARRAY_SIZE(normalNameID); i++) {
+        dComIfGp_particle_setColor(normalNameID[i], &current.pos, &tevStr, NULL, NULL, 0.0f, 0xFF,
+            &shape_angle, &scale, NULL, -1, NULL);
+    }
+
+    // Create an explosion sound
+    mSound.startSound(Z2SE_OBJ_BOMB_EXPLODE, 0, mReverb);
+
+    // Vibrate the controller
+    dComIfGp_getVibration().StartShock(4, 31, cXyz(0.0f, 1.0f, 0.0f));
+
+    // Request to delete the actor so it disappears
+    fopAcM_delete(this);
+}
+
+void ma_Mine_c::atHitCallback(fopAc_ac_c* i_tgActor, dCcD_GObjInf* i_tgObjInf,
+    fopAc_ac_c* i_atActor, dCcD_GObjInf* i_atObjInf) {
+    // This callback gets triggered anytime an intersection happens with the object's collision sphere
+    ((ma_Mine_c*)i_tgActor)->atHit(i_atObjInf);
+}
+
+static cPhs_Step ma_Mine_create(void* i_this) {
+    return static_cast<ma_Mine_c*>(i_this)->create();
+}
+
+static int maMine_Delete(void* i_this) {
+    return static_cast<ma_Mine_c*>(i_this)->Delete();
+}
+
+static int maMine_Execute(void* i_this) {
+    return static_cast<ma_Mine_c*>(i_this)->Execute();
+}
+
+static int maMine_Draw(void* i_this) {
+    return static_cast<ma_Mine_c*>(i_this)->Draw();
+}
+
+static int maMine_IsDelete(void*) {
+    return 1;
+}
+
+s16 ma_Mine_c::sProcName = -1;
+ActorHandle ma_Mine_c::sActorHandle = -1;
+const ActorProfileDesc ma_Mine_c::sProfile = {.name = MA_MINE_NAME,
+    .priority_group = 7,
+    .process_size = sizeof(ma_Mine_c),
+    .draw_priority = fpcDwPi_OBJ_LBOX_e,  // An unused draw priority
+    .status = fopAcStts_UNK_0x40000_e | fopAcStts_UNK_0x4000_e | fopAcStts_CULL_e,
+    .group = fopAc_ACTOR_e,
+    .cull_type = fopAc_CULLBOX_CUSTOM_e,
+    .create_function = ma_Mine_create,
+    .delete_function = maMine_Delete,
+    .execute_function = maMine_Execute,
+    .is_delete_function = maMine_IsDelete,
+    .draw_function = maMine_Draw};
diff --git a/mods/custom_actor_demo/src/m_a_mine.hpp b/mods/custom_actor_demo/src/m_a_mine.hpp
new file mode 100644
index 0000000000..147938473f
--- /dev/null
+++ b/mods/custom_actor_demo/src/m_a_mine.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include "mods/svc/actor.h"
+
+// Base actor class definitions
+#include "f_op/f_op_actor.h"
+
+// Definitions for request_of_phase_process_class and cPhs_Step
+#include "SSystem/SComponent/c_phase.h"
+
+// Definitions for collision
+#include "d/d_bg_s_acch.h"
+#include "d/d_bg_w.h"
+#include "d/d_cc_d.h"
+
+#define MA_MINE_NAME "m_mine"
+
+class ma_Mine_c : public fopAc_ac_c {
+public:
+    request_of_phase_process_class mPhase;
+    J3DModel* mpModel;
+    dBgS_ObjAcch mAcch;
+    dBgS_AcchCir mAcchCir;
+    Mtx mColliderMtx;
+    dCcD_Stts mCcStts;
+    dCcD_Sph mCollisionSphere;
+    Z2SoundObjSimple mSound;
+    s8 mReverb;
+
+    virtual ~ma_Mine_c();
+    cPhs_Step create();
+    int CreateHeap();
+    int Delete();
+    int Execute();
+    int Draw();
+    void atHit(dCcD_GObjInf* i_atObjInf);
+    static int createHeapCallBack(fopAc_ac_c*);
+    static void atHitCallback(fopAc_ac_c* i_tgActor, dCcD_GObjInf* i_tgObjInf,
+        fopAc_ac_c* i_atActor, dCcD_GObjInf* i_atObjInf);
+
+    static s16 sProcName;
+    static ActorHandle sActorHandle;
+    static const ActorProfileDesc sProfile;
+};
diff --git a/mods/custom_actor_demo/src/m_a_obj_wrock.cpp b/mods/custom_actor_demo/src/m_a_obj_wrock.cpp
new file mode 100644
index 0000000000..bb40d10cf3
--- /dev/null
+++ b/mods/custom_actor_demo/src/m_a_obj_wrock.cpp
@@ -0,0 +1,195 @@
+/*
+ * m_a_obj_wrock.cpp
+ * An example actor for a rock that can be placed in the world.
+ */
+
+#include "m_a_obj_wrock.hpp"
+#include "d/d_com_inf_game.h"
+#include "res/Object/WRock.h"
+
+// The name of the archive in /res/Object/
+static const char* l_resName = "Wrock";
+
+// The actor's heap (for resources) should be enough to hold the data for the model and collision
+static constexpr u32 heap_size = ALIGN_NEXT(13952, 0x20) + ALIGN_NEXT(1920, 0x20);
+
+maObj_Wrock_c::~maObj_Wrock_c() {
+    // Called every time the actor is deleted
+
+    // Remove the collider from the world's collision
+    if (mpCollider != NULL) {
+        dComIfG_Bgsp().Release(mpCollider);
+    }
+
+    // Request to unload the archive (the data acts as a shared pointer, and only gets deleted when
+    // the reference counter goes to zero)
+    dComIfG_resDelete(&mPhase, l_resName);
+}
+
+cPhs_Step maObj_Wrock_c::create() {
+    // Because of how the actor system works, an actor's constructor doesn't get called when an
+    // actor is created. We need to manually do it here with the following macro:
+    fopAcM_ct(this, maObj_Wrock_c);
+
+    // The create function gets called until we return cPhs_COMPLEATE_e while an actor is loading.
+    // We request to load the archive here, and wait until the dvd completes loading it
+    cPhs_Step step = dComIfG_resLoad(&mPhase, l_resName);
+    if (step == cPhs_COMPLEATE_e) {
+        // Initialize the solid heap for the actor's resources, if needed
+        if (!fopAcM_entrySolidHeap(this, createHeapCallBack, heap_size)) {
+            return cPhs_ERROR_e;
+        }
+
+        // Register the actor's collider to the current world's collision
+        if (mpCollider != NULL) {
+            if (dComIfG_Bgsp().Regist(mpCollider, this) == true) {
+                return cPhs_ERROR_e;
+            }
+        }
+
+        // Set the initial matrix and cull box for the actor
+        fopAcM_SetMtx(this, mpModel->getBaseTRMtx());
+        fopAcM_setCullSizeBox(this, -400.0f, -400.0f, -400.0f, 400.0f, 400.0f, 400.0f);
+
+        // Setup collision info (will be used in execute)
+        mAcch.Set(&current.pos, &old.pos, this, 1, &mAcchCir, &speed, &current.angle, &shape_angle);
+
+        // Call execute so the actor's information in the world can be updated
+        Execute();
+    }
+    return step;
+}
+
+// Initializes the heap that all instances of this actor will use for resources
+// Gets called from the callback in fopAcM_entrySolidHeap
+int maObj_Wrock_c::CreateHeap() {
+    // Get the bmd data from the archive and initialize it
+    J3DModelData* model_data =
+        (J3DModelData*)dComIfG_getObjectRes(l_resName, dRes_INDEX_WROCK_BMD_WROCK_e);
+    if (model_data == NULL) {
+        return 0;
+    }
+    mpModel = mDoExt_J3DModel__create(model_data, 0x80000, 0x11000084);
+    if (mpModel == NULL) {
+        return 0;
+    }
+
+    // Get the dzb collision data from the archive and initialize it
+    mpCollider = JKR_NEW dBgW();
+    if (mpCollider == NULL) {
+        return 0;
+    }
+    cBgD_t* dzb = (cBgD_t*)dComIfG_getObjectRes(l_resName, dRes_INDEX_WROCK_DZB_WROCK_e);
+    if (mpCollider->Set(dzb, 1, &mColliderMtx) == true) {
+        return 0;
+    }
+    mpCollider->SetCrrFunc(dBgS_MoveBGProc_Typical);
+    return 1;
+}
+
+int maObj_Wrock_c::createHeapCallBack(fopAc_ac_c* i_this) {
+    return static_cast<maObj_Wrock_c*>(i_this)->CreateHeap();
+}
+
+int maObj_Wrock_c::Delete() {
+    // Call the destructor anytime we delete the actor
+    this->~maObj_Wrock_c();
+    return 1;
+}
+
+int maObj_Wrock_c::Execute() {
+    // Update collision with the world
+    mAcch.CrrPos(dComIfG_Bgsp());
+
+    // Get the collision below the actor
+    mGndChk = mAcch.m_gnd;
+    mGroundH = mAcch.GetGroundH();
+    if (mGroundH != -G_CM3D_F_INF) {
+        // Set the actor's environment colors to match the room's current ones
+        tevStr.YukaCol = dComIfG_Bgsp().GetPolyColor(mGndChk);
+        tevStr.room_no = dComIfG_Bgsp().GetRoomId(mGndChk);
+
+        // Set the actor's room to be where it is sitting
+        fopAcM_SetRoomNo(this, dComIfG_Bgsp().GetRoomId(mGndChk));
+    }
+
+    // Update the model's transformation matrix to match the actor's transform
+    mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
+    mDoMtx_stack_c::ZXYrotM(shape_angle);
+    mDoMtx_stack_c::scaleM(scale);
+    mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
+
+    // Copy the model's transformation matrix to the collider's transformation matrix and update the
+    // collider
+    if (mpCollider != NULL) {
+        PSMTXCopy(mpModel->getBaseTRMtx(), mColliderMtx);
+        mpCollider->Move();
+    }
+
+    // Set any attention flags (if needed)
+    eyePos = attention_info.position = current.pos;
+    attention_info.flags = 0;
+    return 1;
+}
+
+int maObj_Wrock_c::Draw() {
+    // Update the model's lighting with the scene
+    g_env_light.settingTevStruct(0x20, &current.pos, &tevStr);
+    g_env_light.setLightTevColorType_MAJI(mpModel, &tevStr);
+
+    // Set the current dlist to BG Which means that shadows can be cast on it
+    // Because of the messy collider, the shadows don't look great, but this is here as an example
+    dComIfGd_setListBG();
+
+    // Set the bmd model to be drawn when the display list is executed
+    mDoExt_modelUpdateDL(mpModel);
+
+    // Cast a shadow for the actor onto the ground.
+    // We can only do this if we are drawing to the normal dlist, not the BG dlist
+    // if (mGroundH != -G_CM3D_F_INF) {
+    //     mShadow = dComIfGd_setShadow(mShadow, 1, mpModel, &current.pos,
+    //                                  2000.0f, 0.0f,
+    //                                  current.pos.y, mGroundH, mGndChk, &tevStr, 0,
+    //                                  1.0f, &dDlst_shadowControl_c::mSimpleTexObj);
+    // }
+
+    // Reset the active dlist
+    dComIfGd_setList();
+
+    return 1;
+}
+
+static cPhs_Step maObj_Wrock_Create(void* i_this) {
+    return static_cast<maObj_Wrock_c*>(i_this)->create();
+}
+
+static int maObj_Wrock_Delete(void* i_this) {
+    return static_cast<maObj_Wrock_c*>(i_this)->Delete();
+}
+
+static int maObj_Wrock_Execute(void* i_this) {
+    return static_cast<maObj_Wrock_c*>(i_this)->Execute();
+}
+
+static int maObj_Wrock_Draw(void* i_this) {
+    return static_cast<maObj_Wrock_c*>(i_this)->Draw();
+}
+
+static int maObj_Wrock_IsDelete(void*) {
+    return 1;
+}
+
+s16 maObj_Wrock_c::sProcName = -1;
+ActorHandle maObj_Wrock_c::sActorHandle = -1;
+const ActorProfileDesc maObj_Wrock_c::sProfile = {.name = MAOBJ_WROCK_NAME,
+    .priority_group = 7,
+    .process_size = sizeof(maObj_Wrock_c),
+    .draw_priority = fpcDwPi_OBJ_LBOX_e,  // An unused draw priority
+    .status = fopAcStts_UNK_0x40000_e | fopAcStts_UNK_0x4000_e | fopAcStts_CULL_e,
+    .group = fopAc_ACTOR_e,
+    .cull_type = fopAc_CULLBOX_CUSTOM_e,
+    .create_function = maObj_Wrock_Create,
+    .delete_function = maObj_Wrock_Delete,
+    .execute_function = maObj_Wrock_Execute,
+    .is_delete_function = maObj_Wrock_IsDelete,
+    .draw_function = maObj_Wrock_Draw};
diff --git a/mods/custom_actor_demo/src/m_a_obj_wrock.hpp b/mods/custom_actor_demo/src/m_a_obj_wrock.hpp
new file mode 100644
index 0000000000..1e18d36f5f
--- /dev/null
+++ b/mods/custom_actor_demo/src/m_a_obj_wrock.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include "mods/svc/actor.h"
+
+// Base actor class definitions
+#include "f_op/f_op_actor.h"
+
+// Definitions for request_of_phase_process_class and cPhs_Step
+#include "SSystem/SComponent/c_phase.h"
+
+// Definitions for collision
+#include "d/d_bg_s_acch.h"
+#include "d/d_bg_w.h"
+
+#define MAOBJ_WROCK_NAME "wrock"
+
+class maObj_Wrock_c : public fopAc_ac_c {
+public:
+    request_of_phase_process_class mPhase;
+    J3DModel* mpModel;
+    dBgS_ObjAcch mAcch;
+    cBgS_GndChk mGndChk;
+    dBgS_AcchCir mAcchCir;
+    Mtx mColliderMtx;
+    dBgW* mpCollider;
+    f32 mGroundH;
+    int mShadow;
+
+    virtual ~maObj_Wrock_c();
+    cPhs_Step create();
+    int CreateHeap();
+    int Delete();
+    int Execute();
+    int Draw();
+    static int createHeapCallBack(fopAc_ac_c*);
+
+    static s16 sProcName;
+    static ActorHandle sActorHandle;
+    static const ActorProfileDesc sProfile;
+};
diff --git a/mods/custom_actor_demo/src/mod.cpp b/mods/custom_actor_demo/src/mod.cpp
new file mode 100644
index 0000000000..971ad6e4f0
--- /dev/null
+++ b/mods/custom_actor_demo/src/mod.cpp
@@ -0,0 +1,85 @@
+#include "mods/service.hpp"
+#include "mods/svc/actor.h"
+#include "mods/svc/log.hpp"
+#include "mods/svc/stage.h"
+
+#include "d/d_com_inf_game.h"
+
+#include "m_a_mine.hpp"
+#include "m_a_obj_wrock.hpp"
+
+#include <array>
+
+DEFINE_MOD();
+IMPORT_SERVICE(LogService, svc_log);
+IMPORT_SERVICE(ActorService, svc_actor);
+IMPORT_SERVICE(StageService, svc_stage);
+
+extern "C" {
+MOD_EXPORT ModResult mod_initialize(ModError*) {
+    if (svc_actor->register_actor(mod_ctx, &maObj_Wrock_c::sProfile, &maObj_Wrock_c::sProcName,
+            &maObj_Wrock_c::sActorHandle) != MOD_OK)
+    {
+        mods::log::error("Failed to register actor wrock!");
+        return MOD_ERROR;
+    }
+
+    const stage_actor_data_class wrockParams{
+        .name = MAOBJ_WROCK_NAME,
+        .base =
+            {
+                .parameters = 0,
+                .position = {-14324.0f, 0.0f, 341.0f},
+                .angle = {0, -16595, 0},
+                .setID = 0xFFFF,
+            },
+    };
+    if (svc_stage->add_actor(
+            mod_ctx, "F_SP108", 0, -1, &wrockParams, sizeof(wrockParams), nullptr) != MOD_OK)
+    {
+        mods::log::error("Adding wrock to F_SP108 Failed!");
+        return MOD_ERROR;
+    }
+
+    if (svc_actor->register_actor(mod_ctx, &ma_Mine_c::sProfile, &ma_Mine_c::sProcName,
+            &ma_Mine_c::sActorHandle) != MOD_OK)
+    {
+        mods::log::error("Failed to register actor " MA_MINE_NAME);
+        return MOD_ERROR;
+    }
+
+    static const std::array<cXyz, 6> minePositions = {
+        {{-14445.0f, 11.0f, 1304.0f}, {-14557.0f, 7.0f, 990.0f}, {-14790.0f, 7.0f, 634.0f},
+            {-14829.0f, 0.0f, 144.0f}, {-14615.0f, 0.0f, -170.0f}, {-14283.0f, 10.0f, -420.0f}}};
+    for (const auto& pos : minePositions) {
+        const stage_actor_data_class mineParams{
+            .name = MA_MINE_NAME,
+            .base =
+                {
+                    .parameters = 0,
+                    .position = {pos.x, pos.y, pos.z},
+                    .angle = {0x2000, (s16)(pos.x*100000), 0}, // Adjusted and seemingly random angle
+                    .setID = 0xFFFF,
+                },
+        };
+        if (svc_stage->add_actor(
+                mod_ctx, "F_SP108", 0, -1, &mineParams, sizeof(mineParams), nullptr) != MOD_OK)
+        {
+            mods::log::error("Adding mine to F_SP108 Failed!");
+            return MOD_ERROR;
+        }
+    }
+
+    mods::log::info("custom_actor_demo initialized");
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_shutdown(ModError*) {
+    mods::log::info("custom_actor_demo shutdown");
+    return MOD_OK;
+}
+}
diff --git a/mods/flow_demo/CMakeLists.txt b/mods/flow_demo/CMakeLists.txt
new file mode 100644
index 0000000000..8487073dae
--- /dev/null
+++ b/mods/flow_demo/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.25)
+project(flow_demo CXX)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(DUSK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../.." CACHE PATH "Path to dusk source root")
+    option(DUSK_MOD_USE_FULL_TREE "Use full build instead of the minimal mod SDK" OFF)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    if (DUSK_MOD_USE_FULL_TREE)
+        add_subdirectory("${DUSK_DIR}" dusk EXCLUDE_FROM_ALL)
+    else ()
+        add_subdirectory("${DUSK_DIR}/sdk" dusk-sdk EXCLUDE_FROM_ALL)
+    endif ()
+endif ()
+
+add_mod(flow_demo
+    FEATURES fmt
+    SOURCES  src/mod.cpp
+    MOD_JSON mod.json
+)
diff --git a/mods/flow_demo/mod.json b/mods/flow_demo/mod.json
new file mode 100644
index 0000000000..90d395bdcc
--- /dev/null
+++ b/mods/flow_demo/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "dev.twilitrealm.flow_demo",
+  "name": "[Demo] Flow & Messages",
+  "version": "1.0.0",
+  "author": "Twilit Realm",
+  "description": "Adds a FlowService demonstration submenu to Midna's menu."
+}
diff --git a/mods/flow_demo/src/mod.cpp b/mods/flow_demo/src/mod.cpp
new file mode 100644
index 0000000000..a05150458b
--- /dev/null
+++ b/mods/flow_demo/src/mod.cpp
@@ -0,0 +1,302 @@
+#include "mods/service.hpp"
+#include "mods/svc/flow.hpp"
+#include "mods/svc/log.hpp"
+
+#include <array>
+#include <cstdint>
+#include <span>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+DEFINE_MOD();
+IMPORT_SERVICE(LogService, svc_log);
+IMPORT_SERVICE(FlowService, svc_flow);
+IMPORT_SERVICE(MessageService, svc_message);
+
+namespace {
+
+// The Midna flow lives in BMG group 0.
+constexpr uint16_t kMessageGroup = 0;
+// Midna's "speaker" value for messages.
+constexpr uint16_t kMidnaSpeaker = 21;
+
+// Vanilla flow node/branch/edge IDs that we reference or override.
+constexpr uint16_t kMidnaPromptHumanNode = 0x018c;
+constexpr uint16_t kMidnaPromptWolfNode = 0x018d;
+constexpr uint16_t kMidnaHumanBranch = 0x0190;
+constexpr uint16_t kMidnaWolfBranch = 0x0193;
+constexpr uint16_t kMidnaTalkNode = 0x018f;
+constexpr uint16_t kMidnaHumanTalkEdge = 0x0113;
+constexpr uint16_t kMidnaWolfTalkEdge = 0x0119;
+
+// For vanilla messages, we need both the entry index and the message ID.
+// For registered custom messages, they're the same.
+constexpr uint16_t kMidnaMenuPromptEntry = 3003;  // message index used in flow message data
+constexpr uint16_t kMidnaMenuPromptId = 2042;     // message ID used to override
+
+constexpr std::array kAllLanguages{
+    MESSAGE_LANGUAGE_ENGLISH,
+    MESSAGE_LANGUAGE_GERMAN,
+    MESSAGE_LANGUAGE_FRENCH,
+    MESSAGE_LANGUAGE_SPANISH,
+    MESSAGE_LANGUAGE_ITALIAN,
+    MESSAGE_LANGUAGE_JAPANESE,
+};
+
+constexpr mods::flow::MessageStyle kResponseStyle =
+    mods::flow::MessageStyle{}.speaker(kMidnaSpeaker).box_kind(MESSAGE_BOX_MIDNA);
+constexpr mods::flow::MessageStyle kPromptStyle =
+    kResponseStyle.draw_type(MESSAGE_DRAW_INSTANT).talk_anim(31).face_anim(31);
+
+mods::flow::Query g_demoQuery;
+mods::flow::Event g_demoEvent;
+mods::flow::Graph g_graph;
+std::vector<mods::flow::RegisteredMessage> g_messages;
+std::vector<mods::flow::MessageOverride> g_overrides;
+std::vector<uint8_t> g_visitedPromptText;
+uint32_t g_queryExecutions = 0;
+uint32_t g_eventExecutions = 0;
+
+mods::flow::MessageBuilder build_prompt(std::string_view suffix) {
+    return mods::flow::MessageBuilder{kPromptStyle}
+        .text("What is it, ")
+        .text_color(MESSAGE_COLOR_RED)
+        .player_name()
+        .text_color(MESSAGE_COLOR_DEFAULT)
+        .text("?\n")
+        .text_scale(85)
+        .text(suffix)
+        .text_scale(100)
+        .await_choice();
+}
+
+// Registers a single message for all languages.
+mods::flow::RegisteredMessage register_message(const mods::flow::MessageBuilder& builder) {
+    std::vector<mods::flow::MessageVariant> variants;
+    variants.reserve(kAllLanguages.size());
+    for (const MessageLanguage language : kAllLanguages) {
+        variants.push_back(builder.build(language));
+    }
+    return mods::flow::register_message(kMessageGroup, variants);
+}
+
+ModResult add_message(const mods::flow::MessageBuilder& builder, MessageId& outId) {
+    auto message = register_message(builder);
+    if (!message) {
+        return message.result();
+    }
+    outId = message.id();
+    g_messages.push_back(std::move(message));
+    return MOD_OK;
+}
+
+ModResult add_fixed_override(
+    uint16_t messageId, const std::vector<uint8_t>& text, bool addCallback) {
+    for (const MessageLanguage language : kAllLanguages) {
+        auto fixed =
+            mods::flow::override_message(kMessageGroup, messageId, language, std::span{text});
+        if (!fixed) {
+            return fixed.result();
+        }
+        g_overrides.push_back(std::move(fixed));
+        if (!addCallback) {
+            continue;
+        }
+        auto callback = mods::flow::override_message_fn(kMessageGroup, messageId, language,
+            [](ModContext*, const MessageOverrideContext*, MessageTextData* outText,
+                void*) -> bool {
+                if (g_eventExecutions == 0 || outText == nullptr) {
+                    return false;
+                }
+                outText->text = g_visitedPromptText.data();
+                outText->text_size = g_visitedPromptText.size();
+                return true;
+            });
+        if (!callback) {
+            return callback.result();
+        }
+        g_overrides.push_back(std::move(callback));
+    }
+    return MOD_OK;
+}
+
+uint16_t demo_query(ModContext*, const FlowQueryContext* query, void*) {
+    if (query == nullptr || query->parameter != 1234 || query->result_count < 3) {
+        return 0;
+    }
+    const auto result = static_cast<uint16_t>(g_queryExecutions % 3);
+    if (query->phase == FLOW_QUERY_PHASE_EXECUTE) {
+        ++g_queryExecutions;
+        mods::log::info("Flow demo query selected result {}", result);
+    }
+    return result;
+}
+
+void demo_event(ModContext*, const FlowEventContext* event, void*) {
+    ++g_eventExecutions;
+    const uint8_t path = event != nullptr ? event->parameters[3] : 0;
+    mods::log::info("Flow demo event {} executed (activation {})", path, g_eventExecutions);
+}
+
+}  // namespace
+
+extern "C" {
+MOD_EXPORT ModResult mod_initialize(ModError* outError) {
+    g_queryExecutions = 0;
+    g_eventExecutions = 0;
+
+    MessageId humanSelectionId = 0;
+    MessageId wolfSelectionId = 0;
+    MessageId labPromptId = 0;
+    MessageId labSelectionId = 0;
+    MessageId formattedId = 0;
+    MessageId evenId = 0;
+    MessageId oddId = 0;
+    MessageId timeoutId = 0;
+
+    auto result = add_message(mods::flow::MessageBuilder{}
+                                  .speaker(kMidnaSpeaker)
+                                  .options("Transform into human", "Warp", "Flow demo"),
+        humanSelectionId);
+    if (result == MOD_OK) {
+        result = add_message(mods::flow::MessageBuilder{}
+                                 .speaker(kMidnaSpeaker)
+                                 .options("Transform into wolf", "Warp", "Flow demo"),
+            wolfSelectionId);
+    }
+    if (result == MOD_OK) {
+        result = add_message(build_prompt("Choose a FlowService test."), labPromptId);
+    }
+    if (result == MOD_OK) {
+        result = add_message(mods::flow::MessageBuilder{}
+                                 .speaker(kMidnaSpeaker)
+                                 .options("Formatted message", "Callback branch", "Talk to Midna"),
+            labSelectionId);
+    }
+    if (result == MOD_OK) {
+        result = add_message(mods::flow::MessageBuilder{kResponseStyle}
+                                 .text_color(MESSAGE_COLOR_DEFAULT)
+                                 .text("Custom ")
+                                 .text_color(0xFF0000FF)
+                                 .text("colors")
+                                 .text_color(MESSAGE_COLOR_DEFAULT)
+                                 .text(" and even ")
+                                 .text_color(0x00FF00FF, 0x00FFFFFF)
+                                 .text("gradients")
+                                 .text_color(MESSAGE_COLOR_DEFAULT)
+                                 .text("!\n")
+                                 .character_delay(3)
+                                 .text("This text is slow. ")
+                                 .character_delay(0)
+                                 .pause(12)
+                                 .text_scale(150)
+                                 .text("Big")
+                                 .text_scale(100)
+                                 .text(" text too.")
+                                 .input_after_delay(15),
+            formattedId);
+    }
+    if (result == MOD_OK) {
+        result = add_message(mods::flow::MessageBuilder{kResponseStyle}
+                                 .text("Query returned ")
+                                 .text_color(MESSAGE_COLOR_GREEN)
+                                 .text("zero")
+                                 .text_color(MESSAGE_COLOR_DEFAULT)
+                                 .text(".")
+                                 .auto_advance(75),
+            evenId);
+    }
+    if (result == MOD_OK) {
+        result = add_message(mods::flow::MessageBuilder{kResponseStyle}
+                                 .box_kind(MESSAGE_BOX_LIGHT_SPIRIT)
+                                 .text("Query returned ")
+                                 .text_color(MESSAGE_COLOR_RED)
+                                 .text("one")
+                                 .text_color(MESSAGE_COLOR_DEFAULT)
+                                 .text(".")
+                                 .auto_advance(75),
+            oddId);
+    }
+    if (result == MOD_OK) {
+        result = add_message(mods::flow::MessageBuilder{kResponseStyle}
+                                 .text("Query returned ")
+                                 .text_color(MESSAGE_COLOR_YELLOW)
+                                 .text("three")
+                                 .text_color(MESSAGE_COLOR_DEFAULT)
+                                 .text(".\nThis will timeout after three seconds.")
+                                 .input_or_timeout(90),
+            timeoutId);
+    }
+    if (result != MOD_OK) {
+        return mods::set_error(outError, result, "failed to register custom demo messages");
+    }
+
+    g_visitedPromptText =
+        build_prompt("A custom event has run.").build(MESSAGE_LANGUAGE_ENGLISH).text();
+    result = add_fixed_override(kMidnaMenuPromptId,
+        build_prompt("Flow demo is installed.").build(MESSAGE_LANGUAGE_ENGLISH).text(), true);
+    if (result != MOD_OK) {
+        return mods::set_error(outError, result, "failed to register demo message overrides");
+    }
+
+    g_demoQuery = mods::flow::register_query("flow_demo cycling branch", demo_query);
+    g_demoEvent = mods::flow::register_event("flow_demo activation", demo_event);
+    if (!g_demoQuery || !g_demoEvent) {
+        const auto callbackResult = !g_demoQuery ? g_demoQuery.result() : g_demoEvent.result();
+        return mods::set_error(outError, callbackResult, "failed to register flow callbacks");
+    }
+
+    // Set up our demo graph
+    mods::flow::GraphBuilder graph{kMessageGroup};
+    const auto demoSetup = graph.add_event(FLOW_EVENT_SELECT_VERTICAL, {0, 0, 0, 4});
+    const auto formattedMessage = graph.add_message(formattedId).next(demoSetup);
+    const auto formattedEvent =
+        graph.add_event(g_demoEvent.id(), {0, 0, 0, 1}).next(formattedMessage);
+    const auto evenMessage = graph.add_message(evenId).next(demoSetup);
+    const auto evenEvent = graph.add_event(g_demoEvent.id(), {0, 0, 0, 2}).next(evenMessage);
+    const auto oddMessage = graph.add_message(oddId).next(demoSetup);
+    const auto oddEvent = graph.add_event(g_demoEvent.id(), {0, 0, 0, 3}).next(oddMessage);
+    const auto timeoutMessage = graph.add_message(timeoutId).next(demoSetup);
+    const auto timeoutEvent = graph.add_event(g_demoEvent.id(), {0, 0, 0, 4}).next(timeoutMessage);
+    const auto callbackBranch =
+        graph.add_branch(g_demoQuery.id(), 1234).results({evenEvent, oddEvent, timeoutEvent});
+    const auto choiceBranch =
+        graph.add_branch(FLOW_QUERY_SELECT_3_CANCEL, 0)
+            .results({formattedEvent, callbackBranch, kMidnaTalkNode, mods::flow::kEnd});
+    const auto demoSelection = graph.add_message(labSelectionId).next(choiceBranch);
+    const auto demoPrompt = graph.add_message(labPromptId).next(demoSelection);
+    demoSetup.next(demoPrompt);
+
+    // Patch original nodes and edges so they flow into our custom graph
+    const auto humanSelection = graph.add_message(humanSelectionId).next(kMidnaHumanBranch);
+    const auto wolfSelection = graph.add_message(wolfSelectionId).next(kMidnaWolfBranch);
+    graph.patch_node(
+        kMidnaPromptHumanNode, mods::flow::message(0, kMidnaMenuPromptEntry, humanSelection));
+    graph.patch_node(
+        kMidnaPromptWolfNode, mods::flow::message(0, kMidnaMenuPromptEntry, wolfSelection));
+    graph.patch_edge(kMidnaHumanTalkEdge, demoSetup);
+    graph.patch_edge(kMidnaWolfTalkEdge, demoSetup);
+
+    g_graph = graph.commit();
+    if (!g_graph) {
+        return mods::set_error(outError, g_graph.result(), "failed to commit the flow demo graph");
+    }
+
+    mods::log::info("Flow demo ready: {} custom messages", g_messages.size());
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_shutdown(ModError*) {
+    mods::log::info("Flow demo unloaded after {} events", g_eventExecutions);
+    g_graph.reset();
+    g_overrides.clear();
+    g_messages.clear();
+    g_visitedPromptText.clear();
+    return MOD_OK;
+}
+}
diff --git a/mods/luau_runtime/CMakeLists.txt b/mods/luau_runtime/CMakeLists.txt
new file mode 100644
index 0000000000..fa38b64b8a
--- /dev/null
+++ b/mods/luau_runtime/CMakeLists.txt
@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.25)
+project(luau_runtime CXX)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(DUSK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../.." CACHE PATH "Path to dusk source root")
+    option(DUSK_MOD_USE_FULL_TREE "Use full build instead of the minimal mod SDK" OFF)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    if (DUSK_MOD_USE_FULL_TREE)
+        add_subdirectory("${DUSK_DIR}" dusk EXCLUDE_FROM_ALL)
+    else ()
+        add_subdirectory("${DUSK_DIR}/sdk" dusk-sdk EXCLUDE_FROM_ALL)
+    endif ()
+endif ()
+
+include(FetchContent)
+
+set(LUAU_BUILD_CLI OFF CACHE BOOL "" FORCE)
+set(LUAU_BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(LUAU_BUILD_WEB OFF CACHE BOOL "" FORCE)
+set(LUAU_WERROR OFF CACHE BOOL "" FORCE)
+FetchContent_Declare(luau
+    URL https://github.com/luau-lang/luau/archive/refs/tags/0.734.tar.gz
+    URL_HASH SHA256=cb55a891226d8c70284e22eb9281cc2b4496c709a4050f52aaa18a355fe7b1a3
+    DOWNLOAD_EXTRACT_TIMESTAMP FALSE
+    EXCLUDE_FROM_ALL
+)
+FetchContent_MakeAvailable(luau)
+
+add_mod(luau_runtime
+    SOURCES
+        src/bindings.cpp
+        src/config.cpp
+        src/runtime.cpp
+        src/ui.cpp
+    MOD_JSON mod.json
+    RES_DIR res
+    BUNDLE
+)
+
+target_link_libraries(luau_runtime PRIVATE Luau.VM Luau.Compiler)
diff --git a/mods/luau_runtime/mod.json b/mods/luau_runtime/mod.json
new file mode 100644
index 0000000000..788a57f554
--- /dev/null
+++ b/mods/luau_runtime/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "dev.twilitrealm.luau",
+  "name": "Luau Support",
+  "version": "1.0.0",
+  "author": "Twilit Realm",
+  "description": "Luau script runtime for mods"
+}
diff --git a/mods/luau_runtime/res/licenses/LUAU-MIT.txt b/mods/luau_runtime/res/licenses/LUAU-MIT.txt
new file mode 100644
index 0000000000..2f2aa17066
--- /dev/null
+++ b/mods/luau_runtime/res/licenses/LUAU-MIT.txt
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2019-2025 Roblox Corporation
+Copyright (c) 1994-2019 Lua.org, PUC-Rio.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/mods/luau_runtime/src/bindings.cpp b/mods/luau_runtime/src/bindings.cpp
new file mode 100644
index 0000000000..27f4218a83
--- /dev/null
+++ b/mods/luau_runtime/src/bindings.cpp
@@ -0,0 +1,340 @@
+#include "runtime.hpp"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace luau_runtime {
+namespace {
+
+constexpr char kOverlayMetatable[] = "dusklight.overlay_handle";
+constexpr char kTextureMetatable[] = "dusklight.texture_handle";
+
+uint64_t get_hash_field(lua_State* state, int table, const char* field, bool required) {
+    lua_getfield(state, table, field);
+    if (lua_isnil(state, -1)) {
+        lua_pop(state, 1);
+        if (required) {
+            luaL_error(state, "field '%s' is required", field);
+        }
+        return 0;
+    }
+    if (!lua_isinteger64(state, -1)) {
+        luaL_error(state, "field '%s' must be an integer", field);
+    }
+    const uint64_t value = static_cast<uint64_t>(lua_tointeger64(state, -1, nullptr));
+    lua_pop(state, 1);
+    return value;
+}
+
+int log_write(lua_State* state, LogLevel level, int messageIndex) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_log == nullptr) {
+        service_unavailable(state, "LogService");
+    }
+    size_t length = 0;
+    const char* message = luaL_checklstring(state, messageIndex, &length);
+    const std::string copy{message, length};
+    svc_log->write(vm.subject, level, copy.c_str());
+    return 0;
+}
+
+int log_trace(lua_State* state) {
+    return log_write(state, LOG_LEVEL_TRACE, 1);
+}
+
+int log_debug(lua_State* state) {
+    return log_write(state, LOG_LEVEL_DEBUG, 1);
+}
+
+int log_info(lua_State* state) {
+    return log_write(state, LOG_LEVEL_INFO, 1);
+}
+
+int log_warn(lua_State* state) {
+    return log_write(state, LOG_LEVEL_WARN, 1);
+}
+
+int log_error(lua_State* state) {
+    return log_write(state, LOG_LEVEL_ERROR, 1);
+}
+
+int log_write_level(lua_State* state) {
+    static constexpr const char* kLevels[] = {"trace", "debug", "info", "warn", "error", nullptr};
+    const int level = luaL_checkoption(state, 1, nullptr, kLevels);
+    return log_write(state, static_cast<LogLevel>(level), 2);
+}
+
+int host_mod_id(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr) {
+        service_unavailable(state, "HostService");
+    }
+    lua_pushstring(state, svc_host->mod_id(vm.subject));
+    return 1;
+}
+
+int host_mod_name(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr) {
+        service_unavailable(state, "HostService");
+    }
+    lua_pushstring(state, svc_host->mod_name(vm.subject));
+    return 1;
+}
+
+int host_mod_version(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr) {
+        service_unavailable(state, "HostService");
+    }
+    lua_pushstring(state, svc_host->mod_version(vm.subject));
+    return 1;
+}
+
+int host_mod_dir(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr) {
+        service_unavailable(state, "HostService");
+    }
+    lua_pushstring(state, svc_host->mod_dir(vm.subject));
+    return 1;
+}
+
+int host_data_dir(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr || !SERVICE_HAS(svc_host, HostService, data_dir) ||
+        svc_host->data_dir == nullptr)
+    {
+        service_unavailable(state, "HostService::data_dir");
+    }
+    const char* path = nullptr;
+    check_result(state, svc_host->data_dir(vm.subject, &path), "host.data_dir");
+    lua_pushstring(state, path != nullptr ? path : "");
+    return 1;
+}
+
+int host_fail(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr) {
+        service_unavailable(state, "HostService");
+    }
+    const char* message = luaL_checkstring(state, 1);
+    svc_host->fail(vm.subject, MOD_ERROR, message);
+    luaL_error(state, "%s", message);
+}
+
+int register_host_callback(lua_State* state, std::vector<int>& callbacks) {
+    luaL_checktype(state, 1, LUA_TFUNCTION);
+    lua_pushvalue(state, 1);
+    callbacks.push_back(lua_ref(state, -1));
+    lua_pop(state, 1);
+    return 0;
+}
+
+int host_on_update(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    return register_host_callback(state, vm.updateRefs);
+}
+
+int host_on_shutdown(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    return register_host_callback(state, vm.shutdownRefs);
+}
+
+int resource_load(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_resource == nullptr) {
+        service_unavailable(state, "ResourceService");
+    }
+    const char* path = luaL_checkstring(state, 1);
+    ResourceBuffer buffer = RESOURCE_BUFFER_INIT;
+    check_result(state, svc_resource->load(vm.subject, path, &buffer), "resource.load");
+    const auto* data = buffer.data != nullptr ? static_cast<const char*>(buffer.data) : "";
+    const std::string copy{data, buffer.size};
+    svc_resource->free(vm.subject, &buffer);
+    lua_pushlstring(state, copy.data(), copy.size());
+    return 1;
+}
+
+int overlay_remove(lua_State* state) {
+    auto& handle = check_handle(state, 1, kOverlayMetatable, HandleKind::Overlay);
+    if (svc_overlay == nullptr) {
+        service_unavailable(state, "OverlayService");
+    }
+    check_result(state, svc_overlay->remove(handle.vm->subject, handle.value), "overlay.remove");
+    handle.value = 0;
+    return 0;
+}
+
+int overlay_add_file(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_overlay == nullptr) {
+        service_unavailable(state, "OverlayService");
+    }
+    const char* discPath = luaL_checkstring(state, 1);
+    const char* bundlePath = luaL_checkstring(state, 2);
+    OverlayHandle handle = 0;
+    check_result(state, svc_overlay->add_file(vm.subject, discPath, bundlePath, &handle),
+        "overlay.add_file");
+    push_handle(state, vm, handle, HandleKind::Overlay, kOverlayMetatable);
+    return 1;
+}
+
+int overlay_add_buffer(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_overlay == nullptr) {
+        service_unavailable(state, "OverlayService");
+    }
+    const char* discPath = luaL_checkstring(state, 1);
+    size_t size = 0;
+    const char* data = luaL_checklstring(state, 2, &size);
+    OverlayHandle handle = 0;
+    check_result(state, svc_overlay->add_buffer(vm.subject, discPath, data, size, &handle),
+        "overlay.add_buffer");
+    push_handle(state, vm, handle, HandleKind::Overlay, kOverlayMetatable);
+    return 1;
+}
+
+int texture_unregister(lua_State* state) {
+    auto& handle = check_handle(state, 1, kTextureMetatable, HandleKind::Texture);
+    if (svc_texture == nullptr) {
+        service_unavailable(state, "TextureService");
+    }
+    check_result(
+        state, svc_texture->unregister(handle.vm->subject, handle.value), "texture.unregister");
+    handle.value = 0;
+    return 0;
+}
+
+int texture_register_file(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_texture == nullptr) {
+        service_unavailable(state, "TextureService");
+    }
+    const char* path = luaL_checkstring(state, 1);
+    TextureReplacementHandle handle = 0;
+    check_result(
+        state, svc_texture->register_file(vm.subject, path, &handle), "texture.register_file");
+    push_handle(state, vm, handle, HandleKind::Texture, kTextureMetatable);
+    return 1;
+}
+
+int texture_register_data(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_texture == nullptr) {
+        service_unavailable(state, "TextureService");
+    }
+    luaL_checktype(state, 1, LUA_TTABLE);
+    luaL_checktype(state, 2, LUA_TTABLE);
+
+    TextureKey key = TEXTURE_KEY_INIT;
+    key.kind = TEXTURE_KEY_SOURCE;
+    key.texture_hash = get_hash_field(state, 1, "texture_hash", true);
+    key.tlut_hash = get_hash_field(state, 1, "tlut_hash", false);
+    key.width = static_cast<uint32_t>(get_optional_int(state, 1, "width", 0));
+    key.height = static_cast<uint32_t>(get_optional_int(state, 1, "height", 0));
+    key.gx_format = static_cast<uint32_t>(get_optional_int(state, 1, "gx_format", 0));
+    key.has_tlut = get_optional_bool(state, 1, "has_tlut", false);
+
+    lua_getfield(state, 2, "data");
+    size_t size = 0;
+    const char* bytes = luaL_checklstring(state, -1, &size);
+    TextureData data = TEXTURE_DATA_INIT;
+    data.data = bytes;
+    data.size = size;
+    data.width = static_cast<uint32_t>(get_optional_int(state, 2, "width", key.width));
+    data.height = static_cast<uint32_t>(get_optional_int(state, 2, "height", key.height));
+    data.mip_count = static_cast<uint32_t>(get_optional_int(state, 2, "mip_count", 1));
+    data.gx_format = static_cast<uint32_t>(get_optional_int(state, 2, "gx_format", key.gx_format));
+
+    TextureReplacementHandle handle = 0;
+    const ModResult result = svc_texture->register_data(vm.subject, &key, &data, &handle);
+    lua_pop(state, 1);
+    check_result(state, result, "texture.register_data");
+    push_handle(state, vm, handle, HandleKind::Texture, kTextureMetatable);
+    return 1;
+}
+
+}  // namespace
+
+int open_log(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_log == nullptr) {
+        service_unavailable(state, "LogService");
+    }
+    lua_newtable(state);
+    set_function(state, vm, "write", log_write_level);
+    set_function(state, vm, "trace", log_trace);
+    set_function(state, vm, "debug", log_debug);
+    set_function(state, vm, "info", log_info);
+    set_function(state, vm, "warn", log_warn);
+    set_function(state, vm, "error", log_error);
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+int open_host(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_host == nullptr) {
+        service_unavailable(state, "HostService");
+    }
+    lua_newtable(state);
+    lua_pushstring(state, svc_host->version != nullptr ? svc_host->version : "");
+    lua_setfield(state, -2, "version");
+    set_function(state, vm, "mod_id", host_mod_id);
+    set_function(state, vm, "mod_name", host_mod_name);
+    set_function(state, vm, "mod_version", host_mod_version);
+    set_function(state, vm, "mod_dir", host_mod_dir);
+    set_function(state, vm, "data_dir", host_data_dir);
+    set_function(state, vm, "on_update", host_on_update);
+    set_function(state, vm, "on_shutdown", host_on_shutdown);
+    set_function(state, vm, "fail", host_fail);
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+int open_resource(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_resource == nullptr) {
+        service_unavailable(state, "ResourceService");
+    }
+    lua_newtable(state);
+    set_function(state, vm, "load", resource_load);
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+int open_overlay(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_overlay == nullptr) {
+        service_unavailable(state, "OverlayService");
+    }
+    static const luaL_Reg kMethods[] = {{"remove", overlay_remove}, {nullptr, nullptr}};
+    create_handle_metatable(state, kOverlayMetatable, kMethods, "OverlayHandle");
+    lua_newtable(state);
+    set_function(state, vm, "add_file", overlay_add_file);
+    set_function(state, vm, "add_buffer", overlay_add_buffer);
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+int open_texture(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_texture == nullptr) {
+        service_unavailable(state, "TextureService");
+    }
+    static const luaL_Reg kMethods[] = {{"unregister", texture_unregister}, {nullptr, nullptr}};
+    create_handle_metatable(state, kTextureMetatable, kMethods, "TextureHandle");
+    lua_newtable(state);
+    set_function(state, vm, "register_file", texture_register_file);
+    set_function(state, vm, "register_data", texture_register_data);
+    lua_pushinteger64(state, static_cast<int64_t>(TEXTURE_HASH_WILDCARD));
+    lua_setfield(state, -2, "hash_wildcard");
+    lua_pushinteger64(state, static_cast<int64_t>(TEXTURE_TLUT_WILDCARD));
+    lua_setfield(state, -2, "tlut_wildcard");
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+}  // namespace luau_runtime
diff --git a/mods/luau_runtime/src/config.cpp b/mods/luau_runtime/src/config.cpp
new file mode 100644
index 0000000000..b198bdb6e7
--- /dev/null
+++ b/mods/luau_runtime/src/config.cpp
@@ -0,0 +1,243 @@
+#include "runtime.hpp"
+
+#include <string>
+#include <vector>
+
+namespace luau_runtime {
+namespace {
+
+constexpr char kConfigVarMetatable[] = "dusklight.config_var";
+constexpr char kConfigSubscriptionMetatable[] = "dusklight.config_subscription";
+
+void config_changed(ModContext*, ConfigVarHandle, const ConfigVarValue* value,
+    const ConfigVarValue* previous, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    if (value == nullptr || previous == nullptr) {
+        return;
+    }
+    push_config_value(callback.vm->state, *value);
+    push_config_value(callback.vm->state, *previous);
+    std::string error;
+    if (!call_ref(*callback.vm, callback.refs[0], 2, 0, kCallbackBudget, error)) {
+        fail_callback(*callback.vm, "config change callback", error);
+    }
+}
+
+int config_get(lua_State* state) {
+    auto& handle = check_handle(state, 1, kConfigVarMetatable, HandleKind::ConfigVar);
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    switch (handle.configType) {
+    case CONFIG_VAR_BOOL: {
+        bool value = false;
+        check_result(
+            state, svc_config->get_bool(handle.vm->subject, handle.value, &value), "config get");
+        lua_pushboolean(state, value);
+        break;
+    }
+    case CONFIG_VAR_INT: {
+        int64_t value = 0;
+        check_result(
+            state, svc_config->get_int(handle.vm->subject, handle.value, &value), "config get");
+        lua_pushinteger64(state, value);
+        break;
+    }
+    case CONFIG_VAR_FLOAT: {
+        double value = 0;
+        check_result(
+            state, svc_config->get_float(handle.vm->subject, handle.value, &value), "config get");
+        lua_pushnumber(state, value);
+        break;
+    }
+    case CONFIG_VAR_STRING: {
+        size_t size = 0;
+        check_result(state,
+            svc_config->get_string(handle.vm->subject, handle.value, nullptr, 0, &size),
+            "config get");
+        std::vector<char> value(size + 1);
+        check_result(state,
+            svc_config->get_string(
+                handle.vm->subject, handle.value, value.data(), value.size(), nullptr),
+            "config get");
+        lua_pushlstring(state, value.data(), size);
+        break;
+    }
+    default:
+        luaL_error(state, "unknown config value type");
+    }
+    return 1;
+}
+
+int config_set(lua_State* state) {
+    auto& handle = check_handle(state, 1, kConfigVarMetatable, HandleKind::ConfigVar);
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    ModResult result = MOD_INVALID_ARGUMENT;
+    switch (handle.configType) {
+    case CONFIG_VAR_BOOL:
+        result = svc_config->set_bool(
+            handle.vm->subject, handle.value, luaL_checkboolean(state, 2) != 0);
+        break;
+    case CONFIG_VAR_INT:
+        result = svc_config->set_int(handle.vm->subject, handle.value, check_int64(state, 2));
+        break;
+    case CONFIG_VAR_FLOAT:
+        result =
+            svc_config->set_float(handle.vm->subject, handle.value, luaL_checknumber(state, 2));
+        break;
+    case CONFIG_VAR_STRING:
+        result =
+            svc_config->set_string(handle.vm->subject, handle.value, luaL_checkstring(state, 2));
+        break;
+    default:
+        break;
+    }
+    check_result(state, result, "config set");
+    return 0;
+}
+
+int config_unregister(lua_State* state) {
+    auto& handle = check_handle(state, 1, kConfigVarMetatable, HandleKind::ConfigVar);
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    check_result(
+        state, svc_config->unregister_var(handle.vm->subject, handle.value), "config unregister");
+    handle.value = 0;
+    return 0;
+}
+
+int config_unsubscribe(lua_State* state) {
+    auto& handle =
+        check_handle(state, 1, kConfigSubscriptionMetatable, HandleKind::ConfigSubscription);
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    check_result(
+        state, svc_config->unsubscribe(handle.vm->subject, handle.value), "config unsubscribe");
+    handle.value = 0;
+    return 0;
+}
+
+int subscribe(lua_State* state, ScriptHandle& variable, int functionIndex) {
+    luaL_checktype(state, functionIndex, LUA_TFUNCTION);
+    Callback& callback = retain_callback(*variable.vm);
+    callback.refs[0] = lua_ref(state, functionIndex);
+
+    ConfigSubscriptionHandle subscription = 0;
+    check_result(state,
+        svc_config->subscribe(
+            variable.vm->subject, variable.value, config_changed, &callback, &subscription),
+        "config.subscribe");
+    push_handle(state, *variable.vm, subscription, HandleKind::ConfigSubscription,
+        kConfigSubscriptionMetatable);
+    return 1;
+}
+
+int config_subscribe(lua_State* state) {
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    auto& variable = check_handle(state, 1, kConfigVarMetatable, HandleKind::ConfigVar);
+    return subscribe(state, variable, 2);
+}
+
+int config_var_subscribe(lua_State* state) {
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    auto& variable = check_handle(state, 1, kConfigVarMetatable, HandleKind::ConfigVar);
+    return subscribe(state, variable, 2);
+}
+
+int config_register(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    luaL_checktype(state, 1, LUA_TTABLE);
+
+    const std::string name = get_optional_string(state, 1, "name");
+    const std::string type = get_optional_string(state, 1, "type");
+    ConfigVarDesc desc = CONFIG_VAR_DESC_INIT;
+    desc.name = name.c_str();
+    if (type == "bool") {
+        desc.type = CONFIG_VAR_BOOL;
+        desc.default_bool = get_optional_bool(state, 1, "default", false);
+    } else if (type == "int") {
+        desc.type = CONFIG_VAR_INT;
+        desc.default_int = get_optional_int(state, 1, "default", 0);
+    } else if (type == "float") {
+        desc.type = CONFIG_VAR_FLOAT;
+        desc.default_float = get_optional_number(state, 1, "default", 0);
+    } else if (type == "string") {
+        desc.type = CONFIG_VAR_STRING;
+    } else {
+        luaL_error(state, "config type must be 'bool', 'int', 'float', or 'string'");
+    }
+
+    std::string defaultString;
+    if (desc.type == CONFIG_VAR_STRING) {
+        defaultString = get_optional_string(state, 1, "default");
+        desc.default_string = defaultString.c_str();
+    }
+
+    ConfigVarHandle handle = 0;
+    check_result(state, svc_config->register_var(vm.subject, &desc, &handle), "config.register");
+    push_handle(state, vm, handle, HandleKind::ConfigVar, kConfigVarMetatable, desc.type);
+    return 1;
+}
+
+}  // namespace
+
+void push_config_value(lua_State* state, const ConfigVarValue& value) {
+    switch (value.type) {
+    case CONFIG_VAR_BOOL:
+        lua_pushboolean(state, value.bool_value);
+        break;
+    case CONFIG_VAR_INT:
+        lua_pushinteger64(state, value.int_value);
+        break;
+    case CONFIG_VAR_FLOAT:
+        lua_pushnumber(state, value.float_value);
+        break;
+    case CONFIG_VAR_STRING:
+        lua_pushlstring(state, value.string_value != nullptr ? value.string_value : "",
+            value.string_value != nullptr ? value.string_length : 0);
+        break;
+    default:
+        lua_pushnil(state);
+        break;
+    }
+}
+
+int open_config(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_config == nullptr) {
+        service_unavailable(state, "ConfigService");
+    }
+    static const luaL_Reg kVarMethods[] = {
+        {"get", config_get},
+        {"set", config_set},
+        {"subscribe", config_var_subscribe},
+        {"unregister", config_unregister},
+        {nullptr, nullptr},
+    };
+    static const luaL_Reg kSubscriptionMethods[] = {
+        {"unsubscribe", config_unsubscribe},
+        {nullptr, nullptr},
+    };
+    create_handle_metatable(state, kConfigVarMetatable, kVarMethods, "ConfigVar");
+    create_handle_metatable(
+        state, kConfigSubscriptionMetatable, kSubscriptionMethods, "ConfigSubscription");
+
+    lua_newtable(state);
+    set_function(state, vm, "register", config_register);
+    set_function(state, vm, "subscribe", config_subscribe);
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+}  // namespace luau_runtime
diff --git a/mods/luau_runtime/src/runtime.cpp b/mods/luau_runtime/src/runtime.cpp
new file mode 100644
index 0000000000..87676395d4
--- /dev/null
+++ b/mods/luau_runtime/src/runtime.cpp
@@ -0,0 +1,645 @@
+#include "runtime.hpp"
+
+#include "Luau/Common.h"
+#include "luacode.h"
+#include "mods/runtime.h"
+#include "mods/service.hpp"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <new>
+#include <optional>
+#include <string_view>
+#include <utility>
+
+LUAU_FASTFLAG(LuauIntegerLibrary)
+LUAU_FASTFLAG(LuauIntegerType2)
+
+DEFINE_MOD();
+IMPORT_OPTIONAL_SERVICE(LogService, svc_log);
+IMPORT_OPTIONAL_SERVICE(HostService, svc_host);
+IMPORT_OPTIONAL_SERVICE(ConfigService, svc_config);
+IMPORT_OPTIONAL_SERVICE(ResourceService, svc_resource);
+IMPORT_OPTIONAL_SERVICE(OverlayService, svc_overlay);
+IMPORT_OPTIONAL_SERVICE(TextureService, svc_texture);
+IMPORT_OPTIONAL_SERVICE(UiService, svc_ui);
+
+namespace luau_runtime {
+namespace {
+
+std::unordered_map<ModContext*, std::unique_ptr<Vm>> s_vms;
+
+void* limited_realloc(void* userData, void* pointer, size_t oldSize, size_t newSize) {
+    auto& budget = *static_cast<MemoryBudget*>(userData);
+    if (newSize == 0) {
+        std::free(pointer);
+        budget.used -= std::min(budget.used, oldSize);
+        return nullptr;
+    }
+
+    const size_t growth = newSize > oldSize ? newSize - oldSize : 0;
+    if (growth > budget.limit - std::min(budget.used, budget.limit)) {
+        return nullptr;
+    }
+    void* result = std::realloc(pointer, newSize);
+    if (result != nullptr) {
+        budget.used -= std::min(budget.used, oldSize);
+        budget.used += newSize;
+    }
+    return result;
+}
+
+int traceback_handler(lua_State* state) {
+    const char* message = lua_tostring(state, 1);
+    luaL_traceback(state, state, message != nullptr ? message : "Luau error", 1);
+    return 1;
+}
+
+class DeadlineScope {
+public:
+    DeadlineScope(Vm& vm, std::chrono::steady_clock::duration budget)
+        : m_vm{vm}, m_previousDeadline{vm.deadline}, m_previousActive{vm.deadlineActive} {
+        const auto requested = std::chrono::steady_clock::now() + budget;
+        if (!vm.deadlineActive || requested < vm.deadline) {
+            vm.deadline = requested;
+        }
+        vm.deadlineActive = true;
+        ++vm.callDepth;
+    }
+
+    ~DeadlineScope() {
+        --m_vm.callDepth;
+        m_vm.deadline = m_previousDeadline;
+        m_vm.deadlineActive = m_previousActive;
+    }
+
+private:
+    Vm& m_vm;
+    std::chrono::steady_clock::time_point m_previousDeadline;
+    bool m_previousActive;
+};
+
+bool protected_call(lua_State* state, Vm& vm, int argumentCount, int resultCount,
+    std::chrono::steady_clock::duration budget, std::string& outError) {
+    const int functionIndex = lua_gettop(state) - argumentCount;
+    lua_pushcfunction(state, traceback_handler, "dusklight traceback");
+    lua_insert(state, functionIndex);
+
+    DeadlineScope deadline{vm, budget};
+    const int status = lua_pcall(state, argumentCount, resultCount, functionIndex);
+    if (status != LUA_OK) {
+        const char* message = lua_tostring(state, -1);
+        outError = message != nullptr ? message : "unknown Luau error";
+        lua_pop(state, 1);
+        lua_remove(state, functionIndex);
+        return false;
+    }
+    lua_remove(state, functionIndex);
+    return true;
+}
+
+std::optional<std::string> normalize_module_path(
+    std::string_view currentPath, std::string_view requested) {
+    if ((!requested.starts_with("./") && !requested.starts_with("../")) ||
+        requested.find('\\') != std::string_view::npos)
+    {
+        return std::nullopt;
+    }
+
+    std::vector<std::string_view> parts;
+    const auto parentEnd = currentPath.rfind('/');
+    std::string combined;
+    if (parentEnd != std::string_view::npos) {
+        combined.assign(currentPath.substr(0, parentEnd + 1));
+    }
+    combined.append(requested);
+
+    size_t begin = 0;
+    while (begin <= combined.size()) {
+        const size_t end = combined.find('/', begin);
+        const auto part = std::string_view{combined}.substr(
+            begin, end == std::string::npos ? combined.size() - begin : end - begin);
+        if (part.empty() || part == ".") {
+        } else if (part == "..") {
+            if (parts.empty()) {
+                return std::nullopt;
+            }
+            parts.pop_back();
+        } else {
+            parts.push_back(part);
+        }
+        if (end == std::string::npos) {
+            break;
+        }
+        begin = end + 1;
+    }
+    if (parts.empty()) {
+        return std::nullopt;
+    }
+
+    std::string normalized;
+    for (const auto part : parts) {
+        if (!normalized.empty()) {
+            normalized.push_back('/');
+        }
+        normalized.append(part);
+    }
+    if (!normalized.ends_with(".luau")) {
+        normalized += ".luau";
+    }
+    return normalized;
+}
+
+ModuleOpenFn module_factory(std::string_view name) {
+    if (name == "dusklight.log") {
+        return open_log;
+    }
+    if (name == "dusklight.host") {
+        return open_host;
+    }
+    if (name == "dusklight.resource") {
+        return open_resource;
+    }
+    if (name == "dusklight.overlay") {
+        return open_overlay;
+    }
+    if (name == "dusklight.texture") {
+        return open_texture;
+    }
+    if (name == "dusklight.config") {
+        return open_config;
+    }
+    if (name == "dusklight.ui") {
+        return open_ui;
+    }
+    return nullptr;
+}
+
+int module_require(lua_State* state);
+int print(lua_State* state);
+
+void install_module_require(lua_State* state, Vm& vm, std::string_view currentPath) {
+    lua_pushlightuserdata(state, &vm);
+    lua_pushlstring(state, currentPath.data(), currentPath.size());
+    lua_pushcclosure(state, module_require, "require", 2);
+    lua_setglobal(state, "require");
+}
+
+void install_globals(Vm& vm) {
+    push_vm_closure(vm.state, vm, print, "print");
+    lua_setglobal(vm.state, "print");
+}
+
+bool load_source_module(
+    lua_State* caller, Vm& vm, const std::string& path, bool keepResult, std::string& outError) {
+    if (svc_resource == nullptr) {
+        outError = "ResourceService is not available in this Dusklight build";
+        return false;
+    }
+
+    ResourceBuffer buffer = RESOURCE_BUFFER_INIT;
+    const ModResult loadResult = svc_resource->load(vm.subject, path.c_str(), &buffer);
+    if (loadResult != MOD_OK) {
+        outError = loadResult == MOD_UNAVAILABLE ? "module not found: res/" + path :
+                                                   "failed to load module: res/" + path;
+        return false;
+    }
+    std::string source;
+    if (buffer.data != nullptr) {
+        source.assign(static_cast<const char*>(buffer.data), buffer.size);
+    }
+    svc_resource->free(vm.subject, &buffer);
+
+    size_t bytecodeSize = 0;
+    lua_CompileOptions options{};
+    options.optimizationLevel = 1;
+    options.debugLevel = 1;
+    char* bytecode = luau_compile(source.data(), source.size(), &options, &bytecodeSize);
+    if (bytecode == nullptr) {
+        outError = "Luau compiler ran out of memory";
+        return false;
+    }
+
+    lua_State* moduleState = lua_newthread(caller);
+    if (moduleState == nullptr) {
+        std::free(bytecode);
+        outError = "Luau VM ran out of memory";
+        return false;
+    }
+    luaL_sandboxthread(moduleState);
+    install_module_require(moduleState, vm, path);
+
+    const std::string chunkName = "@res/" + path;
+    const int loadStatus = luau_load(moduleState, chunkName.c_str(), bytecode, bytecodeSize, 0);
+    std::free(bytecode);
+    if (loadStatus != LUA_OK) {
+        const char* message = lua_tostring(moduleState, -1);
+        outError = message != nullptr ? message : "failed to load Luau bytecode";
+        lua_pop(caller, 1);
+        return false;
+    }
+    if (!protected_call(moduleState, vm, 0, keepResult ? 1 : 0, kLifecycleBudget, outError)) {
+        lua_pop(caller, 1);
+        return false;
+    }
+    if (!keepResult) {
+        lua_pop(caller, 1);
+        return true;
+    }
+    if (lua_isnil(moduleState, -1)) {
+        outError = "module res/" + path + " must return a value";
+        lua_pop(caller, 1);
+        return false;
+    }
+
+    lua_xmove(moduleState, caller, 1);
+    lua_remove(caller, -2);
+    return true;
+}
+
+int module_require(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    const std::string requested = luaL_checkstring(state, 1);
+
+    std::string moduleName;
+    ModuleOpenFn factory = nullptr;
+    if (requested.starts_with("dusklight.")) {
+        moduleName = requested;
+        factory = module_factory(moduleName);
+        if (factory == nullptr) {
+            luaL_error(state, "unknown module '%s'", moduleName.c_str());
+        }
+    } else {
+        const char* currentPath = lua_tostring(state, lua_upvalueindex(2));
+        const auto normalized =
+            normalize_module_path(currentPath != nullptr ? currentPath : "main.luau", requested);
+        if (!normalized.has_value()) {
+            luaL_error(
+                state, "module paths must be relative and remain inside the mod's res directory");
+        }
+        moduleName = *normalized;
+    }
+
+    if (const auto found = vm.moduleRefs.find(moduleName); found != vm.moduleRefs.end()) {
+        lua_getref(state, found->second);
+        return 1;
+    }
+    if (!vm.loadingModules.insert(moduleName).second) {
+        luaL_error(state, "cyclic require of '%s'", moduleName.c_str());
+    }
+
+    std::string error;
+    if (factory != nullptr) {
+        factory(state);
+    } else if (!load_source_module(state, vm, moduleName, true, error)) {
+        vm.loadingModules.erase(moduleName);
+        luaL_error(state, "%s", error.c_str());
+    }
+    vm.loadingModules.erase(moduleName);
+
+    const int ref = lua_ref(state, -1);
+    vm.moduleRefs.emplace(moduleName, ref);
+    return 1;
+}
+
+int print(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_log == nullptr) {
+        service_unavailable(state, "LogService");
+    }
+
+    std::string value;
+    int const numArgs = lua_gettop(state);
+    for (int i = 0; i < numArgs; i += 1) {
+        if (i != 0) {
+            value.push_back('\t');
+        }
+
+        size_t length;
+        char const* str = luaL_tolstring(state, i + 1, &length);
+        value.append(str, length);
+        lua_pop(state, 1);
+    }
+
+    svc_log->info(vm.subject, value.data());
+    return 0;
+}
+
+ModResult runtime_activate(ModContext*, ModContext* subject, ModError* outError) {
+    if (subject == nullptr) {
+        return set_error(outError, MOD_INVALID_ARGUMENT, "Delegated mod context is null");
+    }
+    if (s_vms.contains(subject)) {
+        return set_error(outError, MOD_CONFLICT, "Delegated mod is already active");
+    }
+
+    auto vm = std::make_unique<Vm>();
+    vm->subject = subject;
+    vm->state = lua_newstate(limited_realloc, &vm->memory);
+    if (vm->state == nullptr) {
+        return set_error(outError, MOD_ERROR, "Failed to create Luau VM");
+    }
+    lua_callbacks(vm->state)->userdata = vm.get();
+#if NDEBUG // Annoying for debuggers
+    lua_callbacks(vm->state)->interrupt = [](lua_State* state, int gc) {
+        auto* current = static_cast<Vm*>(lua_callbacks(state)->userdata);
+        if (gc < 0 && current != nullptr && current->deadlineActive &&
+            std::chrono::steady_clock::now() > current->deadline)
+        {
+            luaL_error(state, "script execution exceeded its time budget");
+        }
+    };
+#endif
+    luaL_openlibs(vm->state);
+    install_globals(*vm);
+    luaL_sandbox(vm->state);
+
+    std::string error;
+    vm->loadingModules.insert("main.luau");
+    const bool loadedMain = load_source_module(vm->state, *vm, "main.luau", false, error);
+    vm->loadingModules.erase("main.luau");
+    if (!loadedMain) {
+        return set_error(outError, MOD_ERROR, error);
+    }
+
+    s_vms.emplace(subject, std::move(vm));
+    return MOD_OK;
+}
+
+ModResult runtime_update(ModContext*, ModContext* subject, ModError* outError) {
+    const auto found = s_vms.find(subject);
+    if (found == s_vms.end()) {
+        return set_error(outError, MOD_INVALID_ARGUMENT, "Delegated mod is not active");
+    }
+    Vm& vm = *found->second;
+    const size_t callbackCount = vm.updateRefs.size();
+    if (callbackCount == 0) {
+        return MOD_OK;
+    }
+
+    DeadlineScope deadline{vm, kUpdateBudget};
+    std::string error;
+    for (size_t i = 0; i < callbackCount; ++i) {
+        const int ref = vm.updateRefs[i];
+        if (!call_ref(vm, ref, 0, 0, kUpdateBudget, error)) {
+            return set_error(outError, MOD_ERROR, error);
+        }
+    }
+    return MOD_OK;
+}
+
+ModResult runtime_deactivate(ModContext*, ModContext* subject, ModError*) {
+    const auto found = s_vms.find(subject);
+    if (found == s_vms.end()) {
+        return MOD_OK;
+    }
+
+    {
+        Vm& vm = *found->second;
+        DeadlineScope deadline{vm, kLifecycleBudget};
+        const size_t callbackCount = vm.shutdownRefs.size();
+        for (size_t i = callbackCount; i > 0; --i) {
+            std::string error;
+            const int ref = vm.shutdownRefs[i - 1];
+            if (!call_ref(vm, ref, 0, 0, kLifecycleBudget, error) && svc_log != nullptr) {
+                svc_log->write(subject, LOG_LEVEL_ERROR, error.c_str());
+            }
+        }
+    }
+    s_vms.erase(found);
+    return MOD_OK;
+}
+
+constexpr ModRuntimeService s_runtimeService{
+    .header = SERVICE_HEADER(ModRuntimeService, 1, 0),
+    .activate = runtime_activate,
+    .update = runtime_update,
+    .deactivate = runtime_deactivate,
+};
+EXPORT_SERVICE_AS(s_runtimeService, "dev.twilitrealm.luau");
+
+}  // namespace
+
+Vm::~Vm() {
+    if (state != nullptr) {
+        lua_close(state);
+    }
+}
+
+Vm& vm_from_upvalue(lua_State* state) {
+    auto* vm = static_cast<Vm*>(lua_tolightuserdata(state, lua_upvalueindex(1)));
+    if (vm == nullptr) {
+        luaL_error(state, "missing Luau runtime context");
+    }
+    return *vm;
+}
+
+void push_vm_closure(lua_State* state, Vm& vm, lua_CFunction function, const char* name) {
+    lua_pushlightuserdata(state, &vm);
+    lua_pushcclosure(state, function, name, 1);
+}
+
+void set_function(lua_State* state, Vm& vm, const char* name, lua_CFunction function) {
+    push_vm_closure(state, vm, function, name);
+    lua_setfield(state, -2, name);
+}
+
+[[noreturn]] void service_unavailable(lua_State* state, const char* name) {
+    luaL_error(state, "%s is not available in this Dusklight build", name);
+}
+
+void check_result(lua_State* state, ModResult result, const char* operation) {
+    if (result == MOD_OK) {
+        return;
+    }
+    const char* resultName = "error";
+    switch (result) {
+    case MOD_UNAVAILABLE:
+        resultName = "unavailable";
+        break;
+    case MOD_UNSUPPORTED:
+        resultName = "unsupported";
+        break;
+    case MOD_CONFLICT:
+        resultName = "conflict";
+        break;
+    case MOD_INVALID_ARGUMENT:
+        resultName = "invalid argument";
+        break;
+    default:
+        break;
+    }
+    luaL_error(state, "%s failed: %s", operation, resultName);
+}
+
+bool get_optional_bool(lua_State* state, int table, const char* field, bool fallback) {
+    lua_getfield(state, table, field);
+    const bool value = lua_isnil(state, -1) ? fallback : luaL_checkboolean(state, -1) != 0;
+    lua_pop(state, 1);
+    return value;
+}
+
+bool to_int64(lua_State* state, int index, int64_t& outValue) {
+    if (lua_isinteger64(state, index)) {
+        outValue = lua_tointeger64(state, index, nullptr);
+        return true;
+    }
+    if (!lua_isnumber(state, index)) {
+        return false;
+    }
+    const double value = lua_tonumber(state, index);
+    constexpr double kMaxSafeInteger = 9007199254740991.0;
+    if (!std::isfinite(value) || value < -kMaxSafeInteger || value > kMaxSafeInteger ||
+        std::trunc(value) != value)
+    {
+        return false;
+    }
+    outValue = static_cast<int64_t>(value);
+    return true;
+}
+
+int64_t check_int64(lua_State* state, int index) {
+    int64_t value = 0;
+    if (!to_int64(state, index, value)) {
+        luaL_argerror(state, index, "integer value expected");
+    }
+    return value;
+}
+
+int64_t get_optional_int(lua_State* state, int table, const char* field, int64_t fallback) {
+    lua_getfield(state, table, field);
+    const int64_t value = lua_isnil(state, -1) ? fallback : check_int64(state, -1);
+    lua_pop(state, 1);
+    return value;
+}
+
+double get_optional_number(lua_State* state, int table, const char* field, double fallback) {
+    lua_getfield(state, table, field);
+    const double value = lua_isnil(state, -1) ? fallback : luaL_checknumber(state, -1);
+    lua_pop(state, 1);
+    return value;
+}
+
+std::string get_optional_string(
+    lua_State* state, int table, const char* field, std::string fallback) {
+    lua_getfield(state, table, field);
+    if (!lua_isnil(state, -1)) {
+        size_t length = 0;
+        const char* value = luaL_checklstring(state, -1, &length);
+        fallback.assign(value, length);
+    }
+    lua_pop(state, 1);
+    return fallback;
+}
+
+int ref_optional_function(lua_State* state, int table, const char* field) {
+    lua_getfield(state, table, field);
+    if (lua_isnil(state, -1)) {
+        lua_pop(state, 1);
+        return LUA_NOREF;
+    }
+    luaL_argexpected(state, lua_isfunction(state, -1), table, "function field");
+    const int ref = lua_ref(state, -1);
+    lua_pop(state, 1);
+    return ref;
+}
+
+int ref_required_function(lua_State* state, int table, const char* field) {
+    const int ref = ref_optional_function(state, table, field);
+    if (ref == LUA_NOREF) {
+        luaL_error(state, "field '%s' is required", field);
+    }
+    return ref;
+}
+
+Callback& retain_callback(Vm& vm) {
+    auto callback = std::make_unique<Callback>();
+    callback->vm = &vm;
+    callback->refs.fill(LUA_NOREF);
+    vm.callbacks.push_back(std::move(callback));
+    return *vm.callbacks.back();
+}
+
+bool call_ref(Vm& vm, int ref, int argumentCount, int resultCount,
+    std::chrono::steady_clock::duration budget, std::string& outError) {
+    lua_State* state = vm.state;
+    lua_getref(state, ref);
+    if (!lua_isfunction(state, -1)) {
+        lua_pop(state, 1);
+        outError = "callback is no longer a function";
+        return false;
+    }
+    if (argumentCount != 0) {
+        lua_insert(state, -argumentCount - 1);
+    }
+    return protected_call(state, vm, argumentCount, resultCount, budget, outError);
+}
+
+void fail_callback(Vm& vm, std::string_view callbackName, std::string_view error) {
+    const std::string message = std::string{callbackName} + ": " + std::string{error};
+    if (svc_host != nullptr) {
+        svc_host->fail(vm.subject, MOD_ERROR, message.c_str());
+    } else if (svc_log != nullptr) {
+        svc_log->write(vm.subject, LOG_LEVEL_ERROR, message.c_str());
+    }
+}
+
+ModResult set_error(ModError* outError, ModResult result, std::string_view message) {
+    if (outError != nullptr && outError->struct_size >= sizeof(ModError)) {
+        outError->code = result;
+        const size_t size = std::min(message.size(), sizeof(outError->message) - 1);
+        std::memcpy(outError->message, message.data(), size);
+        outError->message[size] = '\0';
+    }
+    return result;
+}
+
+void create_handle_metatable(
+    lua_State* state, const char* name, const luaL_Reg* methods, const char* typeName) {
+    luaL_newmetatable(state, name);
+    luaL_register(state, nullptr, methods);
+    lua_pushvalue(state, -1);
+    lua_setfield(state, -2, "__index");
+    lua_pushstring(state, typeName);
+    lua_setfield(state, -2, "__type");
+    lua_setreadonly(state, -1, true);
+    lua_pop(state, 1);
+}
+
+ScriptHandle& check_handle(lua_State* state, int index, const char* metatable, HandleKind kind) {
+    auto* handle = static_cast<ScriptHandle*>(luaL_checkudata(state, index, metatable));
+    if (handle == nullptr || handle->kind != kind || handle->vm == nullptr || handle->value == 0) {
+        luaL_argerror(state, index, "stale handle");
+    }
+    return *handle;
+}
+
+void push_handle(lua_State* state, Vm& vm, uint64_t value, HandleKind kind, const char* metatable,
+    ConfigVarType configType) {
+    auto* handle = static_cast<ScriptHandle*>(lua_newuserdata(state, sizeof(ScriptHandle)));
+    *handle = ScriptHandle{.vm = &vm, .value = value, .kind = kind, .configType = configType};
+    luaL_getmetatable(state, metatable);
+    lua_setmetatable(state, -2);
+}
+
+}  // namespace luau_runtime
+
+extern "C" {
+MOD_EXPORT ModResult mod_initialize(ModError*) {
+    FFlag::LuauIntegerType2.value = true;
+    FFlag::LuauIntegerLibrary.value = true;
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_shutdown(ModError*) {
+    luau_runtime::s_vms.clear();
+    return MOD_OK;
+}
+}
diff --git a/mods/luau_runtime/src/runtime.hpp b/mods/luau_runtime/src/runtime.hpp
new file mode 100644
index 0000000000..2916a817e5
--- /dev/null
+++ b/mods/luau_runtime/src/runtime.hpp
@@ -0,0 +1,124 @@
+#pragma once
+
+#include "lua.h"
+#include "lualib.h"
+
+#include "mods/api.h"
+#include "mods/svc/config.h"
+#include "mods/svc/host.h"
+#include "mods/svc/log.h"
+#include "mods/svc/overlay.h"
+#include "mods/svc/resource.h"
+#include "mods/svc/texture.h"
+#include "mods/svc/ui.h"
+
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace luau_runtime {
+
+constexpr size_t kMemoryLimit = 64u * 1024u * 1024u;
+constexpr auto kUpdateBudget = std::chrono::milliseconds{250};
+constexpr auto kLifecycleBudget = std::chrono::seconds{5};
+constexpr auto kCallbackBudget = std::chrono::milliseconds{250};
+
+struct MemoryBudget {
+    size_t used = 0;
+    size_t limit = kMemoryLimit;
+};
+
+struct Vm;
+
+struct Callback {
+    Vm* vm = nullptr;
+    std::array<int, 8> refs{};
+    std::string returnedString;
+    int tag = 0;
+};
+
+struct Vm {
+    MemoryBudget memory;
+    lua_State* state = nullptr;
+    ModContext* subject = nullptr;
+    std::vector<int> updateRefs;
+    std::vector<int> shutdownRefs;
+    std::unordered_map<std::string, int> moduleRefs;
+    std::unordered_set<std::string> loadingModules;
+    std::vector<std::unique_ptr<Callback>> callbacks;
+    std::chrono::steady_clock::time_point deadline{};
+    unsigned callDepth = 0;
+    bool deadlineActive = false;
+
+    ~Vm();
+};
+
+enum class HandleKind : uint8_t {
+    ConfigVar,
+    ConfigSubscription,
+    Overlay,
+    Texture,
+    UiWindow,
+    UiDialog,
+    UiElement,
+    UiStyle,
+    UiMenuTab,
+    UiList,
+};
+
+struct ScriptHandle {
+    Vm* vm = nullptr;
+    uint64_t value = 0;
+    HandleKind kind = HandleKind::ConfigVar;
+    ConfigVarType configType = CONFIG_VAR_BOOL;
+};
+
+using ModuleOpenFn = int (*)(lua_State* state);
+
+Vm& vm_from_upvalue(lua_State* state);
+void push_vm_closure(lua_State* state, Vm& vm, lua_CFunction function, const char* name);
+void set_function(lua_State* state, Vm& vm, const char* name, lua_CFunction function);
+
+[[noreturn]] void service_unavailable(lua_State* state, const char* name);
+void check_result(lua_State* state, ModResult result, const char* operation);
+
+bool get_optional_bool(lua_State* state, int table, const char* field, bool fallback);
+bool to_int64(lua_State* state, int index, int64_t& outValue);
+int64_t check_int64(lua_State* state, int index);
+int64_t get_optional_int(lua_State* state, int table, const char* field, int64_t fallback);
+double get_optional_number(lua_State* state, int table, const char* field, double fallback);
+std::string get_optional_string(
+    lua_State* state, int table, const char* field, std::string fallback = {});
+int ref_optional_function(lua_State* state, int table, const char* field);
+int ref_required_function(lua_State* state, int table, const char* field);
+
+Callback& retain_callback(Vm& vm);
+bool call_ref(Vm& vm, int ref, int argumentCount, int resultCount,
+    std::chrono::steady_clock::duration budget, std::string& outError);
+void fail_callback(Vm& vm, std::string_view callbackName, std::string_view error);
+ModResult set_error(ModError* outError, ModResult result, std::string_view message);
+
+void create_handle_metatable(
+    lua_State* state, const char* name, const luaL_Reg* methods, const char* typeName);
+ScriptHandle& check_handle(lua_State* state, int index, const char* metatable, HandleKind kind);
+void push_handle(lua_State* state, Vm& vm, uint64_t value, HandleKind kind, const char* metatable,
+    ConfigVarType configType = CONFIG_VAR_BOOL);
+
+void push_config_value(lua_State* state, const ConfigVarValue& value);
+void push_ui_handle(lua_State* state, Vm& vm, uint64_t value, HandleKind kind);
+
+int open_log(lua_State* state);
+int open_host(lua_State* state);
+int open_resource(lua_State* state);
+int open_overlay(lua_State* state);
+int open_texture(lua_State* state);
+int open_config(lua_State* state);
+int open_ui(lua_State* state);
+
+}  // namespace luau_runtime
diff --git a/mods/luau_runtime/src/ui.cpp b/mods/luau_runtime/src/ui.cpp
new file mode 100644
index 0000000000..7c3acc1296
--- /dev/null
+++ b/mods/luau_runtime/src/ui.cpp
@@ -0,0 +1,856 @@
+#include "runtime.hpp"
+
+#include <algorithm>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace luau_runtime {
+namespace {
+
+constexpr char kUiWindowMetatable[] = "dusklight.ui_window";
+constexpr char kUiDialogMetatable[] = "dusklight.ui_dialog";
+constexpr char kUiElementMetatable[] = "dusklight.ui_element";
+constexpr char kUiStyleMetatable[] = "dusklight.ui_style";
+constexpr char kUiMenuTabMetatable[] = "dusklight.ui_menu_tab";
+constexpr char kUiListMetatable[] = "dusklight.ui_list";
+
+const char* ui_metatable(HandleKind kind) {
+    switch (kind) {
+    case HandleKind::UiWindow:
+        return kUiWindowMetatable;
+    case HandleKind::UiDialog:
+        return kUiDialogMetatable;
+    case HandleKind::UiStyle:
+        return kUiStyleMetatable;
+    case HandleKind::UiMenuTab:
+        return kUiMenuTabMetatable;
+    case HandleKind::UiList:
+        return kUiListMetatable;
+    default:
+        return kUiElementMetatable;
+    }
+}
+
+ScriptHandle& check_ui_handle(lua_State* state, int index, HandleKind kind) {
+    return check_handle(state, index, ui_metatable(kind), kind);
+}
+
+ScriptHandle& check_config_var(lua_State* state, int index) {
+    luaL_checktype(state, index, LUA_TUSERDATA);
+    auto* handle = static_cast<ScriptHandle*>(lua_touserdata(state, index));
+    if (handle == nullptr || handle->kind != HandleKind::ConfigVar || handle->value == 0 ||
+        handle->vm == nullptr)
+    {
+        luaL_argerror(state, index, "expected a live ConfigVar");
+    }
+    return *handle;
+}
+
+bool call_callback(Callback& callback, int ref, int argumentCount, int resultCount,
+    const char* name, std::string* outError = nullptr) {
+    std::string error;
+    if (call_ref(*callback.vm, ref, argumentCount, resultCount, kCallbackBudget, error)) {
+        return true;
+    }
+    if (outError != nullptr) {
+        *outError = std::move(error);
+    } else {
+        fail_callback(*callback.vm, name, error);
+    }
+    return false;
+}
+
+ModResult call_build(
+    Callback& callback, int ref, int argumentCount, const char* name, ModError* outError) {
+    std::string error;
+    if (call_callback(callback, ref, argumentCount, 0, name, &error)) {
+        return MOD_OK;
+    }
+    return set_error(outError, MOD_ERROR, error);
+}
+
+bool call_predicate(Callback& callback, int ref, int argumentCount, const char* name) {
+    if (!call_callback(callback, ref, argumentCount, 1, name)) {
+        return false;
+    }
+    lua_State* state = callback.vm->state;
+    const bool result = lua_toboolean(state, -1) != 0;
+    lua_pop(state, 1);
+    return result;
+}
+
+void control_get(ModContext*, void* userData, UiControlValue* outValue) {
+    auto& callback = *static_cast<Callback*>(userData);
+    if (outValue == nullptr || !call_callback(callback, callback.refs[0], 0, 1, "control get")) {
+        return;
+    }
+    lua_State* state = callback.vm->state;
+    switch (static_cast<UiControlKind>(callback.tag)) {
+    case UI_CONTROL_TOGGLE:
+        outValue->bool_value = lua_toboolean(state, -1) != 0;
+        break;
+    case UI_CONTROL_NUMBER:
+    case UI_CONTROL_SELECT: {
+        int64_t value = 0;
+        if (!to_int64(state, -1, value)) {
+            fail_callback(*callback.vm, "control get", "callback must return an integer");
+        } else {
+            outValue->int_value = value;
+        }
+        break;
+    }
+    case UI_CONTROL_STRING:
+    case UI_CONTROL_COLOR:
+    case UI_CONTROL_FILE_PICKER: {
+        size_t length = 0;
+        const char* value = lua_tolstring(state, -1, &length);
+        if (value == nullptr) {
+            fail_callback(*callback.vm, "control get", "callback must return a string");
+        } else {
+            callback.returnedString.assign(value, length);
+            outValue->string_value = callback.returnedString.c_str();
+        }
+        break;
+    }
+    default:
+        break;
+    }
+    lua_pop(state, 1);
+}
+
+void control_set(ModContext*, void* userData, const UiControlValue* value) {
+    auto& callback = *static_cast<Callback*>(userData);
+    if (value == nullptr) {
+        return;
+    }
+    lua_State* state = callback.vm->state;
+    switch (static_cast<UiControlKind>(callback.tag)) {
+    case UI_CONTROL_TOGGLE:
+        lua_pushboolean(state, value->bool_value);
+        break;
+    case UI_CONTROL_NUMBER:
+    case UI_CONTROL_SELECT:
+        lua_pushinteger64(state, value->int_value);
+        break;
+    case UI_CONTROL_STRING:
+    case UI_CONTROL_COLOR:
+    case UI_CONTROL_FILE_PICKER:
+        lua_pushstring(state, value->string_value != nullptr ? value->string_value : "");
+        break;
+    default:
+        return;
+    }
+    call_callback(callback, callback.refs[1], 1, 0, "control set");
+}
+
+bool control_disabled(ModContext*, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    return call_predicate(callback, callback.refs[3], 0, "control is_disabled");
+}
+
+bool control_modified(ModContext*, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    return call_predicate(callback, callback.refs[4], 0, "control is_modified");
+}
+
+bool control_selected(ModContext*, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    return call_predicate(callback, callback.refs[5], 0, "control is_selected");
+}
+
+void control_pressed(ModContext*, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    call_callback(callback, callback.refs[2], 0, 0, "control on_pressed");
+}
+
+ModResult panel_build(ModContext*, UiElementHandle pane, void* userData, ModError* outError) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, pane, HandleKind::UiElement);
+    return call_build(callback, callback.refs[0], 1, "panel build", outError);
+}
+
+ModResult panel_update(ModContext*, void* userData, ModError* outError) {
+    auto& callback = *static_cast<Callback*>(userData);
+    return call_build(callback, callback.refs[1], 0, "panel update", outError);
+}
+
+ModResult group_build(ModContext*, UiElementHandle pane, void* userData, ModError* outError) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, pane, HandleKind::UiElement);
+    return call_build(callback, callback.refs[0], 1, "group build", outError);
+}
+
+ModResult tab_build(ModContext*, UiWindowHandle window, UiElementHandle left, UiElementHandle right,
+    void* userData, ModError* outError) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, window, HandleKind::UiWindow);
+    push_ui_handle(callback.vm->state, *callback.vm, left, HandleKind::UiElement);
+    push_ui_handle(callback.vm->state, *callback.vm, right, HandleKind::UiElement);
+    return call_build(callback, callback.refs[0], 3, "window tab build", outError);
+}
+
+void window_closed(ModContext*, UiWindowHandle window, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, window, HandleKind::UiWindow);
+    call_callback(callback, callback.refs[0], 1, 0, "window on_closed");
+}
+
+void dialog_action(ModContext*, UiDialogHandle dialog, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, dialog, HandleKind::UiDialog);
+    call_callback(callback, callback.refs[0], 1, 0, "dialog action");
+}
+
+bool dialog_action_disabled(ModContext*, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    return call_predicate(callback, callback.refs[1], 0, "dialog action is_disabled");
+}
+
+void dialog_dismissed(ModContext*, UiDialogHandle dialog, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, dialog, HandleKind::UiDialog);
+    call_callback(callback, callback.refs[0], 1, 0, "dialog on_dismiss");
+}
+
+ModResult dialog_build(ModContext*, UiElementHandle pane, void* userData, ModError* outError) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, pane, HandleKind::UiElement);
+    return call_build(callback, callback.refs[1], 1, "dialog build", outError);
+}
+
+void menu_selected(ModContext*, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    call_callback(callback, callback.refs[0], 0, 0, "menu tab on_selected");
+}
+
+void list_pressed(ModContext*, UiListHandle list, uint64_t key, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, list, HandleKind::UiList);
+    lua_pushinteger64(callback.vm->state, static_cast<int64_t>(key));
+    call_callback(callback, callback.refs[0], 2, 0, "list on_pressed");
+}
+
+bool list_selected(ModContext*, UiListHandle list, uint64_t key, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, list, HandleKind::UiList);
+    lua_pushinteger64(callback.vm->state, static_cast<int64_t>(key));
+    return call_predicate(callback, callback.refs[1], 2, "list is_selected");
+}
+
+bool list_disabled(ModContext*, UiListHandle list, uint64_t key, void* userData) {
+    auto& callback = *static_cast<Callback*>(userData);
+    push_ui_handle(callback.vm->state, *callback.vm, list, HandleKind::UiList);
+    lua_pushinteger64(callback.vm->state, static_cast<int64_t>(key));
+    return call_predicate(callback, callback.refs[2], 2, "list is_disabled");
+}
+
+std::vector<std::string> string_array(lua_State* state, int table, const char* field) {
+    std::vector<std::string> result;
+    lua_getfield(state, table, field);
+    if (lua_isnil(state, -1)) {
+        lua_pop(state, 1);
+        return result;
+    }
+    luaL_checktype(state, -1, LUA_TTABLE);
+    const int count = lua_objlen(state, -1);
+    result.reserve(count);
+    for (int i = 1; i <= count; ++i) {
+        lua_rawgeti(state, -1, i);
+        result.emplace_back(luaL_checkstring(state, -1));
+        lua_pop(state, 1);
+    }
+    lua_pop(state, 1);
+    return result;
+}
+
+std::vector<UiListItem> list_items(lua_State* state, int table, std::vector<std::string>& labels) {
+    luaL_checktype(state, table, LUA_TTABLE);
+    const int count = lua_objlen(state, table);
+    labels.reserve(count);
+    std::vector<UiListItem> items;
+    items.reserve(count);
+    for (int i = 1; i <= count; ++i) {
+        lua_rawgeti(state, table, i);
+        luaL_checktype(state, -1, LUA_TTABLE);
+        labels.push_back(get_optional_string(state, -1, "label"));
+        UiListItem item = UI_LIST_ITEM_INIT;
+        item.key = static_cast<uint64_t>(get_optional_int(state, -1, "key", 0));
+        items.push_back(item);
+        lua_pop(state, 1);
+    }
+    for (size_t i = 0; i < items.size(); ++i) {
+        items[i].label = labels[i].c_str();
+    }
+    return items;
+}
+
+UiControlKind control_kind(lua_State* state, const std::string& kind) {
+    if (kind == "button")
+        return UI_CONTROL_BUTTON;
+    if (kind == "toggle")
+        return UI_CONTROL_TOGGLE;
+    if (kind == "number")
+        return UI_CONTROL_NUMBER;
+    if (kind == "string")
+        return UI_CONTROL_STRING;
+    if (kind == "select")
+        return UI_CONTROL_SELECT;
+    if (kind == "color")
+        return UI_CONTROL_COLOR;
+    if (kind == "group")
+        return UI_CONTROL_GROUP;
+    if (kind == "file_picker")
+        return UI_CONTROL_FILE_PICKER;
+    luaL_error(state, "unknown UI control kind '%s'", kind.c_str());
+}
+
+UiStyleScope style_scope(lua_State* state, const std::string& scope) {
+    if (scope == "prelaunch")
+        return UI_SCOPE_PRELAUNCH;
+    if (scope == "window")
+        return UI_SCOPE_WINDOW;
+    if (scope == "menu_bar")
+        return UI_SCOPE_MENU_BAR;
+    if (scope == "overlay")
+        return UI_SCOPE_OVERLAY;
+    if (scope == "touch_controls")
+        return UI_SCOPE_TOUCH_CONTROLS;
+    if (scope == "graphics_tuner")
+        return UI_SCOPE_GRAPHICS_TUNER;
+    luaL_error(state, "unknown UI style scope '%s'", scope.c_str());
+}
+
+int pane_add_section(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    check_result(state,
+        svc_ui->pane_add_section(pane.vm->subject, pane.value, luaL_checkstring(state, 2)),
+        "ui pane_add_section");
+    return 0;
+}
+
+int pane_add_text(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    UiElementHandle element = 0;
+    check_result(state,
+        svc_ui->pane_add_text(pane.vm->subject, pane.value, luaL_checkstring(state, 2), &element),
+        "ui pane_add_text");
+    push_ui_handle(state, *pane.vm, element, HandleKind::UiElement);
+    return 1;
+}
+
+int pane_add_rml(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    UiElementHandle element = 0;
+    check_result(state,
+        svc_ui->pane_add_rml(pane.vm->subject, pane.value, luaL_checkstring(state, 2), &element),
+        "ui pane_add_rml");
+    push_ui_handle(state, *pane.vm, element, HandleKind::UiElement);
+    return 1;
+}
+
+int pane_add_progress(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    UiElementHandle element = 0;
+    check_result(state,
+        svc_ui->pane_add_progress(
+            pane.vm->subject, pane.value, static_cast<float>(luaL_checknumber(state, 2)), &element),
+        "ui pane_add_progress");
+    push_ui_handle(state, *pane.vm, element, HandleKind::UiElement);
+    return 1;
+}
+
+int pane_add_control(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    luaL_checktype(state, 2, LUA_TTABLE);
+
+    UiControlDesc desc = UI_CONTROL_DESC_INIT;
+    const std::string kind = get_optional_string(state, 2, "kind");
+    const std::string label = get_optional_string(state, 2, "label");
+    const std::string help = get_optional_string(state, 2, "help_rml");
+    const std::string prefix = get_optional_string(state, 2, "prefix");
+    const std::string suffix = get_optional_string(state, 2, "suffix");
+    desc.kind = control_kind(state, kind);
+    desc.label = label.c_str();
+    desc.help_rml = help.empty() ? nullptr : help.c_str();
+    desc.min = get_optional_int(state, 2, "min", 0);
+    desc.max = get_optional_int(state, 2, "max", 0);
+    desc.step = get_optional_int(state, 2, "step", 1);
+    desc.prefix = prefix.empty() ? nullptr : prefix.c_str();
+    desc.suffix = suffix.empty() ? nullptr : suffix.c_str();
+    desc.max_length = static_cast<int32_t>(get_optional_int(state, 2, "max_length", 0));
+    desc.color_alpha = get_optional_bool(state, 2, "color_alpha", false);
+    desc.directory_mode = get_optional_bool(state, 2, "directory_mode", false);
+    desc.string_set_mode = get_optional_string(state, 2, "string_set_mode") == "change" ?
+                               UI_STRING_SET_ON_CHANGE :
+                               UI_STRING_SET_ON_COMMIT;
+
+    std::vector<std::string> options = string_array(state, 2, "options");
+    std::vector<const char*> optionPointers;
+    optionPointers.reserve(options.size());
+    for (const auto& option : options)
+        optionPointers.push_back(option.c_str());
+    desc.options = optionPointers.data();
+    desc.option_count = optionPointers.size();
+
+    std::vector<std::string> presets = string_array(state, 2, "color_presets");
+    std::vector<const char*> presetPointers;
+    presetPointers.reserve(presets.size());
+    for (const auto& preset : presets)
+        presetPointers.push_back(preset.c_str());
+    desc.color_presets = presetPointers.data();
+    desc.color_preset_count = presetPointers.size();
+
+    std::vector<std::string> filterNames;
+    std::vector<std::string> filterPatterns;
+    std::vector<FileFilter> filters;
+    lua_getfield(state, 2, "file_filters");
+    if (!lua_isnil(state, -1)) {
+        luaL_checktype(state, -1, LUA_TTABLE);
+        const int count = lua_objlen(state, -1);
+        filterNames.reserve(count);
+        filterPatterns.reserve(count);
+        filters.resize(count);
+        for (int i = 1; i <= count; ++i) {
+            lua_rawgeti(state, -1, i);
+            filterNames.push_back(get_optional_string(state, -1, "name"));
+            filterPatterns.push_back(get_optional_string(state, -1, "pattern"));
+            lua_pop(state, 1);
+        }
+        for (int i = 0; i < count; ++i) {
+            filters[i] = {filterNames[i].c_str(), filterPatterns[i].c_str()};
+        }
+    }
+    lua_pop(state, 1);
+    desc.file_filters = filters.data();
+    desc.file_filter_count = filters.size();
+
+    Callback& callback = retain_callback(*pane.vm);
+    callback.tag = desc.kind;
+    callback.refs[2] = ref_optional_function(state, 2, "on_pressed");
+    callback.refs[3] = ref_optional_function(state, 2, "is_disabled");
+    callback.refs[4] = ref_optional_function(state, 2, "is_modified");
+    callback.refs[5] = ref_optional_function(state, 2, "is_selected");
+    desc.user_data = &callback;
+    desc.on_pressed = callback.refs[2] != LUA_NOREF ? control_pressed : nullptr;
+    desc.is_disabled = callback.refs[3] != LUA_NOREF ? control_disabled : nullptr;
+    desc.is_modified = callback.refs[4] != LUA_NOREF ? control_modified : nullptr;
+    desc.is_selected = callback.refs[5] != LUA_NOREF ? control_selected : nullptr;
+
+    lua_getfield(state, 2, "config_var");
+    if (!lua_isnil(state, -1)) {
+        auto& variable = check_config_var(state, -1);
+        desc.binding = UI_BINDING_CONFIG_VAR;
+        desc.config_var = variable.value;
+    } else if (desc.kind != UI_CONTROL_BUTTON && desc.kind != UI_CONTROL_GROUP) {
+        desc.binding = UI_BINDING_CALLBACKS;
+        callback.refs[0] = ref_required_function(state, 2, "get");
+        callback.refs[1] = ref_required_function(state, 2, "set");
+        desc.get = control_get;
+        desc.set = control_set;
+    }
+    lua_pop(state, 1);
+
+    UiElementHandle element = 0;
+    check_result(state, svc_ui->pane_add_control(pane.vm->subject, pane.value, &desc, &element),
+        "ui pane_add_control");
+    push_ui_handle(state, *pane.vm, element, HandleKind::UiElement);
+    return 1;
+}
+
+int pane_add_group(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    auto& target = check_ui_handle(state, 2, HandleKind::UiElement);
+    luaL_checktype(state, 3, LUA_TTABLE);
+    const std::string label = get_optional_string(state, 3, "label");
+    Callback& callback = retain_callback(*pane.vm);
+    callback.refs[0] = ref_required_function(state, 3, "build");
+    UiGroupDesc desc = UI_GROUP_DESC_INIT;
+    desc.label = label.c_str();
+    desc.build = group_build;
+    desc.user_data = &callback;
+    UiElementHandle element = 0;
+    check_result(state,
+        svc_ui->pane_add_group(pane.vm->subject, pane.value, target.value, &desc, &element),
+        "ui pane_add_group");
+    push_ui_handle(state, *pane.vm, element, HandleKind::UiElement);
+    return 1;
+}
+
+int pane_add_list(lua_State* state) {
+    auto& pane = check_ui_handle(state, 1, HandleKind::UiElement);
+    luaL_checktype(state, 2, LUA_TTABLE);
+    Callback& callback = retain_callback(*pane.vm);
+    callback.refs[0] = ref_required_function(state, 2, "on_pressed");
+    callback.refs[1] = ref_optional_function(state, 2, "is_selected");
+    callback.refs[2] = ref_optional_function(state, 2, "is_disabled");
+
+    std::vector<std::string> labels;
+    std::vector<UiListItem> items;
+    lua_getfield(state, 2, "items");
+    if (!lua_isnil(state, -1))
+        items = list_items(state, -1, labels);
+    lua_pop(state, 1);
+
+    UiListDesc desc = UI_LIST_DESC_INIT;
+    desc.items = items.data();
+    desc.item_count = items.size();
+    desc.on_pressed = list_pressed;
+    desc.is_selected = callback.refs[1] != LUA_NOREF ? list_selected : nullptr;
+    desc.is_disabled = callback.refs[2] != LUA_NOREF ? list_disabled : nullptr;
+    desc.user_data = &callback;
+    UiListHandle list = 0;
+    check_result(state, svc_ui->pane_add_list(pane.vm->subject, pane.value, &desc, &list),
+        "ui pane_add_list");
+    push_ui_handle(state, *pane.vm, list, HandleKind::UiList);
+    return 1;
+}
+
+int element_set_text(lua_State* state) {
+    auto& element = check_ui_handle(state, 1, HandleKind::UiElement);
+    check_result(state,
+        svc_ui->elem_set_text(element.vm->subject, element.value, luaL_checkstring(state, 2)),
+        "ui elem_set_text");
+    return 0;
+}
+
+int element_set_rml(lua_State* state) {
+    auto& element = check_ui_handle(state, 1, HandleKind::UiElement);
+    check_result(state,
+        svc_ui->elem_set_rml(element.vm->subject, element.value, luaL_checkstring(state, 2)),
+        "ui elem_set_rml");
+    return 0;
+}
+
+int element_set_progress(lua_State* state) {
+    auto& element = check_ui_handle(state, 1, HandleKind::UiElement);
+    check_result(state,
+        svc_ui->elem_set_progress(
+            element.vm->subject, element.value, static_cast<float>(luaL_checknumber(state, 2))),
+        "ui elem_set_progress");
+    return 0;
+}
+
+int element_set_class(lua_State* state) {
+    auto& element = check_ui_handle(state, 1, HandleKind::UiElement);
+    check_result(state,
+        svc_ui->elem_set_class(element.vm->subject, element.value, luaL_checkstring(state, 2),
+            luaL_checkboolean(state, 3) != 0),
+        "ui elem_set_class");
+    return 0;
+}
+
+int list_set_items(lua_State* state) {
+    auto& list = check_ui_handle(state, 1, HandleKind::UiList);
+    std::vector<std::string> labels;
+    auto items = list_items(state, 2, labels);
+    check_result(state,
+        svc_ui->list_set_items(list.vm->subject, list.value, items.data(), items.size()),
+        "ui list_set_items");
+    return 0;
+}
+
+int window_close(lua_State* state) {
+    auto& window = check_ui_handle(state, 1, HandleKind::UiWindow);
+    check_result(state, svc_ui->window_close(window.vm->subject, window.value), "ui window_close");
+    window.value = 0;
+    return 0;
+}
+
+int dialog_close(lua_State* state) {
+    auto& dialog = check_ui_handle(state, 1, HandleKind::UiDialog);
+    check_result(state, svc_ui->dialog_close(dialog.vm->subject, dialog.value), "ui dialog_close");
+    dialog.value = 0;
+    return 0;
+}
+
+int dialog_set_body(lua_State* state) {
+    auto& dialog = check_ui_handle(state, 1, HandleKind::UiDialog);
+    check_result(state,
+        svc_ui->dialog_set_body(dialog.vm->subject, dialog.value, luaL_checkstring(state, 2)),
+        "ui dialog_set_body");
+    return 0;
+}
+
+int dialog_set_icon(lua_State* state) {
+    auto& dialog = check_ui_handle(state, 1, HandleKind::UiDialog);
+    check_result(state,
+        svc_ui->dialog_set_icon(dialog.vm->subject, dialog.value, luaL_checkstring(state, 2)),
+        "ui dialog_set_icon");
+    return 0;
+}
+
+int style_unregister(lua_State* state) {
+    auto& style = check_ui_handle(state, 1, HandleKind::UiStyle);
+    check_result(
+        state, svc_ui->unregister_styles(style.vm->subject, style.value), "ui unregister_styles");
+    style.value = 0;
+    return 0;
+}
+
+int menu_tab_unregister(lua_State* state) {
+    auto& tab = check_ui_handle(state, 1, HandleKind::UiMenuTab);
+    check_result(
+        state, svc_ui->unregister_menu_tab(tab.vm->subject, tab.value), "ui unregister_menu_tab");
+    tab.value = 0;
+    return 0;
+}
+
+int register_mods_panel(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    luaL_checktype(state, 1, LUA_TTABLE);
+    Callback& callback = retain_callback(vm);
+    callback.refs[0] = ref_required_function(state, 1, "build");
+    callback.refs[1] = ref_optional_function(state, 1, "update");
+    UiModsPanelDesc desc = UI_MODS_PANEL_DESC_INIT;
+    desc.build = panel_build;
+    desc.update = callback.refs[1] != LUA_NOREF ? panel_update : nullptr;
+    desc.user_data = &callback;
+    check_result(state, svc_ui->register_mods_panel(vm.subject, &desc), "ui register_mods_panel");
+    return 0;
+}
+
+int window_push(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    luaL_checktype(state, 1, LUA_TTABLE);
+    std::vector<UiTabDesc> tabs;
+    std::vector<std::string> titles;
+    lua_getfield(state, 1, "tabs");
+    luaL_checktype(state, -1, LUA_TTABLE);
+    const int tabCount = lua_objlen(state, -1);
+    tabs.reserve(tabCount);
+    titles.reserve(tabCount);
+    for (int i = 1; i <= tabCount; ++i) {
+        lua_rawgeti(state, -1, i);
+        titles.push_back(get_optional_string(state, -1, "title"));
+        Callback& callback = retain_callback(vm);
+        callback.refs[0] = ref_required_function(state, -1, "build");
+        callback.refs[1] = ref_optional_function(state, -1, "update");
+        UiTabDesc tab = UI_TAB_DESC_INIT;
+        tab.build = tab_build;
+        tab.update = callback.refs[1] != LUA_NOREF ? panel_update : nullptr;
+        tab.user_data = &callback;
+        tabs.push_back(tab);
+        lua_pop(state, 1);
+    }
+    lua_pop(state, 1);
+    for (size_t i = 0; i < tabs.size(); ++i)
+        tabs[i].title = titles[i].c_str();
+
+    const std::string rcss = get_optional_string(state, 1, "rcss");
+    Callback& closed = retain_callback(vm);
+    closed.refs[0] = ref_optional_function(state, 1, "on_closed");
+    UiWindowDesc desc = UI_WINDOW_DESC_INIT;
+    desc.tabs = tabs.data();
+    desc.tab_count = tabs.size();
+    desc.rcss = rcss.empty() ? nullptr : rcss.c_str();
+    desc.on_closed = closed.refs[0] != LUA_NOREF ? window_closed : nullptr;
+    desc.user_data = &closed;
+    UiWindowHandle window = 0;
+    check_result(state, svc_ui->window_push(vm.subject, &desc, &window), "ui window_push");
+    push_ui_handle(state, vm, window, HandleKind::UiWindow);
+    return 1;
+}
+
+UiDialogVariant dialog_variant(lua_State* state, const std::string& variant) {
+    if (variant.empty() || variant == "normal")
+        return UI_DIALOG_NORMAL;
+    if (variant == "warning")
+        return UI_DIALOG_WARNING;
+    if (variant == "danger")
+        return UI_DIALOG_DANGER;
+    luaL_error(state, "unknown dialog variant '%s'", variant.c_str());
+}
+
+int dialog_push(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    luaL_checktype(state, 1, LUA_TTABLE);
+    const std::string title = get_optional_string(state, 1, "title");
+    const std::string body = get_optional_string(state, 1, "body_rml");
+    const std::string icon = get_optional_string(state, 1, "icon");
+    const std::string variant = get_optional_string(state, 1, "variant");
+
+    std::vector<UiDialogAction> actions;
+    std::vector<std::string> labels;
+    lua_getfield(state, 1, "actions");
+    luaL_checktype(state, -1, LUA_TTABLE);
+    const int actionCount = lua_objlen(state, -1);
+    actions.reserve(actionCount);
+    labels.reserve(actionCount);
+    for (int i = 1; i <= actionCount; ++i) {
+        lua_rawgeti(state, -1, i);
+        labels.push_back(get_optional_string(state, -1, "label"));
+        Callback& callback = retain_callback(vm);
+        callback.refs[0] = ref_optional_function(state, -1, "on_pressed");
+        callback.refs[1] = ref_optional_function(state, -1, "is_disabled");
+        UiDialogAction action = UI_DIALOG_ACTION_INIT;
+        action.on_pressed = callback.refs[0] != LUA_NOREF ? dialog_action : nullptr;
+        action.is_disabled = callback.refs[1] != LUA_NOREF ? dialog_action_disabled : nullptr;
+        action.user_data = &callback;
+        action.keep_open = get_optional_bool(state, -1, "keep_open", false);
+        actions.push_back(action);
+        lua_pop(state, 1);
+    }
+    lua_pop(state, 1);
+    for (size_t i = 0; i < actions.size(); ++i)
+        actions[i].label = labels[i].c_str();
+
+    Callback& callback = retain_callback(vm);
+    callback.refs[0] = ref_optional_function(state, 1, "on_dismiss");
+    callback.refs[1] = ref_optional_function(state, 1, "build");
+    UiDialogDesc desc = UI_DIALOG_DESC_INIT;
+    desc.title = title.c_str();
+    desc.body_rml = body.c_str();
+    desc.icon = icon.empty() ? nullptr : icon.c_str();
+    desc.variant = dialog_variant(state, variant);
+    desc.actions = actions.data();
+    desc.action_count = actions.size();
+    desc.on_dismiss = callback.refs[0] != LUA_NOREF ? dialog_dismissed : nullptr;
+    desc.build = callback.refs[1] != LUA_NOREF ? dialog_build : nullptr;
+    desc.user_data = &callback;
+    UiDialogHandle dialog = 0;
+    check_result(state, svc_ui->dialog_push(vm.subject, &desc, &dialog), "ui dialog_push");
+    push_ui_handle(state, vm, dialog, HandleKind::UiDialog);
+    return 1;
+}
+
+int is_any_document_visible(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    bool visible = false;
+    check_result(
+        state, svc_ui->is_any_document_visible(vm.subject, &visible), "ui is_any_document_visible");
+    lua_pushboolean(state, visible);
+    return 1;
+}
+
+int register_styles(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    const auto scope = style_scope(state, luaL_checkstring(state, 1));
+    UiStyleHandle style = 0;
+    check_result(state,
+        svc_ui->register_styles(vm.subject, scope, luaL_checkstring(state, 2), &style),
+        "ui register_styles");
+    push_ui_handle(state, vm, style, HandleKind::UiStyle);
+    return 1;
+}
+
+int register_styles_file(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    const auto scope = style_scope(state, luaL_checkstring(state, 1));
+    UiStyleHandle style = 0;
+    check_result(state,
+        svc_ui->register_styles_file(vm.subject, scope, luaL_checkstring(state, 2), &style),
+        "ui register_styles_file");
+    push_ui_handle(state, vm, style, HandleKind::UiStyle);
+    return 1;
+}
+
+int register_menu_tab(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    luaL_checktype(state, 1, LUA_TTABLE);
+    const std::string label = get_optional_string(state, 1, "label");
+    Callback& callback = retain_callback(vm);
+    callback.refs[0] = ref_required_function(state, 1, "on_selected");
+    UiMenuTabDesc desc = UI_MENU_TAB_DESC_INIT;
+    desc.label = label.c_str();
+    desc.on_selected = menu_selected;
+    desc.user_data = &callback;
+    UiMenuTabHandle tab = 0;
+    check_result(state, svc_ui->register_menu_tab(vm.subject, &desc, &tab), "ui register_menu_tab");
+    push_ui_handle(state, vm, tab, HandleKind::UiMenuTab);
+    return 1;
+}
+
+int push_toast(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    luaL_checktype(state, 1, LUA_TTABLE);
+    const std::string type = get_optional_string(state, 1, "type");
+    const std::string title = get_optional_string(state, 1, "title_rml");
+    const std::string body = get_optional_string(state, 1, "body_rml");
+    UiToastDesc desc = UI_TOAST_DESC_INIT;
+    desc.type = type.empty() ? nullptr : type.c_str();
+    desc.title_rml = title.empty() ? nullptr : title.c_str();
+    desc.body_rml = body.empty() ? nullptr : body.c_str();
+    desc.duration_ms = static_cast<uint32_t>(get_optional_int(state, 1, "duration_ms", 0));
+    check_result(state, svc_ui->push_toast(vm.subject, &desc), "ui push_toast");
+    return 0;
+}
+
+int get_clipboard_text(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    size_t size = 0;
+    check_result(
+        state, svc_ui->get_clipboard_text(vm.subject, nullptr, 0, &size), "ui get_clipboard_text");
+    std::vector<char> text(size + 1);
+    check_result(state, svc_ui->get_clipboard_text(vm.subject, text.data(), text.size(), nullptr),
+        "ui get_clipboard_text");
+    lua_pushlstring(state, text.data(), size);
+    return 1;
+}
+
+int set_clipboard_text(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    check_result(state, svc_ui->set_clipboard_text(vm.subject, luaL_checkstring(state, 1)),
+        "ui set_clipboard_text");
+    return 0;
+}
+
+}  // namespace
+
+void push_ui_handle(lua_State* state, Vm& vm, uint64_t value, HandleKind kind) {
+    push_handle(state, vm, value, kind, ui_metatable(kind));
+}
+
+int open_ui(lua_State* state) {
+    Vm& vm = vm_from_upvalue(state);
+    if (svc_ui == nullptr) {
+        service_unavailable(state, "UiService");
+    }
+    static const luaL_Reg kElementMethods[] = {
+        {"add_section", pane_add_section},
+        {"add_text", pane_add_text},
+        {"add_rml", pane_add_rml},
+        {"add_progress", pane_add_progress},
+        {"add_control", pane_add_control},
+        {"add_group", pane_add_group},
+        {"add_list", pane_add_list},
+        {"set_text", element_set_text},
+        {"set_rml", element_set_rml},
+        {"set_progress", element_set_progress},
+        {"set_class", element_set_class},
+        {nullptr, nullptr},
+    };
+    static const luaL_Reg kWindowMethods[] = {{"close", window_close}, {nullptr, nullptr}};
+    static const luaL_Reg kDialogMethods[] = {
+        {"close", dialog_close},
+        {"set_body", dialog_set_body},
+        {"set_icon", dialog_set_icon},
+        {nullptr, nullptr},
+    };
+    static const luaL_Reg kStyleMethods[] = {{"unregister", style_unregister}, {nullptr, nullptr}};
+    static const luaL_Reg kMenuMethods[] = {
+        {"unregister", menu_tab_unregister}, {nullptr, nullptr}};
+    static const luaL_Reg kListMethods[] = {{"set_items", list_set_items}, {nullptr, nullptr}};
+    create_handle_metatable(state, kUiElementMetatable, kElementMethods, "UiElement");
+    create_handle_metatable(state, kUiWindowMetatable, kWindowMethods, "UiWindow");
+    create_handle_metatable(state, kUiDialogMetatable, kDialogMethods, "UiDialog");
+    create_handle_metatable(state, kUiStyleMetatable, kStyleMethods, "UiStyle");
+    create_handle_metatable(state, kUiMenuTabMetatable, kMenuMethods, "UiMenuTab");
+    create_handle_metatable(state, kUiListMetatable, kListMethods, "UiList");
+
+    lua_newtable(state);
+    set_function(state, vm, "register_mods_panel", register_mods_panel);
+    set_function(state, vm, "window_push", window_push);
+    set_function(state, vm, "dialog_push", dialog_push);
+    set_function(state, vm, "is_any_document_visible", is_any_document_visible);
+    set_function(state, vm, "register_styles", register_styles);
+    set_function(state, vm, "register_styles_file", register_styles_file);
+    set_function(state, vm, "register_menu_tab", register_menu_tab);
+    set_function(state, vm, "push_toast", push_toast);
+    set_function(state, vm, "get_clipboard_text", get_clipboard_text);
+    set_function(state, vm, "set_clipboard_text", set_clipboard_text);
+    lua_setreadonly(state, -1, true);
+    return 1;
+}
+
+}  // namespace luau_runtime
diff --git a/mods/randomizer b/mods/randomizer
new file mode 160000
index 0000000000..641c9c9e0b
--- /dev/null
+++ b/mods/randomizer
@@ -0,0 +1 @@
+Subproject commit 641c9c9e0bd04d51f9cb32e08daf7d134c65dcb1
diff --git a/mods/shadow_mod/CMakeLists.txt b/mods/shadow_mod/CMakeLists.txt
new file mode 100644
index 0000000000..3f2e6b9412
--- /dev/null
+++ b/mods/shadow_mod/CMakeLists.txt
@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.25)
+project(shadow_mod CXX)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(DUSK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../.." CACHE PATH "Path to dusk source root")
+    option(DUSK_MOD_USE_FULL_TREE "Use full build instead of the minimal mod SDK" OFF)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    if (DUSK_MOD_USE_FULL_TREE)
+        add_subdirectory("${DUSK_DIR}" dusk EXCLUDE_FROM_ALL)
+    else ()
+        add_subdirectory("${DUSK_DIR}/sdk" dusk-sdk EXCLUDE_FROM_ALL)
+    endif ()
+endif ()
+
+add_mod(shadow_mod
+    FEATURES game webgpu
+    SOURCES  src/mod.cpp
+    MOD_JSON mod.json
+    RES_DIR  res
+)
diff --git a/mods/shadow_mod/mod.json b/mods/shadow_mod/mod.json
new file mode 100644
index 0000000000..dadc790f29
--- /dev/null
+++ b/mods/shadow_mod/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "dev.twilitrealm.shadow_mod",
+  "name": "[Demo] Dynamic Shadows",
+  "version": "1.0.1",
+  "author": "encounter",
+  "description": "Demo showcasing dynamic shadow maps: re-renders geometry from the sun (or moon) point of view and composites real-time shadows over the world, with screen-space contact shadows for fine detail."
+}
diff --git a/mods/shadow_mod/res/shadow.wgsl b/mods/shadow_mod/res/shadow.wgsl
new file mode 100644
index 0000000000..fe69b5bc3a
--- /dev/null
+++ b/mods/shadow_mod/res/shadow.wgsl
@@ -0,0 +1,273 @@
+// Deferred shadow composite: reconstructs the world position of every scene pixel from the
+// depth snapshot (CameraService matrices), transforms it into the light's clip space, and
+// PCF-compares against the shadow map rendered earlier this frame. Drawn as a fullscreen
+// triangle with multiply blending (srcFactor = Dst, dstFactor = Zero) before the HUD.
+//
+// Depth conventions (both reversed-Z): the scene snapshot has 1.0 at the camera near plane;
+// the shadow map, rendered through the game's GX pipeline with a GC-convention light matrix,
+// stores clip.z, i.e. 1.0 nearest to the light and 0.0 at the light frustum far plane.
+//
+// The optional contact-shadow raymarch follows Panos Karabelas' screen-space shadows
+// (https://panoskarabelas.com/blog/posts/screen_space_shadows/, MIT via Spartan Engine):
+// march from the pixel toward the light in view space and mark occlusion when the ray dips
+// behind the depth buffer within a thickness threshold.
+
+struct Uniforms {
+    world_from_proj: mat4x4f, // scene depth unproject (camera)
+    view_from_proj: mat4x4f,  // scene depth -> view space (contact shadows)
+    proj_from_view: mat4x4f,  // view -> clip (contact shadows re-projection)
+    light_vp: mat4x4f,        // world -> light receiver projection (UV/depth basis)
+    light_dir_view: vec3f,    // direction *toward* the light, view space, normalized
+    bias: f32,                // shadow-map depth bias (reversed-depth units)
+    size: vec2f,              // shadow map size in texels
+    inv_size: vec2f,
+    edge_fade_width: f32,
+    strength: f32,            // final darkening amount, horizon fade baked in
+    pcf_taps: f32,            // 0 = single tap, 1 = 3x3, 2 = 5x5
+    contact_enabled: f32,
+    contact_thickness: f32,   // view-space thickness threshold
+    contact_length: f32,      // view-space march distance
+    debug_mode: u32,          // 0 = composite; nonzero modes are diagnostic views
+    _pad0: f32,
+}
+
+@group(0) @binding(0) var scene_depth: texture_2d<f32>;
+@group(0) @binding(1) var shadow_map: texture_2d<f32>;
+@group(0) @binding(2) var<uniform> uniforms: Uniforms;
+@group(0) @binding(3) var light_color: texture_2d<f32>;
+
+struct VertexOutput {
+    @builtin(position) position: vec4f,
+    @location(0) uv: vec2f,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) index: u32) -> VertexOutput {
+    var out: VertexOutput;
+    let uv = vec2f(f32((index << 1u) & 2u), f32(index & 2u));
+    out.position = vec4f(uv * vec2f(2.0, -2.0) + vec2f(-1.0, 1.0), 0.0, 1.0);
+    out.uv = uv;
+    return out;
+}
+
+fn load_shadow(texel: vec2<i32>) -> f32 {
+    let clamped = clamp(texel, vec2<i32>(0i), vec2<i32>(uniforms.size) - 1i);
+    return textureLoad(shadow_map, clamped, 0i).r;
+}
+
+// Returns 1.0 when the pixel at light-space depth `receiver` is shadowed by the map texel.
+fn shadow_test(texel: vec2<i32>, receiver: f32) -> f32 {
+    // Reversed depth: a larger stored value is closer to the light, i.e. an occluder.
+    return select(0.0, 1.0, load_shadow(texel) > receiver + uniforms.bias);
+}
+
+// Bilinearly weighted comparison (what a hardware comparison sampler would do): filter the
+// four *comparison results*, never the depths themselves. This is what turns per-texel
+// staircases into smooth penumbra edges.
+fn shadow_compare_bilinear(light_uv: vec2f, receiver: f32) -> f32 {
+    let coordinates = light_uv * uniforms.size - 0.5;
+    let base = floor(coordinates);
+    let fraction = coordinates - base;
+    let texel = vec2<i32>(base);
+    let s00 = shadow_test(texel, receiver);
+    let s10 = shadow_test(texel + vec2<i32>(1i, 0i), receiver);
+    let s01 = shadow_test(texel + vec2<i32>(0i, 1i), receiver);
+    let s11 = shadow_test(texel + vec2<i32>(1i, 1i), receiver);
+    let top = mix(s00, s10, fraction.x);
+    let bottom = mix(s01, s11, fraction.x);
+    return mix(top, bottom, fraction.y);
+}
+
+fn sample_shadow_pcf(light_uv: vec2f, receiver: f32) -> f32 {
+    let radius = i32(uniforms.pcf_taps);
+    var sum = 0.0;
+    var count = 0.0;
+    for (var y = -radius; y <= radius; y += 1i) {
+        for (var x = -radius; x <= radius; x += 1i) {
+            let offset = vec2f(f32(x), f32(y)) * uniforms.inv_size;
+            sum += shadow_compare_bilinear(light_uv + offset, receiver);
+            count += 1.0;
+        }
+    }
+    return sum / count;
+}
+
+// Softly fades shadows out over a small band near the shadow-map edge so receivers do not
+// disappear abruptly when they leave the light's coverage area.
+fn shadow_edge_fade(light_uv: vec2f) -> f32 {
+    let edge_texels = uniforms.edge_fade_width;
+    let edge_uv = edge_texels * max(uniforms.inv_size.x, uniforms.inv_size.y);
+    let distance_to_edge = min(min(light_uv.x, 1.0 - light_uv.x), min(light_uv.y, 1.0 - light_uv.y));
+    // Avoid division by zero when the fade width is zero (no fade).
+    return select(1.0, saturate(distance_to_edge / edge_uv), edge_uv > 0.0);
+}
+
+fn scene_depth_at(uv: vec2f) -> f32 {
+    let size = vec2<i32>(textureDimensions(scene_depth));
+    let texel = clamp(vec2<i32>(uv * vec2f(size)), vec2<i32>(0i), size - 1i);
+    return textureLoad(scene_depth, texel, 0i).r;
+}
+
+fn light_color_at(uv: vec2f) -> vec4f {
+    let size = vec2<i32>(textureDimensions(light_color));
+    let texel = clamp(vec2<i32>(uv * vec2f(size)), vec2<i32>(0i), size - 1i);
+    return textureLoad(light_color, texel, 0i);
+}
+
+fn light_depth_debug_at(uv: vec2f) -> vec3f {
+    let texel = vec2<i32>(uv * uniforms.size);
+    let depth = load_shadow(texel);
+    if depth <= 0.0 {
+        return vec3f(0.0);
+    }
+
+    let dx = abs(depth - load_shadow(texel + vec2<i32>(1i, 0i)));
+    let dy = abs(depth - load_shadow(texel + vec2<i32>(0i, 1i)));
+    let edge = saturate((dx + dy) * 500.0);
+    let shade = saturate(depth * 1.5);
+    let bands = 0.08 * (0.5 + 0.5 * cos(depth * 96.0));
+    return vec3f(saturate(shade + bands + edge));
+}
+
+fn view_position(uv: vec2f, depth: f32) -> vec3f {
+    let ndc = vec4f(uv.x * 2.0 - 1.0, 1.0 - 2.0 * uv.y, depth, 1.0);
+    let position = uniforms.view_from_proj * ndc;
+    return position.xyz / position.w;
+}
+
+// Interleaved gradient noise (Jimenez); fixed per-pixel dither, no temporal rotation.
+fn ign(pixel: vec2f) -> f32 {
+    return fract(52.9829189 * fract(dot(pixel, vec2f(0.06711056, 0.00583715))));
+}
+
+// Screen-space contact shadows: march toward the light in view space; occluded when the ray
+// passes behind the depth buffer by less than the thickness threshold. Faded out with view
+// distance: position reconstruction error grows with distance while the thickness threshold
+// is fixed, so far surfaces (and anything translucent composited over them - clouds, fog)
+// would otherwise pick up dithered false occlusion. Contact shadows are a near-field effect.
+fn contact_shadow_fade(view_distance: f32) -> f32 {
+    return saturate(1.0 - (view_distance - 3000.0) / 5000.0);
+}
+
+fn contact_shadow(origin: vec3f, pixel: vec2f) -> f32 {
+    let steps = 24;
+    let step_vec = uniforms.light_dir_view * (uniforms.contact_length / f32(steps));
+    var ray = origin + step_vec * ign(pixel);
+    for (var i = 0; i < steps; i += 1) {
+        ray += step_vec;
+        // Project the ray position back to screen space.
+        let clip = uniforms.proj_from_view * vec4f(ray, 1.0);
+        if clip.w <= 0.0 {
+            break;
+        }
+        let ray_ndc = clip.xyz / clip.w;
+        let ray_uv = vec2f(0.5 + 0.5 * ray_ndc.x, 0.5 - 0.5 * ray_ndc.y);
+        if any(ray_uv < vec2f(0.0)) || any(ray_uv > vec2f(1.0)) {
+            break;
+        }
+        let scene = scene_depth_at(ray_uv);
+        if scene <= 0.0 {
+            continue;
+        }
+        // Compare in view space: positive delta = the ray is behind the scene surface.
+        let scene_z = view_position(ray_uv, scene).z;
+        let delta = scene_z - ray.z; // view space looks down -z; larger z = closer
+        if delta > 0.0 && delta < uniforms.contact_thickness {
+            return 1.0;
+        }
+    }
+    return 0.0;
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4f {
+    let depth = scene_depth_at(in.uv);
+    if uniforms.debug_mode == 1u {
+        let value = load_shadow(vec2<i32>(in.uv * uniforms.size));
+        return vec4f(value, value, value, 1.0);
+    }
+    if uniforms.debug_mode == 9u || uniforms.debug_mode == 10u {
+        let color = light_color_at(in.uv);
+        let color_luma = max(color.r, max(color.g, color.b));
+        let depth_color = light_depth_debug_at(in.uv);
+        let rgb = select(depth_color, color.rgb, color_luma > (1.0 / 255.0));
+        return vec4f(rgb, 1.0);
+    }
+
+    if depth <= 0.0 {
+        // Sky / cleared pixels receive no shadow.
+        if uniforms.debug_mode >= 3u {
+            return vec4f(0.0, 0.0, 0.0, 1.0);
+        }
+        return vec4f(1.0);
+    }
+
+    let ndc = vec4f(in.uv.x * 2.0 - 1.0, 1.0 - 2.0 * in.uv.y, depth, 1.0);
+    let world4 = uniforms.world_from_proj * ndc;
+    let world = world4.xyz / world4.w;
+
+    let light_clip = uniforms.light_vp * vec4f(world, 1.0);
+    let light_ndc = light_clip.xyz / light_clip.w;
+    let receiver = light_ndc.z; // reversed light depth, 1 = nearest to the light
+    let light_uv = vec2f(0.5 + 0.5 * light_ndc.x, 0.5 - 0.5 * light_ndc.y);
+    let in_shadow_bounds = all(light_uv >= vec2f(0.0)) && all(light_uv <= vec2f(1.0)) &&
+        receiver > 0.0 && receiver <= 1.0;
+    let shadow_depth = load_shadow(vec2<i32>(light_uv * uniforms.size));
+
+    if uniforms.debug_mode == 4u {
+        let valid = select(0.0, 1.0, in_shadow_bounds);
+        return vec4f(saturate(light_uv.x), saturate(light_uv.y), valid, 1.0);
+    }
+
+    if uniforms.debug_mode == 5u {
+        if !in_shadow_bounds {
+            return vec4f(0.0, 0.0, 0.0, 1.0);
+        }
+        let current_compare = select(0.0, 1.0, shadow_depth > receiver + uniforms.bias);
+        let opposite_compare = select(0.0, 1.0, shadow_depth < receiver - uniforms.bias);
+        return vec4f(current_compare, 0.0, opposite_compare, 1.0);
+    }
+
+    if uniforms.debug_mode == 6u {
+        let valid = select(0.0, 1.0, in_shadow_bounds);
+        return vec4f(saturate(receiver), shadow_depth, valid, 1.0);
+    }
+
+    if uniforms.debug_mode == 7u {
+        let beyond_far = select(0.0, 1.0, receiver <= 0.0);
+        let valid_depth = select(0.0, 1.0, receiver > 0.0 && receiver <= 1.0);
+        let before_near = select(0.0, 1.0, receiver > 1.0);
+        return vec4f(beyond_far, valid_depth, before_near, 1.0);
+    }
+
+    if uniforms.debug_mode == 8u {
+        let valid_x = select(0.0, 1.0, light_uv.x >= 0.0 && light_uv.x <= 1.0);
+        let valid_y = select(0.0, 1.0, light_uv.y >= 0.0 && light_uv.y <= 1.0);
+        let valid_depth = select(0.0, 1.0, receiver > 0.0 && receiver <= 1.0);
+        return vec4f(valid_x, valid_y, valid_depth, 1.0);
+    }
+
+    var occlusion = 0.0;
+    if in_shadow_bounds {
+        occlusion = sample_shadow_pcf(light_uv, receiver);
+        occlusion *= shadow_edge_fade(light_uv);
+    }
+
+    if uniforms.debug_mode == 3u {
+        return vec4f(occlusion, occlusion, occlusion, 1.0);
+    }
+
+    if uniforms.contact_enabled != 0.0 && occlusion < 1.0 {
+        let origin = view_position(in.uv, depth);
+        let fade = contact_shadow_fade(-origin.z);
+        if fade > 0.0 {
+            occlusion = max(occlusion, fade * contact_shadow(origin, in.position.xy));
+        }
+    }
+
+    let value = 1.0 - uniforms.strength * occlusion;
+    if uniforms.debug_mode == 2u {
+        return vec4f(value, value, value, 1.0);
+    }
+    return vec4f(value, value, value, 1.0);
+}
diff --git a/mods/shadow_mod/src/mod.cpp b/mods/shadow_mod/src/mod.cpp
new file mode 100644
index 0000000000..fa4056040b
--- /dev/null
+++ b/mods/shadow_mod/src/mod.cpp
@@ -0,0 +1,1349 @@
+// Dynamic shadows example mod.
+//
+// Replays the game's populated opaque scene draw lists into an offscreen pass with a light-space
+// projection to produce a shadow map of the live scene, then composites deferred shadows over the
+// world (scene depth + CameraService unproject + PCF against the map).
+//
+// The optional contact-shadow raymarch in the composite is reimplemented from Panos Karabelas'
+// screen-space shadows (MIT, via Spartan Engine); see res/shadow.wgsl.
+
+#include "global.h"
+
+#include "JSystem/J3DGraphBase/J3DShape.h"
+#include "JSystem/J3DU/J3DUClipper.h"
+#include "JSystem/JMath/JMath.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_kankyo.h"
+#include "d/d_kankyo_rain.h"
+#include "dolphin/gx/GXAurora.h"
+#include "dolphin/gx/GXGet.h"
+#include "dolphin/gx/GXPixel.h"
+#include "dolphin/gx/GXTransform.h"
+#include "m_Do/m_Do_mtx.h"
+#include "mods/service.hpp"
+#include "mods/svc/camera.h"
+#include "mods/svc/config.h"
+#include "mods/svc/gfx.h"
+#include "mods/svc/hook.h"
+#include "mods/svc/hook.hpp"
+#include "mods/svc/log.h"
+#include "mods/svc/resource.h"
+#include "mods/svc/ui.h"
+#include "mods/svc/window.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <type_traits>
+#include <utility>
+#include <webgpu/webgpu.h>
+
+DEFINE_MOD();
+IMPORT_SERVICE(ConfigService, svc_config);
+IMPORT_SERVICE(ResourceService, svc_resource);
+IMPORT_SERVICE(UiService, svc_ui);
+IMPORT_SERVICE(GfxService, svc_gfx);
+IMPORT_SERVICE(CameraService, svc_camera);
+IMPORT_SERVICE(HookService, svc_hook);
+IMPORT_SERVICE(LogService, svc_log);
+IMPORT_SERVICE(WindowService, svc_window);
+
+namespace {
+
+ConfigVarHandle g_cvarEnabled = 0;
+ConfigVarHandle g_cvarMapSize = 0;
+ConfigVarHandle g_cvarNoFrustumClipping = 0;
+ConfigVarHandle g_cvarStrength = 0;
+ConfigVarHandle g_cvarPcf = 0;
+ConfigVarHandle g_cvarBias = 0;
+ConfigVarHandle g_cvarBoxRadius = 0;
+ConfigVarHandle g_cvarEdgeFadeWidth = 0;
+ConfigVarHandle g_cvarContactShadows = 0;
+ConfigVarHandle g_cvarDebugView = 0;
+
+GfxDrawTypeHandle g_drawType = 0;
+GfxStageHookHandle g_sceneBeginHook = 0;
+GfxStageHookHandle g_sceneAfterTerrainHook = 0;
+GfxStageHookHandle g_sceneAfterOpaqueHook = 0;
+GfxStageHookHandle g_frameBeforeHudHook = 0;
+UiWindowHandle g_controlsWindow = 0;
+ResourceBuffer g_shaderSource = RESOURCE_BUFFER_INIT;
+GfxDeviceInfo g_deviceInfo = GFX_DEVICE_INFO_INIT;
+GfxRenderTargetLayout g_sceneTargetLayout = GFX_RENDER_TARGET_LAYOUT_INIT;
+WGPURenderPipeline g_compositePipeline = nullptr;       // multiply blend
+WGPURenderPipeline g_compositeDebugPipeline = nullptr;  // no blend (debug views)
+WGPUBindGroupLayout g_compositeLayout = nullptr;
+WGPUBindGroupLayout g_compositeDebugLayout = nullptr;
+WGPURenderPipeline g_debugPresentPipeline = nullptr;
+WGPUBindGroupLayout g_debugPresentLayout = nullptr;
+WGPUTextureFormat g_debugPresentFormat = WGPUTextureFormat_Undefined;
+WindowHandle g_debugWindow = 0;
+GfxPresentTargetHandle g_debugPresentTarget = 0;
+
+struct MapPassOutput {
+    bool ready = false;
+    WGPUTextureView shadowMap = nullptr;   // frame-pooled
+    WGPUTextureView lightColor = nullptr;  // frame-pooled
+    uint32_t mapSize = 0;
+    Mtx44 lightVp;             // world -> light receiver projection, row-major game convention
+    float dirToLightWorld[3];  // toward the light, normalized
+    float fade = 0.0f;
+};
+
+MapPassOutput g_mapPass;
+bool g_replayingSceneLists = false;
+
+constexpr float kLightDistance = 30000.0f;
+constexpr float kLightNear = 100.0f;
+constexpr float kLightFar = 60000.0f;
+constexpr float kMaxLightLookahead = 10000.0f;
+constexpr float kSunMoonDistance = 80000.0f;
+constexpr float kSunMoonZDistance = -48000.0f;
+
+DEFINE_HOOK(&dDlst_shadowControl_c::imageDraw, GameShadowImageDraw);
+DEFINE_HOOK(&dDlst_shadowControl_c::draw, GameShadowDraw);
+DEFINE_HOOK(&drawCloudShadow, CloudShadowDraw);
+DEFINE_HOOK(static_cast<int (J3DUClipper::*)(f32 const (*)[4], Vec, f32) const>(&J3DUClipper::clip),
+    ClipperSphereClip);
+DEFINE_HOOK(
+    static_cast<int (J3DUClipper::*)(f32 const (*)[4], Vec*, Vec*) const>(&J3DUClipper::clip),
+    ClipperBoxClip);
+DEFINE_HOOK(GXCopyTex, CopyTex);
+
+// Mirror of the WGSL Uniforms struct (keep in sync with res/shadow.wgsl).
+struct ShadowUniforms {
+    float world_from_proj[16];
+    float view_from_proj[16];
+    float proj_from_view[16];
+    float light_vp[16];
+    float light_dir_view[3];
+    float bias;
+    float size[2];
+    float inv_size[2];
+    float edge_fade_width;
+    float strength;
+    float pcf_taps;
+    float contact_enabled;
+    float contact_thickness;
+    float contact_length;
+    uint32_t debug_mode;
+    float _pad0;
+};
+static_assert(sizeof(ShadowUniforms) % 16 == 0);
+
+struct DrawPayload {
+    WGPUTextureView sceneDepth;  // frame-pooled
+    WGPUTextureView shadowMap;   // frame-pooled
+    WGPUTextureView lightColor;  // frame-pooled
+    uint32_t uniform_offset;
+    uint32_t uniform_size;
+    uint32_t debug_mode;
+};
+static_assert(sizeof(DrawPayload) <= GFX_INLINE_DRAW_PAYLOAD_SIZE);
+static_assert(std::is_trivially_copyable_v<DrawPayload>);
+
+struct LightCamera {
+    Mtx view;
+    Mtx44 ortho;
+    Mtx44 vp;
+    float dirToLight[3];
+    float fade = 0.0f;
+};
+
+struct SceneCamera {
+    bool valid = false;
+    bool raw_valid = false;
+    CameraInfo info = CAMERA_INFO_INIT;
+    Mtx raw_view;
+    f32 raw_projection[7]{};
+    Mtx44 raw_projection_mtx;
+};
+
+SceneCamera g_sceneCamera;
+
+struct ActualLightDebugState {
+    bool active = false;
+    Mtx savedView;
+    f32 savedProjection[7];
+    f32 savedViewport[6];
+    u32 savedScissor[4];
+};
+
+ActualLightDebugState g_actualLightDebug;
+
+struct replay_scope {
+    replay_scope() { g_replayingSceneLists = true; }
+    ~replay_scope() { g_replayingSceneLists = false; }
+};
+
+int64_t get_int_option(ConfigVarHandle handle, int64_t fallback) {
+    int64_t value = fallback;
+    if (handle == 0 || svc_config->get_int(mod_ctx, handle, &value) != MOD_OK) {
+        return fallback;
+    }
+    return value;
+}
+
+bool get_bool_option(ConfigVarHandle handle, bool fallback) {
+    bool value = fallback;
+    if (handle == 0 || svc_config->get_bool(mod_ctx, handle, &value) != MOD_OK) {
+        return fallback;
+    }
+    return value;
+}
+
+int64_t get_debug_mode() {
+    return std::clamp<int64_t>(get_int_option(g_cvarDebugView, 0), 0, 10);
+}
+
+bool debug_window_open() {
+    return g_debugWindow != 0 && g_debugPresentTarget != 0;
+}
+
+ModResult close_debug_window() {
+    if (g_debugPresentTarget != 0) {
+        const auto result = svc_gfx->unregister_present_target(mod_ctx, g_debugPresentTarget);
+        if (result != MOD_OK) {
+            return result;
+        }
+        g_debugPresentTarget = 0;
+    }
+    if (g_debugWindow != 0) {
+        const auto result = svc_window->destroy_window(mod_ctx, g_debugWindow);
+        if (result != MOD_OK) {
+            return result;
+        }
+        g_debugWindow = 0;
+    }
+    return MOD_OK;
+}
+
+void on_debug_window_event(ModContext*, WindowHandle, const WindowEvent* event, void*) {
+    if (event->type == WINDOW_EVENT_CLOSE_REQUESTED && close_debug_window() != MOD_OK) {
+        svc_log->error(mod_ctx, "failed to close shadow debug window");
+    }
+}
+
+bool matrix_ready(const Mtx m) {
+    float basis = 0.0f;
+    for (int r = 0; r < 3; ++r) {
+        for (int c = 0; c < 4; ++c) {
+            if (!std::isfinite(m[r][c])) {
+                return false;
+            }
+            if (c < 3) {
+                basis += std::fabs(m[r][c]);
+            }
+        }
+    }
+    return basis > 0.001f;
+}
+
+bool projection_vector_ready(const f32 projection[7]) {
+    if (projection[0] != 0.0f) {
+        return false;
+    }
+    for (int i = 1; i < 7; ++i) {
+        if (!std::isfinite(projection[i])) {
+            return false;
+        }
+    }
+    return std::fabs(projection[1]) > 0.001f && std::fabs(projection[3]) > 0.001f &&
+           std::fabs(projection[6]) > 0.001f;
+}
+
+// Row-major game matrix -> column-major WGSL layout (matching CameraService).
+void store_column_major(const Mtx44 in, float out[16]) {
+    for (int c = 0; c < 4; ++c) {
+        for (int r = 0; r < 4; ++r) {
+            out[c * 4 + r] = in[r][c];
+        }
+    }
+}
+
+void copy_projection(const Mtx44 in, Mtx44 out) {
+    std::memcpy(out, in, sizeof(Mtx44));
+    // TODO: check GfxDeviceInfo.uses_reversed_z
+    for (int c = 0; c < 4; ++c) {
+        out[2][c] = -out[2][c];
+    }
+}
+
+void projection_vector_from_perspective(const Mtx44 projection, f32 out[7]) {
+    out[0] = 0.0f;
+    out[1] = projection[0][0];
+    out[2] = projection[0][2];
+    out[3] = projection[1][1];
+    out[4] = projection[1][2];
+    out[5] = projection[2][2];
+    out[6] = projection[2][3];
+}
+
+const view_class* stage_game_view(const GfxStageContext* stageCtx) {
+    if (stageCtx == nullptr || stageCtx->struct_size < sizeof(GfxStageContext) ||
+        stageCtx->game_view == nullptr)
+    {
+        return nullptr;
+    }
+    return static_cast<const view_class*>(stageCtx->game_view);
+}
+
+bool capture_raw_camera(
+    const view_class* gameView, Mtx outView, Mtx44 outProjectionMtx, f32 outProjection[7]) {
+    if (gameView == nullptr || !matrix_ready(gameView->viewMtx)) {
+        return false;
+    }
+    std::memcpy(outProjectionMtx, gameView->projMtx, sizeof(Mtx44));
+    projection_vector_from_perspective(outProjectionMtx, outProjection);
+    if (!projection_vector_ready(outProjection)) {
+        return false;
+    }
+    cMtx_copy(gameView->viewMtx, outView);
+    return true;
+}
+
+bool capture_scene_camera(const GfxStageContext* stageCtx) {
+    g_sceneCamera.valid = false;
+    g_sceneCamera.raw_valid = false;
+    const view_class* gameView = stage_game_view(stageCtx);
+    if (gameView == nullptr) {
+        return false;
+    }
+    CameraInfo info = CAMERA_INFO_INIT;
+    if (svc_camera->get_camera(mod_ctx, stageCtx->game_view, &info) != MOD_OK) {
+        return false;
+    }
+    g_sceneCamera.info = info;
+    g_sceneCamera.valid = true;
+    g_sceneCamera.raw_valid = capture_raw_camera(gameView, g_sceneCamera.raw_view,
+        g_sceneCamera.raw_projection_mtx, g_sceneCamera.raw_projection);
+    return true;
+}
+
+bool get_replay_camera(Mtx outView, Mtx44 outProjectionMtx, f32 outProjection[7]) {
+    if (g_sceneCamera.raw_valid && matrix_ready(g_sceneCamera.raw_view)) {
+        cMtx_copy(g_sceneCamera.raw_view, outView);
+        std::memcpy(outProjectionMtx, g_sceneCamera.raw_projection_mtx,
+            sizeof(g_sceneCamera.raw_projection_mtx));
+        std::memcpy(
+            outProjection, g_sceneCamera.raw_projection, sizeof(g_sceneCamera.raw_projection));
+        return projection_vector_ready(outProjection);
+    }
+
+    return false;
+}
+
+float wrap_daytime(float daytime) {
+    if (!std::isfinite(daytime)) {
+        return 180.0f;
+    }
+    float wrapped = std::fmod(daytime, 360.0f);
+    if (wrapped < 0.0f) {
+        wrapped += 360.0f;
+    }
+    return wrapped;
+}
+
+float daytime_percent(float max, float min, float value) {
+    const float range = max - min;
+    if (range == 0.0f) {
+        return 1.0f;
+    }
+    const float percent = 1.0f - ((max - value) / range);
+    return percent < 1.0f ? percent : 1.0f;
+}
+
+float sun_moon_angle(float daytime) {
+    daytime = wrap_daytime(daytime);
+    if (daytime >= 90.0f && daytime <= 270.0f) {
+        return daytime_percent(270.0f, 90.0f, daytime) * 150.0f + 105.0f;
+    }
+
+    float angle = daytime;
+    if (angle < 90.0f) {
+        angle += 360.0f;
+    }
+
+    angle = daytime_percent(450.0f, 270.0f, angle) * 210.0f + 255.0f;
+    if (angle > 360.0f) {
+        angle -= 360.0f;
+    }
+    return angle;
+}
+
+cXyz sun_moon_offset(float daytime) {
+    const float angle = DEG_TO_RAD(sun_moon_angle(daytime));
+    const float angleSin = sinf(angle);
+    const float angleCos = cosf(angle);
+    return cXyz{
+        angleSin * kSunMoonDistance, -angleCos * kSunMoonDistance, angleCos * kSunMoonZDistance};
+}
+
+bool build_composite_pipeline(
+    bool blend, WGPURenderPipeline& outPipeline, WGPUBindGroupLayout& outLayout) {
+    WGPUShaderSourceWGSL wgsl = WGPU_SHADER_SOURCE_WGSL_INIT;
+    wgsl.code = {static_cast<const char*>(g_shaderSource.data), g_shaderSource.size};
+    WGPUShaderModuleDescriptor moduleDesc = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
+    moduleDesc.nextInChain = &wgsl.chain;
+    moduleDesc.label = {"shadow composite", WGPU_STRLEN};
+    WGPUShaderModule module = wgpuDeviceCreateShaderModule(g_deviceInfo.device, &moduleDesc);
+    if (module == nullptr) {
+        return false;
+    }
+
+    // Multiply blend: fragment output is the darkening multiplier (result = dst * src).
+    WGPUBlendState blendState{
+        .color = {.operation = WGPUBlendOperation_Add,
+            .srcFactor = WGPUBlendFactor_Dst,
+            .dstFactor = WGPUBlendFactor_Zero},
+        .alpha = {.operation = WGPUBlendOperation_Add,
+            .srcFactor = WGPUBlendFactor_Zero,
+            .dstFactor = WGPUBlendFactor_One},
+    };
+    WGPUColorTargetState colorTargets[GFX_MAX_COLOR_ATTACHMENTS];
+    const uint32_t colorTargetCount = gfx_init_color_target_states(
+        &g_sceneTargetLayout, colorTargets, blend ? &blendState : nullptr, WGPUColorWriteMask_All);
+    WGPUFragmentState fragment = WGPU_FRAGMENT_STATE_INIT;
+    fragment.module = module;
+    fragment.entryPoint = {"fs_main", WGPU_STRLEN};
+    fragment.targetCount = colorTargetCount;
+    fragment.targets = colorTargets;
+    WGPUDepthStencilState depthStencil = WGPU_DEPTH_STENCIL_STATE_INIT;
+    depthStencil.format = g_sceneTargetLayout.depth_stencil_format;
+    depthStencil.depthWriteEnabled = WGPUOptionalBool_False;
+    depthStencil.depthCompare = WGPUCompareFunction_Always;
+
+    WGPURenderPipelineDescriptor pipelineDesc = WGPU_RENDER_PIPELINE_DESCRIPTOR_INIT;
+    pipelineDesc.label = {blend ? "shadow composite" : "shadow composite (debug)", WGPU_STRLEN};
+    pipelineDesc.vertex.module = module;
+    pipelineDesc.vertex.entryPoint = {"vs_main", WGPU_STRLEN};
+    pipelineDesc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+    pipelineDesc.depthStencil = &depthStencil;
+    pipelineDesc.multisample.count = g_sceneTargetLayout.sample_count;
+    pipelineDesc.fragment = &fragment;
+    outPipeline = wgpuDeviceCreateRenderPipeline(g_deviceInfo.device, &pipelineDesc);
+    wgpuShaderModuleRelease(module);
+    if (outPipeline == nullptr) {
+        return false;
+    }
+    outLayout = wgpuRenderPipelineGetBindGroupLayout(outPipeline, 0);
+    return outLayout != nullptr;
+}
+
+void release_debug_present_pipeline() {
+    if (g_debugPresentPipeline != nullptr) {
+        wgpuRenderPipelineRelease(g_debugPresentPipeline);
+        g_debugPresentPipeline = nullptr;
+    }
+    if (g_debugPresentLayout != nullptr) {
+        wgpuBindGroupLayoutRelease(g_debugPresentLayout);
+        g_debugPresentLayout = nullptr;
+    }
+    g_debugPresentFormat = WGPUTextureFormat_Undefined;
+}
+
+bool ensure_debug_present_pipeline(const GfxPresentContext& ctx) {
+    if (g_debugPresentPipeline != nullptr && g_debugPresentFormat == ctx.target_format) {
+        return true;
+    }
+    release_debug_present_pipeline();
+
+    WGPUShaderSourceWGSL wgsl = WGPU_SHADER_SOURCE_WGSL_INIT;
+    wgsl.code = {static_cast<const char*>(g_shaderSource.data), g_shaderSource.size};
+    WGPUShaderModuleDescriptor moduleDesc = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
+    moduleDesc.nextInChain = &wgsl.chain;
+    moduleDesc.label = {"shadow debug present", WGPU_STRLEN};
+    WGPUShaderModule module = wgpuDeviceCreateShaderModule(ctx.device, &moduleDesc);
+    if (module == nullptr) {
+        return false;
+    }
+
+    WGPUColorTargetState colorTarget = WGPU_COLOR_TARGET_STATE_INIT;
+    colorTarget.format = ctx.target_format;
+    WGPUFragmentState fragment = WGPU_FRAGMENT_STATE_INIT;
+    fragment.module = module;
+    fragment.entryPoint = {"fs_main", WGPU_STRLEN};
+    fragment.targetCount = 1;
+    fragment.targets = &colorTarget;
+
+    WGPURenderPipelineDescriptor pipelineDesc = WGPU_RENDER_PIPELINE_DESCRIPTOR_INIT;
+    pipelineDesc.label = {"shadow debug present", WGPU_STRLEN};
+    pipelineDesc.vertex.module = module;
+    pipelineDesc.vertex.entryPoint = {"vs_main", WGPU_STRLEN};
+    pipelineDesc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+    pipelineDesc.multisample.count = 1;
+    pipelineDesc.fragment = &fragment;
+    g_debugPresentPipeline = wgpuDeviceCreateRenderPipeline(ctx.device, &pipelineDesc);
+    wgpuShaderModuleRelease(module);
+    if (g_debugPresentPipeline == nullptr) {
+        return false;
+    }
+    g_debugPresentLayout = wgpuRenderPipelineGetBindGroupLayout(g_debugPresentPipeline, 0);
+    if (g_debugPresentLayout == nullptr) {
+        release_debug_present_pipeline();
+        return false;
+    }
+    g_debugPresentFormat = ctx.target_format;
+    return true;
+}
+
+WGPUBindGroup create_composite_bind_group(WGPUDevice device, WGPUBindGroupLayout layout,
+    WGPUBuffer uniformBuffer, const DrawPayload& data) {
+    if (data.sceneDepth == nullptr || data.shadowMap == nullptr || data.lightColor == nullptr ||
+        layout == nullptr || uniformBuffer == nullptr)
+    {
+        return nullptr;
+    }
+
+    WGPUBindGroupEntry entries[4] = {WGPU_BIND_GROUP_ENTRY_INIT, WGPU_BIND_GROUP_ENTRY_INIT,
+        WGPU_BIND_GROUP_ENTRY_INIT, WGPU_BIND_GROUP_ENTRY_INIT};
+    entries[0].binding = 0;
+    entries[0].textureView = data.sceneDepth;
+    entries[1].binding = 1;
+    entries[1].textureView = data.shadowMap;
+    entries[2].binding = 2;
+    entries[2].buffer = uniformBuffer;
+    entries[2].offset = data.uniform_offset;
+    entries[2].size = data.uniform_size;
+    entries[3].binding = 3;
+    entries[3].textureView = data.lightColor;
+    WGPUBindGroupDescriptor bindGroupDesc = WGPU_BIND_GROUP_DESCRIPTOR_INIT;
+    bindGroupDesc.layout = layout;
+    bindGroupDesc.entryCount = 4;
+    bindGroupDesc.entries = entries;
+    return wgpuDeviceCreateBindGroup(device, &bindGroupDesc);
+}
+
+// Render worker thread: fullscreen deferred-shadow composite.
+void on_draw(
+    ModContext*, const GfxDrawContext* ctx, const void* payload, size_t payloadSize, void*) {
+    if (payloadSize != sizeof(DrawPayload) || ctx->layout.key != g_sceneTargetLayout.key) {
+        return;
+    }
+    DrawPayload data;
+    std::memcpy(&data, payload, sizeof(data));
+
+    WGPURenderPipeline pipeline =
+        data.debug_mode != 0 ? g_compositeDebugPipeline : g_compositePipeline;
+    WGPUBindGroupLayout layout = data.debug_mode != 0 ? g_compositeDebugLayout : g_compositeLayout;
+    if (pipeline == nullptr) {
+        return;
+    }
+
+    WGPUBindGroup bindGroup =
+        create_composite_bind_group(ctx->device, layout, ctx->uniform_buffer, data);
+    if (bindGroup == nullptr) {
+        return;
+    }
+
+    wgpuRenderPassEncoderSetPipeline(ctx->pass, pipeline);
+    wgpuRenderPassEncoderSetBindGroup(ctx->pass, 0, bindGroup, 0, nullptr);
+    wgpuRenderPassEncoderDraw(ctx->pass, 3, 1, 0, 0);
+    wgpuBindGroupRelease(bindGroup);
+}
+
+// Render worker thread: draw the selected diagnostic into the auxiliary surface.
+void on_debug_present(
+    ModContext*, const GfxPresentContext* ctx, const void* payload, size_t payloadSize, void*) {
+    WGPUBindGroup bindGroup = nullptr;
+    if (payloadSize == sizeof(DrawPayload)) {
+        DrawPayload data;
+        std::memcpy(&data, payload, sizeof(data));
+        if (ensure_debug_present_pipeline(*ctx)) {
+            bindGroup = create_composite_bind_group(
+                ctx->device, g_debugPresentLayout, ctx->uniform_buffer, data);
+        }
+    }
+
+    WGPURenderPassColorAttachment colorAttachment = WGPU_RENDER_PASS_COLOR_ATTACHMENT_INIT;
+    colorAttachment.view = ctx->target_view;
+    colorAttachment.loadOp = WGPULoadOp_Clear;
+    colorAttachment.storeOp = WGPUStoreOp_Store;
+    colorAttachment.clearValue = WGPUColor{0.0, 0.0, 0.0, 1.0};
+    WGPURenderPassDescriptor passDesc = WGPU_RENDER_PASS_DESCRIPTOR_INIT;
+    passDesc.label = {"shadow debug present", WGPU_STRLEN};
+    passDesc.colorAttachmentCount = 1;
+    passDesc.colorAttachments = &colorAttachment;
+    WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(ctx->encoder, &passDesc);
+
+    if (bindGroup != nullptr) {
+        wgpuRenderPassEncoderSetPipeline(pass, g_debugPresentPipeline);
+        wgpuRenderPassEncoderSetBindGroup(pass, 0, bindGroup, 0, nullptr);
+        wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0);
+        wgpuBindGroupRelease(bindGroup);
+    }
+
+    wgpuRenderPassEncoderEnd(pass);
+    wgpuRenderPassEncoderRelease(pass);
+}
+
+ModResult open_debug_window() {
+    if (g_debugWindow != 0) {
+        return MOD_CONFLICT;
+    }
+
+    WindowDesc windowDesc = WINDOW_DESC_INIT;
+    windowDesc.title = "Shadow Debug View";
+    windowDesc.width = 720;
+    windowDesc.height = 480;
+    windowDesc.on_event = on_debug_window_event;
+    auto result = svc_window->create_window(mod_ctx, &windowDesc, &g_debugWindow);
+    if (result != MOD_OK) {
+        return result;
+    }
+
+    GfxPresentTargetDesc presentDesc = GFX_PRESENT_TARGET_DESC_INIT;
+    presentDesc.label = "Shadow debug surface";
+    presentDesc.render = on_debug_present;
+    result = svc_gfx->register_window_present_target(
+        mod_ctx, g_debugWindow, &presentDesc, &g_debugPresentTarget);
+    if (result != MOD_OK) {
+        close_debug_window();
+        return result;
+    }
+
+    result = svc_window->show_window(mod_ctx, g_debugWindow);
+    if (result != MOD_OK) {
+        close_debug_window();
+    }
+    return result;
+}
+
+void on_toggle_debug_window(ModContext*, void*) {
+    const auto result = debug_window_open() ? close_debug_window() : open_debug_window();
+    if (result != MOD_OK) {
+        svc_log->error(mod_ctx, debug_window_open() ? "failed to close shadow debug window" :
+                                                      "failed to open shadow debug window");
+    }
+}
+
+// Picks the sun or moon (whichever is above the horizon) and returns the normalized
+// world-space direction *toward* the light plus a horizon fade factor. False = no light.
+bool compute_light(float outDirToLight[3], float& outFade) {
+    dScnKy_env_light_c* envLight = dKy_getEnvlight();
+    if (envLight == nullptr) {
+        return false;
+    }
+
+    // The packet positions can be stale when this runs before the world lists are consumed.
+    // Mirror dScnKy_env_light_c::setSunpos() so --time-of-day directly moves the debug light.
+    const float daytime = wrap_daytime(dComIfGs_getTime());
+    cXyz offset = sun_moon_offset(daytime);
+    if (offset.y <= 0.0f) {
+        offset = sun_moon_offset(daytime + 180.0f);
+    }
+    const float length = std::sqrt(offset.x * offset.x + offset.y * offset.y + offset.z * offset.z);
+    if (length < 1.0f) {
+        return false;
+    }
+    outDirToLight[0] = offset.x / length;
+    outDirToLight[1] = offset.y / length;
+    outDirToLight[2] = offset.z / length;
+    // Fade shadows out as the light approaches the horizon (elevation below ~11 degrees).
+    outFade = std::clamp((outDirToLight[1] - 0.05f) / 0.15f, 0.0f, 1.0f);
+    return outFade > 0.0f;
+}
+
+bool build_light_camera(const Mtx cameraView, uint32_t mapSize, float radius, LightCamera& out) {
+    Mtx cameraInvView;
+    cMtx_inverse(cameraView, cameraInvView);
+    if (!matrix_ready(cameraInvView)) {
+        return false;
+    }
+    if (!compute_light(out.dirToLight, out.fade)) {
+        return false;
+    }
+
+    // Fit a fixed-radius ortho box around the visible play space. The camera target alone can sit
+    // behind the receiver field, while a far-horizon center drops foreground receivers.
+    const cXyz eye{cameraInvView[0][3], cameraInvView[1][3], cameraInvView[2][3]};
+    cXyz forward{-cameraInvView[0][2], -cameraInvView[1][2], -cameraInvView[2][2]};
+    const float forwardLength =
+        std::sqrt(forward.x * forward.x + forward.y * forward.y + forward.z * forward.z);
+    if (forwardLength > 0.001f) {
+        forward = forward / forwardLength;
+    } else {
+        forward = cXyz{0.0f, 0.0f, -1.0f};
+    }
+    const float lookahead = std::min(radius * 0.75f, kMaxLightLookahead);
+    const cXyz center = eye + forward * lookahead;
+    const cXyz lightEye{center.x + out.dirToLight[0] * kLightDistance,
+        center.y + out.dirToLight[1] * kLightDistance,
+        center.z + out.dirToLight[2] * kLightDistance};
+    const bool nearlyVertical = std::fabs(out.dirToLight[1]) > 0.99f;
+    cXyz up = nearlyVertical ? cXyz{0.0f, 0.0f, 1.0f} : cXyz{0.0f, 1.0f, 0.0f};
+
+    cMtx_lookAt(out.view, &lightEye, &center, &up, 0);
+    const float unitsPerTexel = (2.0f * radius) / static_cast<float>(mapSize);
+    out.view[0][3] = std::round(out.view[0][3] / unitsPerTexel) * unitsPerTexel;
+    out.view[1][3] = std::round(out.view[1][3] / unitsPerTexel) * unitsPerTexel;
+
+    C_MTXOrtho(out.ortho, radius, -radius, -radius, radius, kLightNear, kLightFar);
+    cMtx_concatProjView(out.ortho, out.view, out.vp);
+    return true;
+}
+
+bool build_light_replay_projection(
+    const LightCamera& lightCamera, const Mtx cameraView, Mtx44 out) {
+    Mtx cameraInvView;
+    cMtx_inverse(cameraView, cameraInvView);
+    if (!matrix_ready(cameraInvView)) {
+        return false;
+    }
+
+    Mtx lightFromCamera;
+    cMtx_concat(lightCamera.view, cameraInvView, lightFromCamera);
+    cMtx_concatProjView(lightCamera.ortho, lightFromCamera, out);
+    return true;
+}
+
+// True when the dynamic shadow pass will run this frame: enabled, a camera exists, and the
+// sun or moon is above the horizon. Also gates the game-shadow skip hooks, which fire earlier
+// in the painter than our SCENE_AFTER_TERRAIN hook.
+bool dynamic_shadows_wanted() {
+    if (!get_bool_option(g_cvarEnabled, true)) {
+        return false;
+    }
+    if (!g_sceneCamera.raw_valid) {
+        return false;
+    }
+    float dirToLight[3];
+    float fade = 0.0f;
+    return compute_light(dirToLight, fade);
+}
+
+HookAction on_game_shadow_pre(ModContext*, void*, void*, void*) {
+    if (!dynamic_shadows_wanted()) {
+        return HOOK_CONTINUE;
+    }
+    return HOOK_SKIP_ORIGINAL;
+}
+
+HookAction on_frustum_clip_pre(ModContext*, void*, void* retval, void*) {
+    if (!get_bool_option(g_cvarNoFrustumClipping, false) || !dynamic_shadows_wanted()) {
+        return HOOK_CONTINUE;
+    }
+    if (retval != nullptr) {
+        *static_cast<int*>(retval) = 0;
+    }
+    return HOOK_SKIP_ORIGINAL;
+}
+
+HookAction on_copy_tex_pre(ModContext*, void*, void*, void*) {
+    return g_replayingSceneLists ? HOOK_SKIP_ORIGINAL : HOOK_CONTINUE;
+}
+
+void draw_opaque_scene_lists() {
+    dComIfGd_drawOpaListBG();
+    dComIfGd_drawOpaListDarkBG();
+    dComIfGd_drawOpaListMiddle();
+    dComIfGd_drawOpaList();
+    dComIfGd_drawOpaListDark();
+    dComIfGd_drawOpaListPacket();
+}
+
+bool draw_lists_ready() {
+    return dComIfGd_getOpaListBG() != nullptr && dComIfGd_getOpaList() != nullptr &&
+           dComIfGd_getOpaListDark() != nullptr && dComIfGd_getXluListBG() != nullptr &&
+           dComIfGd_getListPacket() != nullptr;
+}
+
+void render_shadow_map(
+    const Mtx replayView, const Mtx44 replayProjectionMtx, const f32 replayProjection[7]);
+
+void restore_actual_light_debug() {
+    if (!g_actualLightDebug.active) {
+        return;
+    }
+
+    j3dSys.setViewMtx(g_actualLightDebug.savedView);
+    GXSetProjectionv(g_actualLightDebug.savedProjection);
+    GXSetViewport(g_actualLightDebug.savedViewport[0], g_actualLightDebug.savedViewport[1],
+        g_actualLightDebug.savedViewport[2], g_actualLightDebug.savedViewport[3],
+        g_actualLightDebug.savedViewport[4], g_actualLightDebug.savedViewport[5]);
+    GXSetScissor(g_actualLightDebug.savedScissor[0], g_actualLightDebug.savedScissor[1],
+        g_actualLightDebug.savedScissor[2], g_actualLightDebug.savedScissor[3]);
+    dKy_setLight();
+    J3DShape::resetVcdVatCache();
+
+    g_actualLightDebug.active = false;
+}
+
+void on_scene_begin(ModContext*, const GfxStageContext* stageCtx, void*) {
+    restore_actual_light_debug();
+    capture_scene_camera(stageCtx);
+    if (!get_bool_option(g_cvarEnabled, true) || get_debug_mode() != 9 || debug_window_open()) {
+        return;
+    }
+
+    Mtx cameraView;
+    if (!g_sceneCamera.raw_valid || !matrix_ready(g_sceneCamera.raw_view)) {
+        return;
+    }
+    cMtx_copy(g_sceneCamera.raw_view, cameraView);
+
+    const uint32_t mapSize = 1024u << std::clamp<int64_t>(get_int_option(g_cvarMapSize, 1), 0, 2);
+    const float radius =
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarBoxRadius, 6000), 1000, 20000));
+    LightCamera lightCamera{};
+    if (!build_light_camera(cameraView, mapSize, radius, lightCamera)) {
+        return;
+    }
+    Mtx44 lightProjection;
+    if (!build_light_replay_projection(lightCamera, cameraView, lightProjection)) {
+        return;
+    }
+
+    cMtx_copy(cameraView, g_actualLightDebug.savedView);
+    GXGetProjectionv(g_actualLightDebug.savedProjection);
+    GXGetViewportv(g_actualLightDebug.savedViewport);
+    GXGetScissor(&g_actualLightDebug.savedScissor[0], &g_actualLightDebug.savedScissor[1],
+        &g_actualLightDebug.savedScissor[2], &g_actualLightDebug.savedScissor[3]);
+    g_actualLightDebug.active = true;
+
+    j3dSys.setViewMtx(g_actualLightDebug.savedView);
+    GXSetProjectionFull(lightProjection);
+    dKy_setLight();
+    J3DShape::resetVcdVatCache();
+}
+
+void on_scene_after_terrain(ModContext*, const GfxStageContext* stageCtx, void*) {
+    if (g_mapPass.ready) {
+        return;
+    }
+
+    const view_class* gameView = stage_game_view(stageCtx);
+    Mtx replayView;
+    Mtx44 replayProjectionMtx;
+    f32 replayProjection[7];
+    if (!capture_raw_camera(gameView, replayView, replayProjectionMtx, replayProjection)) {
+        return;
+    }
+    render_shadow_map(replayView, replayProjectionMtx, replayProjection);
+}
+
+// Game thread, after the draw handlers have populated next frame's scene lists: replay opaque scene
+// geometry from the light's point of view.
+void render_shadow_map(
+    const Mtx replayView, const Mtx44 replayProjectionMtx, const f32 replayProjection[7]) {
+    if (g_mapPass.ready || !get_bool_option(g_cvarEnabled, true)) {
+        return;
+    }
+    const int64_t debugMode = get_debug_mode();
+    if (debugMode == 9 && !debug_window_open()) {
+        return;
+    }
+    if (!matrix_ready(replayView)) {
+        return;
+    }
+    Mtx replayViewMtx;
+    cMtx_copy(replayView, replayViewMtx);
+
+    const uint32_t mapSize = 1024u << std::clamp<int64_t>(get_int_option(g_cvarMapSize, 1), 0, 2);
+    const bool cameraReplayDebug = debugMode == 10;
+    const float radius =
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarBoxRadius, 6000), 1000, 20000));
+    LightCamera lightCamera{};
+    if (!build_light_camera(replayViewMtx, mapSize, radius, lightCamera)) {
+        return;
+    }
+    Mtx44 lightReplayProjection;
+    if (!build_light_replay_projection(lightCamera, replayViewMtx, lightReplayProjection)) {
+        return;
+    }
+    f32 savedProjection[7];
+    GXGetProjectionv(savedProjection);
+    f32 savedViewport[6];
+    GXGetViewportv(savedViewport);
+    u32 savedScissor[4];
+    GXGetScissor(&savedScissor[0], &savedScissor[1], &savedScissor[2], &savedScissor[3]);
+    Mtx savedView;
+    cMtx_copy(j3dSys.getViewMtx(), savedView);
+
+    auto restore_game_camera = [&]() {
+        j3dSys.setViewMtx(savedView);
+        GXSetProjectionv(savedProjection);
+        GXSetViewport(savedViewport[0], savedViewport[1], savedViewport[2], savedViewport[3],
+            savedViewport[4], savedViewport[5]);
+        GXSetScissor(savedScissor[0], savedScissor[1], savedScissor[2], savedScissor[3]);
+        dKy_setLight();
+    };
+    auto set_replay_camera = [&]() {
+        j3dSys.setViewMtx(replayViewMtx);
+        if (cameraReplayDebug) {
+            GXSetProjectionv(replayProjection);
+        } else {
+            GXSetProjectionFull(lightReplayProjection);
+        }
+        dKy_setLight();
+    };
+    if (!draw_lists_ready()) {
+        return;
+    }
+    if (svc_gfx->create_pass(mod_ctx, mapSize, mapSize) != MOD_OK) {
+        return;
+    }
+    J3DShape::resetVcdVatCache();
+
+    set_replay_camera();
+    GXSetViewport(0.0f, 0.0f, static_cast<float>(mapSize), static_cast<float>(mapSize), 0.0f, 1.0f);
+    GXSetViewportRender(
+        0.0f, 0.0f, static_cast<float>(mapSize), static_cast<float>(mapSize), 0.0f, 1.0f);
+    GXSetScissorRender(0, 0, mapSize, mapSize);
+    dKy_setLight();
+    GXSetColorUpdate(GX_TRUE);
+    GXSetAlphaUpdate(GX_TRUE);
+    GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
+    {
+        replay_scope replay;
+        draw_opaque_scene_lists();
+    }
+    j3dSys.reinitGX();
+    J3DShape::resetVcdVatCache();
+    restore_game_camera();
+
+    GfxResolveDesc resolveDesc = GFX_RESOLVE_DESC_INIT;
+    resolveDesc.color = true;
+    resolveDesc.depth = true;
+    GfxResolvedTargets resolved = GFX_RESOLVED_TARGETS_INIT;
+    if (svc_gfx->resolve_pass(mod_ctx, &resolveDesc, &resolved) != MOD_OK ||
+        resolved.color == nullptr || resolved.depth == nullptr)
+    {
+        return;
+    }
+
+    j3dSys.reinitGX();
+    J3DShape::resetVcdVatCache();
+    restore_game_camera();
+
+    g_mapPass.lightColor = resolved.color;
+    g_mapPass.shadowMap = resolved.depth;
+    g_mapPass.mapSize = mapSize;
+    copy_projection(lightCamera.vp, g_mapPass.lightVp);
+    std::memcpy(
+        g_mapPass.dirToLightWorld, lightCamera.dirToLight, sizeof(g_mapPass.dirToLightWorld));
+    g_mapPass.fade = lightCamera.fade;
+    g_mapPass.ready = true;
+}
+
+// Game thread, after opaque scene draws and before translucent/fog overlays: deferred composite.
+void on_scene_after_opaque(ModContext*, const GfxStageContext*, void*) {
+    const int64_t debugMode = get_debug_mode();
+    const bool presentDebug = debug_window_open();
+    restore_actual_light_debug();
+
+    if (presentDebug && debugMode == 0) {
+        svc_gfx->push_present(mod_ctx, g_debugPresentTarget, nullptr, 0);
+    }
+
+    const MapPassOutput mapPass = std::exchange(g_mapPass, {});
+    if (debugMode == 9 && !debug_window_open()) {
+        return;
+    }
+    if (!mapPass.ready || mapPass.shadowMap == nullptr || mapPass.lightColor == nullptr) {
+        if (presentDebug && debugMode != 0) {
+            svc_gfx->push_present(mod_ctx, g_debugPresentTarget, nullptr, 0);
+        }
+        return;
+    }
+    if (!g_sceneCamera.valid) {
+        if (presentDebug && debugMode != 0) {
+            svc_gfx->push_present(mod_ctx, g_debugPresentTarget, nullptr, 0);
+        }
+        return;
+    }
+    const CameraInfo& camera = g_sceneCamera.info;
+
+    GfxResolveDesc resolveDesc = GFX_RESOLVE_DESC_INIT;
+    resolveDesc.color = false;
+    resolveDesc.depth = true;
+    GfxResolvedTargets resolved = GFX_RESOLVED_TARGETS_INIT;
+    if (svc_gfx->resolve_pass(mod_ctx, &resolveDesc, &resolved) != MOD_OK ||
+        resolved.depth == nullptr)
+    {
+        if (presentDebug && debugMode != 0) {
+            svc_gfx->push_present(mod_ctx, g_debugPresentTarget, nullptr, 0);
+        }
+        return;
+    }
+
+    ShadowUniforms uniforms{};
+    std::memcpy(uniforms.world_from_proj, camera.world_from_proj, sizeof(uniforms.world_from_proj));
+    std::memcpy(uniforms.view_from_proj, camera.view_from_proj, sizeof(uniforms.view_from_proj));
+    std::memcpy(uniforms.proj_from_view, camera.proj_from_view, sizeof(uniforms.proj_from_view));
+    store_column_major(mapPass.lightVp, uniforms.light_vp);
+    // Rotate the world-space light direction into view space (w = 0).
+    for (int r = 0; r < 3; ++r) {
+        uniforms.light_dir_view[r] =
+            camera.view_from_world[0 * 4 + r] * mapPass.dirToLightWorld[0] +
+            camera.view_from_world[1 * 4 + r] * mapPass.dirToLightWorld[1] +
+            camera.view_from_world[2 * 4 + r] * mapPass.dirToLightWorld[2];
+    }
+    // Bias is configured in world units along the light direction.
+    uniforms.bias =
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarBias, 15), 0, 200)) /
+        (kLightFar - kLightNear);
+    uniforms.size[0] = static_cast<float>(mapPass.mapSize);
+    uniforms.size[1] = static_cast<float>(mapPass.mapSize);
+    uniforms.inv_size[0] = 1.0f / uniforms.size[0];
+    uniforms.inv_size[1] = 1.0f / uniforms.size[1];
+    uniforms.edge_fade_width =
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarEdgeFadeWidth, 32), 0, 256));
+    uniforms.strength =
+        mapPass.fade *
+        static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarStrength, 45), 0, 100)) /
+        100.0f;
+    uniforms.pcf_taps = static_cast<float>(std::clamp<int64_t>(get_int_option(g_cvarPcf, 1), 0, 2));
+    uniforms.contact_enabled = get_bool_option(g_cvarContactShadows, false) ? 1.0f : 0.0f;
+    uniforms.contact_thickness = 25.0f;
+    uniforms.contact_length = 60.0f;
+    // Camera Replay intentionally uses the gameplay-camera offscreen pass instead of the light
+    // shadow map, so it remains diagnostic on both windows. Other external diagnostics leave the
+    // main window on the normal shadow composite.
+    uniforms.debug_mode = presentDebug && debugMode != 10 ? 0u : static_cast<uint32_t>(debugMode);
+
+    GfxRange uniformRange{0, 0};
+    if (svc_gfx->push_uniform(mod_ctx, &uniforms, sizeof(uniforms), &uniformRange) != MOD_OK) {
+        return;
+    }
+    const DrawPayload payload{resolved.depth, mapPass.shadowMap, mapPass.lightColor,
+        uniformRange.offset, uniformRange.size, uniforms.debug_mode};
+    svc_gfx->push_draw(mod_ctx, g_drawType, &payload, sizeof(payload));
+
+    if (presentDebug && debugMode != 0) {
+        uniforms.debug_mode = static_cast<uint32_t>(debugMode);
+        GfxRange debugUniformRange{0, 0};
+        if (svc_gfx->push_uniform(mod_ctx, &uniforms, sizeof(uniforms), &debugUniformRange) !=
+            MOD_OK)
+        {
+            return;
+        }
+        const DrawPayload debugPayload{resolved.depth, mapPass.shadowMap, mapPass.lightColor,
+            debugUniformRange.offset, debugUniformRange.size, uniforms.debug_mode};
+        svc_gfx->push_present(mod_ctx, g_debugPresentTarget, &debugPayload, sizeof(debugPayload));
+    }
+}
+
+// Frame tail hook: only needed to restore light-view debug camera state before HUD.
+void on_frame_before_hud(ModContext*, const GfxStageContext*, void*) {
+    restore_actual_light_debug();
+}
+
+void add_control(UiElementHandle pane, const UiControlDesc& desc) {
+    svc_ui->pane_add_control(mod_ctx, pane, &desc, nullptr);
+}
+
+void add_toggle(UiElementHandle pane, const char* label, ConfigVarHandle cvar, const char* help) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_TOGGLE;
+    control.label = label;
+    control.help_rml = help;
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = cvar;
+    add_control(pane, control);
+}
+
+void add_select(UiElementHandle pane, const char* label, ConfigVarHandle cvar, const char** options,
+    uint32_t optionCount, const char* help) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_SELECT;
+    control.label = label;
+    control.help_rml = help;
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = cvar;
+    control.options = options;
+    control.option_count = optionCount;
+    add_control(pane, control);
+}
+
+void add_number(UiElementHandle pane, const char* label, ConfigVarHandle cvar, int64_t min,
+    int64_t max, int64_t step, const char* suffix, const char* help) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_NUMBER;
+    control.label = label;
+    control.help_rml = help;
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = cvar;
+    control.min = min;
+    control.max = max;
+    control.step = step;
+    control.suffix = suffix;
+    add_control(pane, control);
+}
+
+ModResult build_controls_tab(
+    ModContext*, UiWindowHandle, UiElementHandle left, UiElementHandle right, void*, ModError*) {
+    (void)right;
+
+    svc_ui->pane_add_section(mod_ctx, left, "Shadow Map");
+    add_toggle(left, "Enabled", g_cvarEnabled, "Enables dynamic shadows.");
+    static const char* kMapSizes[] = {"1024", "2048", "4096"};
+    add_select(left, "Map Size", g_cvarMapSize, kMapSizes, 3,
+        "Shadow map resolution. Larger is sharper and slower.");
+    add_toggle(left, "No Frustum Clipping", g_cvarNoFrustumClipping,
+        "Keeps camera-frustum-culled objects in draw lists so off-screen objects can cast "
+        "dynamic shadows. This can be expensive.");
+    add_number(left, "Coverage", g_cvarBoxRadius, 1000, 20000, 500, nullptr,
+        "Radius of the shadowed area around the camera, in world units. Smaller is sharper.");
+    add_number(left, "Fade Out", g_cvarEdgeFadeWidth, 0, 256, 32, " texels",
+        "Fade out shadows gradually near the edge of the coverage area.");
+
+    svc_ui->pane_add_section(mod_ctx, left, "Appearance");
+    add_number(left, "Strength", g_cvarStrength, 0, 100, 5, "%", "How dark shadowed areas become.");
+    static const char* kPcfOptions[] = {"Off", "3x3", "5x5"};
+    add_select(left, "Soft Shadows", g_cvarPcf, kPcfOptions, 3,
+        "Percentage-closer filtering tap pattern; softens shadow edges.");
+    add_number(left, "Bias", g_cvarBias, 0, 200, 5, nullptr,
+        "Depth bias in world units. Raise to remove shadow acne; lower to reduce peter-panning.");
+    add_toggle(left, "Contact Shadows", g_cvarContactShadows,
+        "Adds a screen-space raymarch for small-scale contact darkening the map misses.");
+
+    svc_ui->pane_add_section(mod_ctx, left, "Debug");
+    static const char* kDebugOptions[] = {"Off", "Shadow Map", "Shadow Factor", "Occlusion",
+        "Light UV", "Compare Sign", "Depth Values", "Receiver Range", "Bounds", "Light View",
+        "Camera Replay"};
+    add_select(left, "Debug View", g_cvarDebugView, kDebugOptions, 11,
+        "Shadow Map: light-space depth buffer<br/>Shadow Factor: final "
+        "darkening term<br/>Occlusion: map comparison result<br/>Light UV: receiver "
+        "projection coverage<br/>Compare Sign: current comparison in red and opposite "
+        "comparison in blue<br/>Depth Values: receiver depth in red and map depth in green<br/>"
+        "Receiver Range: beyond-far in red, valid depth in green, and before-near in blue<br/>"
+        "Bounds: valid X in red, valid Y in green, and valid depth in blue<br/>Light View: "
+        "renders the game world directly from the light camera<br/>Camera Replay: "
+        "captures the same draw-list replay from the gameplay camera");
+    UiControlDesc debugWindowControl = UI_CONTROL_DESC_INIT;
+    debugWindowControl.kind = UI_CONTROL_BUTTON;
+    debugWindowControl.label = "Open / Close Debug Window";
+    debugWindowControl.help_rml =
+        "Shows the selected debug view in an auxiliary WebGPU window. Standard diagnostics leave "
+        "the main view on the normal shadow composite.";
+    debugWindowControl.on_pressed = on_toggle_debug_window;
+    add_control(left, debugWindowControl);
+    return MOD_OK;
+}
+
+void on_controls_window_closed(ModContext*, UiWindowHandle, void*) {
+    g_controlsWindow = 0;
+}
+
+void on_open_controls(ModContext*, void*) {
+    if (g_controlsWindow != 0) {
+        return;
+    }
+    UiTabDesc tabs[1] = {UI_TAB_DESC_INIT};
+    tabs[0].title = "Controls";
+    tabs[0].build = build_controls_tab;
+    UiWindowDesc desc = UI_WINDOW_DESC_INIT;
+    desc.tabs = tabs;
+    desc.tab_count = 1;
+    desc.on_closed = on_controls_window_closed;
+    if (svc_ui->window_push(mod_ctx, &desc, &g_controlsWindow) != MOD_OK) {
+        svc_log->error(mod_ctx, "failed to open shadow controls window");
+    }
+}
+
+ModResult build_panel(ModContext*, UiElementHandle panel, void*, ModError*) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_TOGGLE;
+    control.label = "Enabled";
+    control.binding = UI_BINDING_CONFIG_VAR;
+    control.config_var = g_cvarEnabled;
+    add_control(panel, control);
+
+    control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_BUTTON;
+    control.label = "Open Controls";
+    control.on_pressed = on_open_controls;
+    add_control(panel, control);
+
+    control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_BUTTON;
+    control.label = "Open / Close Debug Window";
+    control.on_pressed = on_toggle_debug_window;
+    add_control(panel, control);
+    return MOD_OK;
+}
+
+ModResult register_bool_option(
+    const char* name, bool defaultValue, ConfigVarHandle& outHandle, ModError* error) {
+    ConfigVarDesc cvarDesc = CONFIG_VAR_DESC_INIT;
+    cvarDesc.name = name;
+    cvarDesc.type = CONFIG_VAR_BOOL;
+    cvarDesc.default_bool = defaultValue;
+    if (svc_config->register_var(mod_ctx, &cvarDesc, &outHandle) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register shadow option");
+    }
+    return MOD_OK;
+}
+
+ModResult register_int_option(
+    const char* name, int64_t defaultValue, ConfigVarHandle& outHandle, ModError* error) {
+    ConfigVarDesc cvarDesc = CONFIG_VAR_DESC_INIT;
+    cvarDesc.name = name;
+    cvarDesc.type = CONFIG_VAR_INT;
+    cvarDesc.default_int = defaultValue;
+    if (svc_config->register_var(mod_ctx, &cvarDesc, &outHandle) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register shadow option");
+    }
+    return MOD_OK;
+}
+
+}  // namespace
+
+extern "C" {
+
+MOD_EXPORT ModResult mod_initialize(ModError* error) {
+    ModResult result = svc_resource->load(mod_ctx, "shadow.wgsl", &g_shaderSource);
+    if (result != MOD_OK || g_shaderSource.data == nullptr) {
+        return mods::set_error(error, result, "failed to load shadow.wgsl");
+    }
+
+    result = register_bool_option("effectEnabled", false, g_cvarEnabled, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("mapSize", 2, g_cvarMapSize, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_bool_option("noFrustumClipping", true, g_cvarNoFrustumClipping, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("strength", 45, g_cvarStrength, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("pcf", 2, g_cvarPcf, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("bias", 55, g_cvarBias, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("boxRadius", 6000, g_cvarBoxRadius, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("edgeFadeWidth", 128, g_cvarEdgeFadeWidth, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_bool_option("contactShadows", true, g_cvarContactShadows, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+    result = register_int_option("debugView", 0, g_cvarDebugView, error);
+    if (result != MOD_OK) {
+        return result;
+    }
+
+    if (svc_gfx->get_device_info(mod_ctx, &g_deviceInfo) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to query device info");
+    }
+    if (svc_gfx->get_scene_target_layout(mod_ctx, &g_sceneTargetLayout) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to query scene target layout");
+    }
+    if (!build_composite_pipeline(true, g_compositePipeline, g_compositeLayout) ||
+        !build_composite_pipeline(false, g_compositeDebugPipeline, g_compositeDebugLayout))
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to create composite pipeline");
+    }
+
+    GfxDrawTypeDesc drawDesc = GFX_DRAW_TYPE_DESC_INIT;
+    drawDesc.label = "shadow composite";
+    drawDesc.draw = on_draw;
+    if (svc_gfx->register_draw_type(mod_ctx, &drawDesc, &g_drawType) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to register draw type");
+    }
+    GfxStageHookDesc stageDesc = GFX_STAGE_HOOK_DESC_INIT;
+    stageDesc.callback = on_scene_begin;
+    if (svc_gfx->register_stage_hook(
+            mod_ctx, GFX_STAGE_SCENE_BEGIN, &stageDesc, &g_sceneBeginHook) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to register stage hook");
+    }
+    stageDesc.callback = on_scene_after_terrain;
+    if (svc_gfx->register_stage_hook(
+            mod_ctx, GFX_STAGE_SCENE_AFTER_TERRAIN, &stageDesc, &g_sceneAfterTerrainHook) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to register stage hook");
+    }
+    stageDesc.callback = on_scene_after_opaque;
+    if (svc_gfx->register_stage_hook(
+            mod_ctx, GFX_STAGE_SCENE_AFTER_OPAQUE, &stageDesc, &g_sceneAfterOpaqueHook) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to register stage hook");
+    }
+    stageDesc.callback = on_frame_before_hud;
+    if (svc_gfx->register_stage_hook(
+            mod_ctx, GFX_STAGE_FRAME_BEFORE_HUD, &stageDesc, &g_frameBeforeHudHook) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to register stage hook");
+    }
+
+    // Skip the game's own shadow rendering while the dynamic pass is active: the
+    // shadowControl pair covers the actor real/blob shadows, drawCloudShadow the weather
+    // cloud shadows.
+    if (mods::hook::add_pre<GameShadowImageDraw>(on_game_shadow_pre) != MOD_OK ||
+        mods::hook::add_pre<GameShadowDraw>(on_game_shadow_pre) != MOD_OK ||
+        mods::hook::add_pre<CloudShadowDraw>(on_game_shadow_pre) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to hook game shadow rendering");
+    }
+    if (mods::hook::add_pre<ClipperSphereClip>(on_frustum_clip_pre) != MOD_OK ||
+        mods::hook::add_pre<ClipperBoxClip>(on_frustum_clip_pre) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to hook frustum clipping");
+    }
+    if (mods::hook::add_pre<CopyTex>(on_copy_tex_pre) != MOD_OK) {
+        return mods::set_error(error, MOD_ERROR, "failed to hook GXCopyTex");
+    }
+    UiModsPanelDesc panelDesc = UI_MODS_PANEL_DESC_INIT;
+    panelDesc.build = build_panel;
+    svc_ui->register_mods_panel(mod_ctx, &panelDesc);
+
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_update(ModError*) {
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_shutdown(ModError*) {
+    restore_actual_light_debug();
+    close_debug_window();
+    release_debug_present_pipeline();
+    svc_resource->free(mod_ctx, &g_shaderSource);
+    if (g_compositePipeline != nullptr) {
+        wgpuRenderPipelineRelease(g_compositePipeline);
+        g_compositePipeline = nullptr;
+    }
+    if (g_compositeDebugPipeline != nullptr) {
+        wgpuRenderPipelineRelease(g_compositeDebugPipeline);
+        g_compositeDebugPipeline = nullptr;
+    }
+    if (g_compositeLayout != nullptr) {
+        wgpuBindGroupLayoutRelease(g_compositeLayout);
+        g_compositeLayout = nullptr;
+    }
+    if (g_compositeDebugLayout != nullptr) {
+        wgpuBindGroupLayoutRelease(g_compositeDebugLayout);
+        g_compositeDebugLayout = nullptr;
+    }
+    g_cvarEnabled = g_cvarMapSize = g_cvarNoFrustumClipping = 0;
+    g_cvarStrength = 0;
+    g_cvarPcf = g_cvarBias = g_cvarBoxRadius = g_cvarEdgeFadeWidth = g_cvarContactShadows =
+        g_cvarDebugView = 0;
+    g_drawType = g_sceneBeginHook = g_sceneAfterTerrainHook = g_sceneAfterOpaqueHook =
+        g_frameBeforeHudHook = 0;
+    g_controlsWindow = 0;
+    g_debugWindow = 0;
+    g_debugPresentTarget = 0;
+    g_mapPass = {};
+    g_sceneCamera.valid = false;
+    g_sceneCamera.raw_valid = false;
+    return MOD_OK;
+}
+}
diff --git a/tools/mod_template/CMakeLists.txt b/mods/template_mod/CMakeLists.txt
similarity index 100%
rename from tools/mod_template/CMakeLists.txt
rename to mods/template_mod/CMakeLists.txt
diff --git a/mods/template_mod/mod.json b/mods/template_mod/mod.json
new file mode 100644
index 0000000000..e60714edf5
--- /dev/null
+++ b/mods/template_mod/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "com.example.mod",
+  "name": "Template Mod",
+  "version": "1.0.0",
+  "author": "You",
+  "description": "An example Dusklight mod"
+}
diff --git a/mods/template_mod/res/.gitkeep b/mods/template_mod/res/.gitkeep
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tools/mod_template/src/mod.cpp b/mods/template_mod/src/mod.cpp
similarity index 100%
rename from tools/mod_template/src/mod.cpp
rename to mods/template_mod/src/mod.cpp
diff --git a/mods/window_demo/CMakeLists.txt b/mods/window_demo/CMakeLists.txt
new file mode 100644
index 0000000000..4257f9686e
--- /dev/null
+++ b/mods/window_demo/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.25)
+project(window_demo CXX)
+
+if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
+    set(DUSK_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../.." CACHE PATH "Path to dusk source root")
+    option(DUSK_MOD_USE_FULL_TREE "Use full build instead of the minimal mod SDK" OFF)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+    if (DUSK_MOD_USE_FULL_TREE)
+        add_subdirectory("${DUSK_DIR}" dusk EXCLUDE_FROM_ALL)
+    else ()
+        add_subdirectory("${DUSK_DIR}/sdk" dusk-sdk EXCLUDE_FROM_ALL)
+    endif ()
+endif ()
+
+add_mod(window_demo
+    FEATURES fmt webgpu
+    SOURCES src/logging.cpp src/mod.cpp
+    MOD_JSON mod.json
+)
diff --git a/mods/window_demo/mod.json b/mods/window_demo/mod.json
new file mode 100644
index 0000000000..ff79e62431
--- /dev/null
+++ b/mods/window_demo/mod.json
@@ -0,0 +1,7 @@
+{
+  "id": "dev.twilitrealm.window_demo",
+  "name": "[Demo] Extra Window",
+  "version": "1.0.0",
+  "author": "Twilit Realm",
+  "description": "Demonstrates creating an extra window through WindowService and rendering to it with GfxService."
+}
diff --git a/mods/window_demo/src/logging.cpp b/mods/window_demo/src/logging.cpp
new file mode 100644
index 0000000000..87015c713a
--- /dev/null
+++ b/mods/window_demo/src/logging.cpp
@@ -0,0 +1,35 @@
+#include "logging.hpp"
+
+#include "mods/svc/log.hpp"
+#include "mods/svc/window.h"
+
+namespace {
+
+const char* window_event_name(WindowEventType type) {
+    switch (type) {
+    case WINDOW_EVENT_CLOSE_REQUESTED:
+        return "close requested";
+    case WINDOW_EVENT_RESIZED:
+        return "resized";
+    case WINDOW_EVENT_MOVED:
+        return "moved";
+    case WINDOW_EVENT_FOCUS_GAINED:
+        return "focus gained";
+    case WINDOW_EVENT_FOCUS_LOST:
+        return "focus lost";
+    case WINDOW_EVENT_SHOWN:
+        return "shown";
+    case WINDOW_EVENT_HIDDEN:
+        return "hidden";
+    }
+    return "unknown";
+}
+
+}  // namespace
+
+void window_demo::log_window_event(const WindowEvent* event) {
+    mods::log::info(
+        "window event: {}; position=({}, {}), size={}x{}, pixels={}x{}, scale={:.2f}",
+        window_event_name(event->type), event->x, event->y, event->width, event->height,
+        event->pixel_width, event->pixel_height, event->display_scale);
+}
diff --git a/mods/window_demo/src/logging.hpp b/mods/window_demo/src/logging.hpp
new file mode 100644
index 0000000000..3f62800d86
--- /dev/null
+++ b/mods/window_demo/src/logging.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+struct WindowEvent;
+
+namespace window_demo {
+
+void log_window_event(const WindowEvent* event);
+
+}  // namespace window_demo
diff --git a/mods/window_demo/src/mod.cpp b/mods/window_demo/src/mod.cpp
new file mode 100644
index 0000000000..0a1e9333ff
--- /dev/null
+++ b/mods/window_demo/src/mod.cpp
@@ -0,0 +1,221 @@
+#include "logging.hpp"
+
+#include "mods/service.hpp"
+#include "mods/svc/gfx.h"
+#include "mods/svc/log.hpp"
+#include "mods/svc/ui.h"
+#include "mods/svc/window.h"
+
+#include <cmath>
+#include <cstring>
+#include <webgpu/webgpu.h>
+
+DEFINE_MOD();
+IMPORT_SERVICE(LogService, svc_log);
+IMPORT_SERVICE(UiService, svc_ui);
+IMPORT_SERVICE(WindowService, svc_window);
+IMPORT_SERVICE(GfxService, svc_gfx);
+
+namespace {
+
+WindowHandle g_window = 0;
+GfxPresentTargetHandle g_presentTarget = 0;
+GfxStageHookHandle g_stageHook = 0;
+uint32_t g_frame = 0;
+bool g_recreatePresentTarget = false;
+
+struct ClearPayload {
+    float red;
+    float green;
+    float blue;
+    float alpha;
+};
+static_assert(sizeof(ClearPayload) <= GFX_INLINE_DRAW_PAYLOAD_SIZE);
+
+ModResult close_window() {
+    g_recreatePresentTarget = false;
+    if (g_presentTarget != 0) {
+        const auto result = svc_gfx->unregister_present_target(mod_ctx, g_presentTarget);
+        if (result != MOD_OK) {
+            return result;
+        }
+        g_presentTarget = 0;
+    }
+    if (g_window != 0) {
+        const auto result = svc_window->destroy_window(mod_ctx, g_window);
+        if (result != MOD_OK) {
+            return result;
+        }
+        g_window = 0;
+    }
+    return MOD_OK;
+}
+
+void on_window_event(ModContext*, WindowHandle, const WindowEvent* event, void*) {
+    window_demo::log_window_event(event);
+
+    if (event->type == WINDOW_EVENT_CLOSE_REQUESTED) {
+        if (close_window() != MOD_OK) {
+            mods::log::error("failed to close auxiliary window");
+        }
+    }
+}
+
+// Render worker thread: record a clear of the acquired auxiliary surface texture.
+void on_present(
+    ModContext*, const GfxPresentContext* ctx, const void* payload, size_t payloadSize, void*) {
+    if (payloadSize != sizeof(ClearPayload)) {
+        return;
+    }
+    ClearPayload color;
+    std::memcpy(&color, payload, sizeof(color));
+
+    WGPURenderPassColorAttachment colorAttachment = WGPU_RENDER_PASS_COLOR_ATTACHMENT_INIT;
+    colorAttachment.view = ctx->target_view;
+    colorAttachment.loadOp = WGPULoadOp_Clear;
+    colorAttachment.storeOp = WGPUStoreOp_Store;
+    colorAttachment.clearValue = WGPUColor{
+        color.red,
+        color.green,
+        color.blue,
+        color.alpha,
+    };
+
+    WGPURenderPassDescriptor passDesc = WGPU_RENDER_PASS_DESCRIPTOR_INIT;
+    passDesc.label = {"Auxiliary window clear", WGPU_STRLEN};
+    passDesc.colorAttachmentCount = 1;
+    passDesc.colorAttachments = &colorAttachment;
+    WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(ctx->encoder, &passDesc);
+    wgpuRenderPassEncoderEnd(pass);
+    wgpuRenderPassEncoderRelease(pass);
+}
+
+ModResult register_present_target() {
+    if (g_window == 0 || g_presentTarget != 0) {
+        return MOD_CONFLICT;
+    }
+    GfxPresentTargetDesc presentDesc = GFX_PRESENT_TARGET_DESC_INIT;
+    presentDesc.label = "Auxiliary window surface";
+    presentDesc.render = on_present;
+    presentDesc.preferred_alpha_mode =
+        WGPUCompositeAlphaMode_Premultiplied;  // For transparent window
+    return svc_gfx->register_window_present_target(
+        mod_ctx, g_window, &presentDesc, &g_presentTarget);
+}
+
+ModResult open_window() {
+    if (g_window != 0) {
+        return MOD_CONFLICT;
+    }
+
+    WindowDesc windowDesc = WINDOW_DESC_INIT;
+    windowDesc.title = "Mod window";
+    windowDesc.width = 640;
+    windowDesc.height = 480;
+    windowDesc.on_event = on_window_event;
+    windowDesc.flags |= WINDOW_FLAG_TRANSPARENT;  // For transparent window
+    auto result = svc_window->create_window(mod_ctx, &windowDesc, &g_window);
+    if (result != MOD_OK) {
+        return result;
+    }
+
+    result = register_present_target();
+    if (result != MOD_OK) {
+        close_window();
+        return result;
+    }
+
+    result = svc_window->show_window(mod_ctx, g_window);
+    if (result != MOD_OK) {
+        close_window();
+    }
+    return result;
+}
+
+void on_frame_after_hud(ModContext*, const GfxStageContext*, void*) {
+    if (g_presentTarget == 0) {
+        return;
+    }
+    const float phase = static_cast<float>(g_frame++) * 0.015f;
+    const ClearPayload color{
+        .red = 0.08f + 0.06f * (std::sin(phase) + 1.0f),
+        .green = 0.10f + 0.06f * (std::sin(phase + 2.1f) + 1.0f),
+        .blue = 0.14f + 0.08f * (std::sin(phase + 4.2f) + 1.0f),
+        .alpha = 0.5f,
+    };
+    if (svc_gfx->push_present(mod_ctx, g_presentTarget, &color, sizeof(color)) == MOD_ERROR) {
+        g_recreatePresentTarget = true;
+    }
+}
+
+void on_toggle_window(ModContext*, void*) {
+    if (g_window != 0) {
+        if (close_window() != MOD_OK) {
+            mods::log::error("failed to close auxiliary window");
+        }
+        return;
+    }
+    if (open_window() != MOD_OK) {
+        mods::log::error("failed to open auxiliary window");
+    }
+}
+
+ModResult build_panel(ModContext*, UiElementHandle panel, void*, ModError*) {
+    UiControlDesc control = UI_CONTROL_DESC_INIT;
+    control.kind = UI_CONTROL_BUTTON;
+    control.label = "Open / Close Window";
+    control.on_pressed = on_toggle_window;
+    return svc_ui->pane_add_control(mod_ctx, panel, &control, nullptr);
+}
+
+}  // namespace
+
+extern "C" {
+
+MOD_EXPORT ModResult mod_initialize(ModError* error) {
+    GfxStageHookDesc stageDesc = GFX_STAGE_HOOK_DESC_INIT;
+    stageDesc.callback = on_frame_after_hud;
+    if (svc_gfx->register_stage_hook(
+            mod_ctx, GFX_STAGE_FRAME_AFTER_HUD, &stageDesc, &g_stageHook) != MOD_OK)
+    {
+        return mods::set_error(error, MOD_ERROR, "failed to register presentation hook");
+    }
+
+    UiModsPanelDesc panelDesc = UI_MODS_PANEL_DESC_INIT;
+    panelDesc.build = build_panel;
+    if (svc_ui->register_mods_panel(mod_ctx, &panelDesc) != MOD_OK) {
+        svc_gfx->unregister_stage_hook(mod_ctx, g_stageHook);
+        g_stageHook = 0;
+        return mods::set_error(error, MOD_ERROR, "failed to register mod panel");
+    }
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_update(ModError* error) {
+    if (!g_recreatePresentTarget || g_window == 0) {
+        return MOD_OK;
+    }
+    g_recreatePresentTarget = false;
+    if (g_presentTarget != 0) {
+        const auto result = svc_gfx->unregister_present_target(mod_ctx, g_presentTarget);
+        if (result != MOD_OK) {
+            return mods::set_error(error, result, "failed to unregister lost present target");
+        }
+        g_presentTarget = 0;
+    }
+    const auto result = register_present_target();
+    if (result != MOD_OK) {
+        return mods::set_error(error, result, "failed to recreate present target");
+    }
+    return MOD_OK;
+}
+
+MOD_EXPORT ModResult mod_shutdown(ModError*) {
+    if (g_stageHook != 0) {
+        svc_gfx->unregister_stage_hook(mod_ctx, g_stageHook);
+        g_stageHook = 0;
+    }
+    close_window();
+    return MOD_OK;
+}
+}
diff --git a/platforms/android/.gitignore b/platforms/android/.gitignore
index 7775e3c7f4..002aaa86aa 100644
--- a/platforms/android/.gitignore
+++ b/platforms/android/.gitignore
@@ -3,3 +3,4 @@ build/
 app/build/
 local.properties
 app/src/main/jniLibs/*/*.so
+app/src/main/bundled_mods/
diff --git a/platforms/android/README.md b/platforms/android/README.md
index f478871392..c4f8a688df 100644
--- a/platforms/android/README.md
+++ b/platforms/android/README.md
@@ -1,10 +1,10 @@
 # Android Shell
 
-This directory contains a minimal SDLActivity-based Android app wrapper for Dusklight.
+This directory contains Dusklight's Android shell built on top of Borealis.
 
 ## Prerequisites
 
-- Android SDK installed (`ANDROID_HOME`)
+- Android SDK with Platform 37 installed (`ANDROID_HOME`)
 - Android NDK version used by CMake presets (`ANDROID_NDK_VERSION`)
 - JDK 17+
 
@@ -21,45 +21,23 @@ export JAVA_HOME="/usr/lib/jvm/java-17-openjdk"
 ```bash
 cmake --preset android-arm64
 cmake --build --preset android-arm64
-
-cmake --preset android-x86_64
-cmake --build --preset android-x86_64
 ```
 
-These builds produce:
-
-- `build/android-arm64/Binaries/libmain.so`
-- `build/android-x86_64/Binaries/libmain.so`
-
-## Stage Libraries Into APK Project
-
-```bash
-./android/scripts/stage-jni-libs.sh
-```
-
-This copies:
-
-- `libmain.so` -> `android/app/src/main/jniLibs/arm64-v8a/`
-- `libmain.so` -> `android/app/src/main/jniLibs/x86_64/`
-
-## Refresh SDL Java Shim (Optional)
-
-If you update SDL and want to refresh the embedded Java shim files:
-
-```bash
-./android/scripts/sync-sdl-java.sh
-```
+This build produces `build/android-arm64/libmain.so`
 
 ## Build APK
 
 ```bash
-cd android
+cd platforms/android
 ./gradlew :app:assembleDebug
 ```
 
 Output APK:
 
-- `android/app/build/outputs/apk/debug/app-debug.apk`
+- `app/build/outputs/apk/debug/app-arm64-v8a-debug.apk`
+
+Aurora needs a hardware-backed graphics adapter. If an AVD has GPU
+acceleration disabled, launch it with `-gpu host`.
 
 ## Launch With Runtime Args (adb)
 
@@ -67,10 +45,13 @@ You can pass command-line args through the activity intent:
 
 ```bash
 adb shell am start -n dev.twilitrealm.dusk/.DuskActivity \
-  --es dusk_args "--backend vulkan"
+  --es borealis_args "--backend vulkan"
 ```
 
 Supported extras:
 
-- `dusk_args`: single shell-like argument string
-- `dusk_argv`: string-array argv
+- `borealis_args`: single shell-like argument string
+- `borealis_argv`: string-array argv
+
+The legacy `dusk_args` and `dusk_argv` names remain accepted during the shell
+transition.
diff --git a/platforms/android/app/build.gradle b/platforms/android/app/build.gradle
index 8527cd1f4d..aba966b448 100644
--- a/platforms/android/app/build.gradle
+++ b/platforms/android/app/build.gradle
@@ -2,69 +2,32 @@ plugins {
     id 'com.android.application'
 }
 
-def versionNameStr = (System.getenv("DUSK_VERSION") ?: "v0.1.0").replaceFirst("^v", "")
-def versionCodeInt = (System.getenv("DUSK_VERSION_CODE") ?: "100000").toInteger()
-
 def duskRepoDir = rootProject.projectDir.parentFile.parentFile
-def duskGeneratedAssetsDir = layout.buildDirectory.dir('generated/assets/dusklight').get().asFile
-def syncDuskAssets = tasks.register('syncDuskAssets', Sync) {
-    from(new File(duskRepoDir, 'res')) {
-        into 'res'
-        exclude '**/.DS_Store'
-    }
-    into duskGeneratedAssetsDir
-}
+def borealisDir = new File(duskRepoDir, 'extern/borealis')
 
-android {
-    namespace 'dev.twilitrealm.dusk'
-    compileSdk 36
+ext.borealisAndroid = [
+    borealisDir: borealisDir,
+    propertiesFile: new File(duskRepoDir, 'build/android-arm64/borealis-android.properties'),
+    namespace: 'dev.twilitrealm.dusk',
+    applicationId: 'dev.twilitrealm.dusk',
+    abis: ['arm64-v8a'],
+    assets: [
+        [
+            from: new File(duskRepoDir, 'res'),
+            into: 'res',
+            excludes: ['**/.DS_Store']
+        ],
+        [
+            from: new File(duskRepoDir, 'build/android-arm64/bundled_mods'),
+            into: 'mods',
+            includes: ['*.dusk']
+        ]
+    ],
+    proguardRules: file('proguard-rules.pro')
+]
 
-    defaultConfig {
-        applicationId 'dev.twilitrealm.dusk'
-        minSdk 26
-        targetSdk 36
-        versionCode versionCodeInt
-        versionName versionNameStr
-    }
-
-    buildTypes {
-        debug {
-            minifyEnabled false
-        }
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
-        }
-    }
-
-    sourceSets {
-        main {
-            jniLibs.srcDirs = ['src/main/jniLibs']
-            assets.srcDirs = [duskGeneratedAssetsDir]
-        }
-    }
-
-    splits {
-        abi {
-            enable true
-            reset()
-            include 'arm64-v8a', 'x86_64'
-            universalApk false
-        }
-    }
-
-    lint {
-        abortOnError false
-    }
-}
+apply from: new File(borealisDir, 'platforms/android/gradle/borealis-application.gradle')
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
 }
-
-tasks.configureEach { task ->
-    if ((task.name.startsWith('merge') && task.name.endsWith('Assets')) ||
-        task.name.toLowerCase().contains('lint')) {
-        task.dependsOn(syncDuskAssets)
-    }
-}
diff --git a/platforms/android/app/proguard-rules.pro b/platforms/android/app/proguard-rules.pro
index 72b7ca16fa..308a46ab83 100644
--- a/platforms/android/app/proguard-rules.pro
+++ b/platforms/android/app/proguard-rules.pro
@@ -1,4 +1 @@
-# Keep SDL activity and related JNI bridge methods.
--keep class org.libsdl.app.** { *; }
--keep class dev.twilitrealm.dusk.DuskHttpClient { *; }
--keep class dev.twilitrealm.dusk.DuskHttpClient$Response { *; }
+-keep class dev.twilitrealm.dusk.DuskActivity { *; }
diff --git a/platforms/android/app/src/main/AndroidManifest.xml b/platforms/android/app/src/main/AndroidManifest.xml
index cd687963e1..8dc7bf3236 100644
--- a/platforms/android/app/src/main/AndroidManifest.xml
+++ b/platforms/android/app/src/main/AndroidManifest.xml
@@ -19,6 +19,7 @@
         android:appCategory="game"
         android:icon="@mipmap/icon"
         android:label="@string/app_name"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:theme="@android:style/Theme.NoTitleBar"
         android:enableOnBackInvokedCallback="false">
 
@@ -26,8 +27,8 @@
             android:resource="@xml/game_mode_config" />
 
         <provider
-            android:name="dev.twilitrealm.dusk.DuskDocumentsProvider"
-            android:authorities="dev.twilitrealm.dusk.documents"
+            android:name="dev.encounter.borealis.BorealisDocumentsProvider"
+            android:authorities="${applicationId}.documents"
             android:exported="true"
             android:grantUriPermissions="true"
             android:permission="android.permission.MANAGE_DOCUMENTS">
diff --git a/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskActivity.java b/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskActivity.java
index 96fc302d9e..4c1d8d41eb 100644
--- a/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskActivity.java
+++ b/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskActivity.java
@@ -1,552 +1,86 @@
 package dev.twilitrealm.dusk;
 
-import android.app.ActionBar;
-import android.app.Activity;
-import android.content.ActivityNotFoundException;
-import android.content.ClipData;
-import android.content.Context;
 import android.content.Intent;
-import android.database.Cursor;
-import android.net.Uri;
-import android.os.Build;
 import android.os.Bundle;
-import android.os.Environment;
-import android.provider.DocumentsContract;
-import android.provider.OpenableColumns;
-import android.provider.Settings;
 import android.util.Log;
-import android.view.Display;
-import android.view.Surface;
-import android.view.SurfaceHolder;
-import android.view.View;
-import android.view.Window;
-import android.view.WindowInsets;
-import android.view.WindowInsetsController;
 
-import org.libsdl.app.SDLActivity;
-import org.libsdl.app.SDLSurface;
+import dev.encounter.borealis.BorealisActivity;
 
 import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
 
-public class DuskActivity extends SDLActivity {
+public class DuskActivity extends BorealisActivity {
     private static final String TAG = "DuskActivity";
-    private static final float DEFAULT_SURFACE_FRAME_RATE = 60.0f;
-    private static final int FOLDER_DIALOG_REQUEST_CODE = 0x4455;
-    private static final int MANAGE_STORAGE_REQUEST_CODE = 0x4456;
-    private static final String EXTERNAL_STORAGE_AUTHORITY =
-        "com.android.externalstorage.documents";
-
-    private long folderDialogUserdata = 0;
-    private boolean awaitingManageStoragePermission = false;
-
-    private static native void nativeFolderDialogResult(long userdata, String path, String error);
-
-    private static String[] splitArgs(String raw) {
-        List<String> out = new ArrayList<>();
-        StringBuilder current = new StringBuilder();
-        boolean inSingle = false;
-        boolean inDouble = false;
-        boolean escaped = false;
-
-        for (int i = 0; i < raw.length(); ++i) {
-            char c = raw.charAt(i);
-            if (escaped) {
-                current.append(c);
-                escaped = false;
-                continue;
-            }
-            if (c == '\\' && !inSingle) {
-                escaped = true;
-                continue;
-            }
-            if (c == '"' && !inSingle) {
-                inDouble = !inDouble;
-                continue;
-            }
-            if (c == '\'' && !inDouble) {
-                inSingle = !inSingle;
-                continue;
-            }
-            if (!inSingle && !inDouble && Character.isWhitespace(c)) {
-                if (current.length() > 0) {
-                    out.add(current.toString());
-                    current.setLength(0);
-                }
-                continue;
-            }
-            current.append(c);
-        }
-
-        if (escaped) {
-            current.append('\\');
-        }
-        if (current.length() > 0) {
-            out.add(current.toString());
-        }
-        return out.toArray(new String[0]);
-    }
-
     @Override
     protected void onCreate(Bundle savedInstanceState) {
+        extractBundledMods();
         super.onCreate(savedInstanceState);
-        hideSystemBars();
     }
 
-    @Override
-    protected SDLSurface createSDLSurface(Context context) {
-        return new DuskSurface(context);
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-        hideSystemBars();
-        if (awaitingManageStoragePermission) {
-            resumeFolderDialogAfterPermissionGrant();
-        }
-    }
-
-    @Override
-    public void onWindowFocusChanged(boolean hasFocus) {
-        super.onWindowFocusChanged(hasFocus);
-        if (hasFocus) {
-            hideSystemBars();
-        }
-    }
-
-    private void hideSystemBars() {
-        Window window = getWindow();
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            window.setDecorFitsSystemWindows(false);
-            WindowInsetsController ctrl = window.getDecorView().getWindowInsetsController();
-            if (ctrl != null) {
-                ctrl.setSystemBarsBehavior(
-                    WindowInsetsController.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
-                ctrl.hide(WindowInsets.Type.systemBars());
-            }
-        } else {
-            View decorView = window.getDecorView();
-            int uiOptions = View.SYSTEM_UI_FLAG_FULLSCREEN |
-                View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
-                View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
-                View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
-                View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
-                View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
-            decorView.setSystemUiVisibility(uiOptions);
-            ActionBar actionBar = getActionBar();
-            if (actionBar != null) {
-                actionBar.hide();
-            }
-        }
-    }
-
-    @Override
-    protected String[] getLibraries() {
-        // SDL3 is statically linked into libmain.so in this build.
-        return new String[] {
-            "main"
-        };
-    }
-
-    public void setPreferredSurfaceFrameRate(float frameRate) {
-        runOnUiThread(() -> {
-            if (mSurface instanceof DuskSurface) {
-                ((DuskSurface)mSurface).setPreferredFrameRate(frameRate);
-            }
-        });
-    }
-
-    private static final class DuskSurface extends SDLSurface {
-        private float preferredFrameRate = DEFAULT_SURFACE_FRAME_RATE;
-
-        DuskSurface(Context context) {
-            super(context);
-        }
-
-        @Override
-        public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-            super.surfaceChanged(holder, format, width, height);
-            setTargetFrameRate(holder);
-        }
-
-        void setPreferredFrameRate(float frameRate) {
-            preferredFrameRate = frameRate;
-            setTargetFrameRate(getHolder());
-        }
-
-        private void setTargetFrameRate(SurfaceHolder holder) {
-            if (!mIsSurfaceReady || Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+    // Bundled mod packages ship as APK assets, which the native loader cannot read directly;
+    // mirror them into internal storage (the loader's CachePath/bundled_mods search dir)
+    // before SDL_main starts.
+    private void extractBundledMods() {
+        File outDir = new File(getFilesDir(), "bundled_mods");
+        try {
+            deleteRecursively(outDir); // drop packages removed by an app update
+            String[] names = getAssets().list("mods");
+            if (names == null || names.length == 0) {
                 return;
             }
-
-            Surface surface = holder != null ? holder.getSurface() : getHolder().getSurface();
-            if (surface == null || !surface.isValid()) {
+            if (!outDir.mkdirs()) {
+                Log.w(TAG, "Unable to create " + outDir);
                 return;
             }
-
-            float targetFrameRate = getMaxSupportedFrameRate();
-            if (preferredFrameRate > 0.0f) {
-                targetFrameRate = preferredFrameRate;
-            }
-            if (targetFrameRate <= 0.0f) {
-                return;
+            byte[] buffer = new byte[65536];
+            for (String name : names) {
+                if (!name.endsWith(".dusk")) {
+                    continue;
+                }
+                try (InputStream in = getAssets().open("mods/" + name);
+                     OutputStream out = new FileOutputStream(new File(outDir, name)))
+                {
+                    int count;
+                    while ((count = in.read(buffer)) > 0) {
+                        out.write(buffer, 0, count);
+                    }
+                }
             }
+        } catch (IOException e) {
+            Log.w(TAG, "Failed to extract bundled mods", e);
+        }
+    }
 
-            try {
-                surface.setFrameRate(
-                    targetFrameRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
-                Log.v(TAG, "Requested surface frame rate " + targetFrameRate + " fps");
-            } catch (RuntimeException e) {
-                Log.w(TAG, "Failed to request surface frame rate", e);
+    private static void deleteRecursively(File file) {
+        File[] children = file.listFiles();
+        if (children != null) {
+            for (File child : children) {
+                deleteRecursively(child);
             }
         }
-
-        private float getMaxSupportedFrameRate() {
-            if (mDisplay == null) {
-                return 0.0f;
-            }
-
-            float maxFrameRate = mDisplay.getRefreshRate();
-            Display.Mode[] modes = mDisplay.getSupportedModes();
-            if (modes == null) {
-                return maxFrameRate;
-            }
-
-            for (Display.Mode mode : modes) {
-                maxFrameRate = Math.max(maxFrameRate, mode.getRefreshRate());
-            }
-            return maxFrameRate;
-        }
+        file.delete();
     }
 
     @Override
     protected String[] getArguments() {
+        String[] arguments = super.getArguments();
+        if (arguments.length > 0) {
+            return arguments;
+        }
+
         Intent intent = getIntent();
-        if (intent != null) {
-            String[] argv = intent.getStringArrayExtra("dusk_argv");
-            if (argv != null && argv.length > 0) {
-                return argv;
-            }
-
-            String rawArgs = intent.getStringExtra("dusk_args");
-            if (rawArgs != null) {
-                String trimmed = rawArgs.trim();
-                if (!trimmed.isEmpty()) {
-                    return splitArgs(trimmed);
-                }
-            }
+        if (intent == null) {
+            return arguments;
         }
-        return new String[0];
+        String[] argv = intent.getStringArrayExtra("dusk_argv");
+        if (argv != null && argv.length > 0) {
+            return argv;
+        }
+        String rawArgs = intent.getStringExtra("dusk_args");
+        return rawArgs == null ? arguments : splitArguments(rawArgs.trim());
     }
 
-    @Override
-    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (resultCode == RESULT_OK) {
-            persistUriPermissions(data);
-        }
-        if (requestCode == FOLDER_DIALOG_REQUEST_CODE) {
-            finishFolderDialog(resultCode, data);
-            return;
-        }
-        super.onActivityResult(requestCode, resultCode, data);
-    }
-
-    public boolean showFolderDialog(long userdata) {
-        if (userdata == 0 || folderDialogUserdata != 0) {
-            return false;
-        }
-
-        folderDialogUserdata = userdata;
-        if (requiresManageStoragePermission() && !hasManageStoragePermission()) {
-            if (!requestManageStoragePermission()) {
-                finishFolderDialogWithError("Unable to request Android file access permission");
-                return false;
-            }
-            return true;
-        }
-
-        openFolderDialog();
-        return true;
-    }
-
-    private void openFolderDialog() {
-        runOnUiThread(() -> {
-            Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
-            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION |
-                Intent.FLAG_GRANT_WRITE_URI_PERMISSION |
-                Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION |
-                Intent.FLAG_GRANT_PREFIX_URI_PERMISSION);
-
-            try {
-                startActivityForResult(intent, FOLDER_DIALOG_REQUEST_CODE);
-            } catch (ActivityNotFoundException e) {
-                Log.w(TAG, "Unable to open folder dialog.", e);
-                finishFolderDialog(Activity.RESULT_CANCELED, null);
-            }
-        });
-    }
-
-    private boolean requiresManageStoragePermission() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.R;
-    }
-
-    private boolean hasManageStoragePermission() {
-        return !requiresManageStoragePermission() || Environment.isExternalStorageManager();
-    }
-
-    private boolean requestManageStoragePermission() {
-        if (!requiresManageStoragePermission()) {
-            return true;
-        }
-
-        awaitingManageStoragePermission = true;
-        runOnUiThread(() -> {
-            if (tryStartManageStorageIntent(
-                    new Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
-                        .setData(Uri.parse("package:" + getPackageName()))) ||
-                tryStartManageStorageIntent(
-                    new Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)))
-            {
-                return;
-            }
-
-            finishFolderDialogWithError("Unable to request Android file access permission");
-        });
-        return true;
-    }
-
-    private boolean tryStartManageStorageIntent(Intent intent) {
-        try {
-            startActivityForResult(intent, MANAGE_STORAGE_REQUEST_CODE);
-            return true;
-        } catch (ActivityNotFoundException e) {
-            Log.w(TAG, "Unable to open all-files access settings.", e);
-            return false;
-        }
-    }
-
-    private void resumeFolderDialogAfterPermissionGrant() {
-        awaitingManageStoragePermission = false;
-        if (folderDialogUserdata == 0) {
-            return;
-        }
-
-        if (hasManageStoragePermission()) {
-            openFolderDialog();
-            return;
-        }
-
-        finishFolderDialogWithError(
-            "Allow \"All files access\" for Dusklight before choosing a custom data folder");
-    }
-
-    private void finishFolderDialogWithError(String error) {
-        long userdata = folderDialogUserdata;
-        folderDialogUserdata = 0;
-        awaitingManageStoragePermission = false;
-        if (userdata != 0) {
-            nativeFolderDialogResult(userdata, null, error);
-        }
-    }
-
-    private void finishFolderDialog(int resultCode, Intent data) {
-        long userdata = folderDialogUserdata;
-        folderDialogUserdata = 0;
-        if (userdata == 0) {
-            return;
-        }
-
-        if (resultCode == RESULT_OK && data != null && data.getData() != null) {
-            String path = getRealPathForUri(data.getData());
-            if (path != null && !path.isEmpty()) {
-                nativeFolderDialogResult(userdata, path, null);
-            } else {
-                nativeFolderDialogResult(
-                    userdata, null, "Selected folder is not available as a filesystem path");
-            }
-            return;
-        }
-
-        nativeFolderDialogResult(userdata, null, null);
-    }
-
-    private String getRealPathForUri(Uri uri) {
-        if (uri == null) {
-            return null;
-        }
-
-        String scheme = uri.getScheme();
-        if ("file".equals(scheme)) {
-            return uri.getPath();
-        }
-
-        if (!"content".equals(scheme) ||
-            !EXTERNAL_STORAGE_AUTHORITY.equals(uri.getAuthority()) ||
-            Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT)
-        {
-            return null;
-        }
-
-        try {
-            return getExternalStoragePathForDocumentId(getExternalStorageDocumentId(uri));
-        } catch (IllegalArgumentException e) {
-            Log.w(TAG, "Unable to resolve URI: " + uri, e);
-            return null;
-        }
-    }
-
-    private static String getExternalStorageDocumentId(Uri uri) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && isTreeDocumentUri(uri)) {
-            return DocumentsContract.getTreeDocumentId(uri);
-        }
-
-        return DocumentsContract.getDocumentId(uri);
-    }
-
-    private static boolean isTreeDocumentUri(Uri uri) {
-        List<String> segments = uri.getPathSegments();
-        return segments.size() >= 2 && "tree".equals(segments.get(0));
-    }
-
-    private String getExternalStoragePathForDocumentId(String documentId) {
-        if (documentId == null || documentId.isEmpty()) {
-            return null;
-        }
-        if (documentId.startsWith("raw:")) {
-            return documentId.substring("raw:".length());
-        }
-
-        String[] parts = documentId.split(":", 2);
-        String volumeId = parts[0];
-        String relativePath = parts.length > 1 ? parts[1] : "";
-
-        File root = getExternalStorageRoot(volumeId);
-        if (root == null) {
-            return null;
-        }
-
-        return relativePath.isEmpty()
-            ? root.getAbsolutePath()
-            : new File(root, relativePath).getAbsolutePath();
-    }
-
-    private File getExternalStorageRoot(String volumeId) {
-        if ("primary".equalsIgnoreCase(volumeId)) {
-            return Environment.getExternalStorageDirectory();
-        }
-        if ("home".equalsIgnoreCase(volumeId)) {
-            return new File(
-                Environment.getExternalStorageDirectory(), Environment.DIRECTORY_DOCUMENTS);
-        }
-
-        File[] externalFilesDirs = getExternalFilesDirs(null);
-        if (externalFilesDirs != null) {
-            for (File externalFilesDir : externalFilesDirs) {
-                File root = getStorageRootForExternalFilesDir(externalFilesDir);
-                if (root != null && volumeId.equalsIgnoreCase(root.getName())) {
-                    return root;
-                }
-            }
-        }
-
-        File fallback = new File("/storage", volumeId);
-        return fallback.exists() ? fallback : null;
-    }
-
-    private File getStorageRootForExternalFilesDir(File externalFilesDir) {
-        if (externalFilesDir == null) {
-            return null;
-        }
-
-        String path = externalFilesDir.getAbsolutePath();
-        int androidDir = path.indexOf("/Android/");
-        if (androidDir <= 0) {
-            return null;
-        }
-
-        return new File(path.substring(0, androidDir));
-    }
-
-    private void persistUriPermissions(Intent data) {
-        if (data == null) {
-            return;
-        }
-
-        int permissionFlags =
-            data.getFlags() & (Intent.FLAG_GRANT_READ_URI_PERMISSION | Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
-        if (permissionFlags == 0) {
-            return;
-        }
-
-        Uri uri = data.getData();
-        if (uri != null) {
-            persistUriPermission(uri, permissionFlags);
-        }
-
-        ClipData clipData = data.getClipData();
-        if (clipData == null) {
-            return;
-        }
-        for (int i = 0; i < clipData.getItemCount(); ++i) {
-            Uri itemUri = clipData.getItemAt(i).getUri();
-            if (itemUri != null) {
-                persistUriPermission(itemUri, permissionFlags);
-            }
-        }
-    }
-
-    private void persistUriPermission(Uri uri, int permissionFlags) {
-        if ((permissionFlags & Intent.FLAG_GRANT_READ_URI_PERMISSION) != 0) {
-            persistUriPermission(uri, Intent.FLAG_GRANT_READ_URI_PERMISSION, "read");
-        }
-        if ((permissionFlags & Intent.FLAG_GRANT_WRITE_URI_PERMISSION) != 0) {
-            persistUriPermission(uri, Intent.FLAG_GRANT_WRITE_URI_PERMISSION, "write");
-        }
-    }
-
-    private void persistUriPermission(Uri uri, int permissionFlag, String permissionName) {
-        try {
-            getContentResolver().takePersistableUriPermission(uri, permissionFlag);
-        } catch (SecurityException | IllegalArgumentException e) {
-            Log.w(TAG, "Unable to persist " + permissionName + " URI permission for " + uri, e);
-        }
-    }
-
-    public String getDisplayNameForUri(String uriString) {
-        if (uriString == null || uriString.isEmpty()) {
-            return "";
-        }
-
-        Uri uri = Uri.parse(uriString);
-        if ("content".equals(uri.getScheme())) {
-            try (Cursor cursor = getContentResolver().query(
-                uri, new String[] { OpenableColumns.DISPLAY_NAME }, null, null, null))
-            {
-                if (cursor != null && cursor.moveToFirst()) {
-                    int displayNameColumn = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
-                    if (displayNameColumn >= 0) {
-                        String displayName = cursor.getString(displayNameColumn);
-                        if (displayName != null && !displayName.isEmpty()) {
-                            return displayName;
-                        }
-                    }
-                }
-            } catch (SecurityException | IllegalArgumentException e) {
-                Log.w(TAG, "Unable to query display name for " + uri, e);
-            }
-        } else if ("file".equals(uri.getScheme())) {
-            String path = uri.getPath();
-            if (path != null && !path.isEmpty()) {
-                String name = new File(path).getName();
-                if (!name.isEmpty()) {
-                    return name;
-                }
-            }
-        }
-
-        String lastSegment = uri.getLastPathSegment();
-        return lastSegment != null ? lastSegment : "";
-    }
 }
diff --git a/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskDocumentsProvider.java b/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskDocumentsProvider.java
deleted file mode 100644
index d4ed6a3041..0000000000
--- a/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskDocumentsProvider.java
+++ /dev/null
@@ -1,467 +0,0 @@
-package dev.twilitrealm.dusk;
-
-import android.content.ContentResolver;
-import android.content.res.AssetFileDescriptor;
-import android.database.Cursor;
-import android.database.MatrixCursor;
-import android.net.Uri;
-import android.os.Bundle;
-import android.os.CancellationSignal;
-import android.os.ParcelFileDescriptor;
-import android.provider.DocumentsContract;
-import android.provider.DocumentsContract.Document;
-import android.provider.DocumentsContract.Root;
-import android.provider.DocumentsProvider;
-import android.webkit.MimeTypeMap;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-
-public class DuskDocumentsProvider extends DocumentsProvider {
-    public static final String AUTHORITY = "dev.twilitrealm.dusk.documents";
-
-    private static final String ROOT_ID = "dusk";
-    private static final String ROOT_DOCUMENT_ID = "root";
-    private static final String LOCATION_DESCRIPTOR_NAME = "data_location.json";
-    private static final String DIRECTORY_MIME_TYPE = Document.MIME_TYPE_DIR;
-
-    private static final String[] DEFAULT_ROOT_PROJECTION = new String[] {
-        Root.COLUMN_ROOT_ID,
-        Root.COLUMN_FLAGS,
-        Root.COLUMN_TITLE,
-        Root.COLUMN_DOCUMENT_ID,
-        Root.COLUMN_ICON,
-        Root.COLUMN_AVAILABLE_BYTES,
-        Root.COLUMN_SUMMARY
-    };
-
-    private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[] {
-        Document.COLUMN_DOCUMENT_ID,
-        Document.COLUMN_DISPLAY_NAME,
-        Document.COLUMN_FLAGS,
-        Document.COLUMN_MIME_TYPE,
-        Document.COLUMN_LAST_MODIFIED,
-        Document.COLUMN_SIZE
-    };
-
-    @Override
-    public boolean onCreate() {
-        if (!isCustomDataPathEnabled()) {
-            ensureUserDirectories();
-        }
-        return true;
-    }
-
-    @Override
-    public Cursor queryRoots(String[] projection) throws FileNotFoundException {
-        final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection));
-        if (isCustomDataPathEnabled()) {
-            return result;
-        }
-
-        final File root = getRootDirectory();
-        final MatrixCursor.RowBuilder row = result.newRow();
-
-        row.add(Root.COLUMN_ROOT_ID, ROOT_ID);
-        row.add(Root.COLUMN_FLAGS,
-            Root.FLAG_LOCAL_ONLY |
-            Root.FLAG_SUPPORTS_CREATE |
-            Root.FLAG_SUPPORTS_IS_CHILD);
-        row.add(Root.COLUMN_TITLE, getContext().getString(R.string.app_name));
-        row.add(Root.COLUMN_DOCUMENT_ID, ROOT_DOCUMENT_ID);
-        row.add(Root.COLUMN_ICON, R.mipmap.icon);
-        row.add(Root.COLUMN_AVAILABLE_BYTES, root.getFreeSpace());
-        row.add(Root.COLUMN_SUMMARY, getContext().getString(R.string.documents_provider_summary));
-
-        return result;
-    }
-
-    @Override
-    public Cursor queryDocument(String documentId, String[] projection) throws FileNotFoundException {
-        final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
-        includeDocument(result, documentId, getFileForDocumentId(documentId));
-        return result;
-    }
-
-    @Override
-    public Cursor queryChildDocuments(String parentDocumentId, String[] projection, String sortOrder)
-        throws FileNotFoundException
-    {
-        return queryChildDocumentsInternal(parentDocumentId, projection);
-    }
-
-    @Override
-    public Cursor queryChildDocuments(String parentDocumentId, String[] projection, Bundle queryArgs)
-        throws FileNotFoundException
-    {
-        return queryChildDocumentsInternal(parentDocumentId, projection);
-    }
-
-    private Cursor queryChildDocumentsInternal(String parentDocumentId, String[] projection)
-        throws FileNotFoundException
-    {
-        final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
-        final File parent = getFileForDocumentId(parentDocumentId);
-        final File[] files = parent.listFiles();
-        result.setNotificationUri(getContext().getContentResolver(), getChildDocumentsUri(parentDocumentId));
-
-        if (files == null) {
-            return result;
-        }
-
-        for (File file : files) {
-            includeDocument(result, getDocumentIdForFile(file), file);
-        }
-
-        return result;
-    }
-
-    @Override
-    public boolean isChildDocument(String parentDocumentId, String documentId) {
-        try {
-            final File parent = getFileForDocumentId(parentDocumentId);
-            final File child = getFileForDocumentId(documentId);
-            return isInside(parent, child);
-        } catch (FileNotFoundException e) {
-            return false;
-        }
-    }
-
-    @Override
-    public String createDocument(String parentDocumentId, String mimeType, String displayName)
-        throws FileNotFoundException
-    {
-        final File parent = getFileForDocumentId(parentDocumentId);
-        if (!parent.isDirectory()) {
-            throw new FileNotFoundException("Parent is not a directory: " + parentDocumentId);
-        }
-
-        final String safeDisplayName = sanitizeDisplayName(displayName);
-        final File file = buildUniqueFile(parent, safeDisplayName);
-        final boolean created;
-        if (DIRECTORY_MIME_TYPE.equals(mimeType)) {
-            created = file.mkdir();
-        } else {
-            try {
-                created = file.createNewFile();
-            } catch (IOException e) {
-                throw asFileNotFound("Unable to create document", e);
-            }
-        }
-
-        if (!created) {
-            throw new FileNotFoundException("Unable to create document: " + displayName);
-        }
-
-        notifyChildrenChanged(parentDocumentId);
-        return getDocumentIdForFile(file);
-    }
-
-    @Override
-    public String renameDocument(String documentId, String displayName) throws FileNotFoundException {
-        final File file = getFileForDocumentId(documentId);
-        if (ROOT_DOCUMENT_ID.equals(documentId)) {
-            throw new FileNotFoundException("Cannot rename root document");
-        }
-
-        final File target = buildUniqueFile(file.getParentFile(), sanitizeDisplayName(displayName));
-        final String parentDocumentId = getDocumentIdForFile(file.getParentFile());
-        if (!file.renameTo(target)) {
-            throw new FileNotFoundException("Unable to rename document: " + documentId);
-        }
-        notifyDocumentChanged(documentId);
-        notifyDocumentChanged(getDocumentIdForFile(target));
-        notifyChildrenChanged(parentDocumentId);
-        return getDocumentIdForFile(target);
-    }
-
-    @Override
-    public void deleteDocument(String documentId) throws FileNotFoundException {
-        if (ROOT_DOCUMENT_ID.equals(documentId)) {
-            throw new FileNotFoundException("Cannot delete root document");
-        }
-
-        final File file = getFileForDocumentId(documentId);
-        final String parentDocumentId = getDocumentIdForFile(file.getParentFile());
-        deleteRecursively(file);
-        notifyDocumentChanged(documentId);
-        notifyChildrenChanged(parentDocumentId);
-    }
-
-    @Override
-    public ParcelFileDescriptor openDocument(String documentId, String mode, CancellationSignal signal)
-        throws FileNotFoundException
-    {
-        return ParcelFileDescriptor.open(getFileForDocumentId(documentId), modeToParcelMode(mode));
-    }
-
-    @Override
-    public AssetFileDescriptor openDocumentThumbnail(String documentId, android.graphics.Point sizeHint,
-        CancellationSignal signal) throws FileNotFoundException
-    {
-        throw new FileNotFoundException("Thumbnails are not supported");
-    }
-
-    private void includeDocument(MatrixCursor result, String documentId, File file) throws FileNotFoundException {
-        final MatrixCursor.RowBuilder row = result.newRow();
-        final boolean isDirectory = file.isDirectory();
-        final String displayName = ROOT_DOCUMENT_ID.equals(documentId)
-            ? getContext().getString(R.string.documents_provider_root_name)
-            : file.getName();
-
-        int flags = Document.FLAG_SUPPORTS_DELETE | Document.FLAG_SUPPORTS_RENAME;
-        if (isDirectory) {
-            flags |= Document.FLAG_DIR_SUPPORTS_CREATE;
-        } else if (file.canWrite()) {
-            flags |= Document.FLAG_SUPPORTS_WRITE;
-        }
-        if (ROOT_DOCUMENT_ID.equals(documentId)) {
-            flags &= ~(Document.FLAG_SUPPORTS_DELETE | Document.FLAG_SUPPORTS_RENAME);
-        }
-
-        row.add(Document.COLUMN_DOCUMENT_ID, documentId);
-        row.add(Document.COLUMN_DISPLAY_NAME, displayName);
-        row.add(Document.COLUMN_FLAGS, flags);
-        row.add(Document.COLUMN_MIME_TYPE, isDirectory ? DIRECTORY_MIME_TYPE : getMimeType(file));
-        row.add(Document.COLUMN_LAST_MODIFIED, file.lastModified());
-        row.add(Document.COLUMN_SIZE, isDirectory ? null : file.length());
-    }
-
-    private File getRootDirectory() throws FileNotFoundException {
-        if (isCustomDataPathEnabled()) {
-            throw new FileNotFoundException(
-                "Dusk DocumentsProvider is disabled while a custom data path is configured");
-        }
-
-        final File root = getContext().getFilesDir();
-        if (root == null) {
-            throw new FileNotFoundException("Dusklight files directory is unavailable");
-        }
-        return root;
-    }
-
-    private File getFileForDocumentId(String documentId) throws FileNotFoundException {
-        final File root = getRootDirectory();
-        if (ROOT_DOCUMENT_ID.equals(documentId)) {
-            return root;
-        }
-        if (!documentId.startsWith(ROOT_DOCUMENT_ID + "/")) {
-            throw new FileNotFoundException("Invalid document id: " + documentId);
-        }
-
-        final String relativePath = documentId.substring(ROOT_DOCUMENT_ID.length() + 1);
-        final File file = new File(root, relativePath);
-        if (!isInside(root, file)) {
-            throw new FileNotFoundException("Document escapes Dusklight files directory: " + documentId);
-        }
-        if (!file.exists()) {
-            throw new FileNotFoundException("Document does not exist: " + documentId);
-        }
-        return file;
-    }
-
-    private String getDocumentIdForFile(File file) throws FileNotFoundException {
-        final File root = getRootDirectory();
-        if (sameFile(root, file)) {
-            return ROOT_DOCUMENT_ID;
-        }
-        if (!isInside(root, file)) {
-            throw new FileNotFoundException("File escapes Dusklight files directory: " + file);
-        }
-
-        final String rootPath = canonicalPath(root);
-        final String filePath = canonicalPath(file);
-        return ROOT_DOCUMENT_ID + "/" + filePath.substring(rootPath.length() + 1);
-    }
-
-    private void ensureUserDirectories() {
-        final File root = getContext().getFilesDir();
-        if (root == null) {
-            return;
-        }
-        new File(root, "texture_replacements").mkdirs();
-        new File(root, "USA/Card A").mkdirs();
-        new File(root, "EUR/Card A").mkdirs();
-    }
-
-    private boolean isCustomDataPathEnabled() {
-        if (getContext() == null) {
-            return false;
-        }
-
-        final File filesDir = getContext().getFilesDir();
-        if (filesDir == null) {
-            return false;
-        }
-
-        final File descriptor = new File(filesDir, LOCATION_DESCRIPTOR_NAME);
-        if (!descriptor.isFile()) {
-            return false;
-        }
-
-        try {
-            final JSONObject json = new JSONObject(readText(descriptor));
-            return "custom".equals(json.optString("mode", "default"));
-        } catch (IOException | JSONException e) {
-            return false;
-        }
-    }
-
-    private static String readText(File file) throws IOException {
-        try (FileInputStream input = new FileInputStream(file);
-             ByteArrayOutputStream output = new ByteArrayOutputStream())
-        {
-            byte[] buffer = new byte[4096];
-            int bytesRead;
-            while ((bytesRead = input.read(buffer)) != -1) {
-                output.write(buffer, 0, bytesRead);
-            }
-            return output.toString(StandardCharsets.UTF_8.name());
-        }
-    }
-
-    private static String[] resolveRootProjection(String[] projection) {
-        return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
-    }
-
-    private static String[] resolveDocumentProjection(String[] projection) {
-        return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
-    }
-
-    private static String sanitizeDisplayName(String displayName) throws FileNotFoundException {
-        if (displayName == null) {
-            throw new FileNotFoundException("Document name is empty");
-        }
-
-        final String sanitized = displayName.trim();
-        if (sanitized.isEmpty() || ".".equals(sanitized) || "..".equals(sanitized) ||
-            sanitized.contains("/") || sanitized.contains("\\"))
-        {
-            throw new FileNotFoundException("Invalid document name: " + displayName);
-        }
-        return sanitized;
-    }
-
-    private static File buildUniqueFile(File parent, String displayName) {
-        File file = new File(parent, displayName);
-        if (!file.exists()) {
-            return file;
-        }
-
-        final int dot = displayName.lastIndexOf('.');
-        final String baseName = dot > 0 ? displayName.substring(0, dot) : displayName;
-        final String extension = dot > 0 ? displayName.substring(dot) : "";
-        for (int i = 1; i < 100; ++i) {
-            file = new File(parent, baseName + " (" + i + ")" + extension);
-            if (!file.exists()) {
-                return file;
-            }
-        }
-        return new File(parent, baseName + " (" + System.currentTimeMillis() + ")" + extension);
-    }
-
-    private static int modeToParcelMode(String mode) {
-        if ("r".equals(mode)) {
-            return ParcelFileDescriptor.MODE_READ_ONLY;
-        }
-        if ("w".equals(mode) || "wt".equals(mode)) {
-            return ParcelFileDescriptor.MODE_WRITE_ONLY |
-                ParcelFileDescriptor.MODE_CREATE |
-                ParcelFileDescriptor.MODE_TRUNCATE;
-        }
-        if ("wa".equals(mode)) {
-            return ParcelFileDescriptor.MODE_WRITE_ONLY |
-                ParcelFileDescriptor.MODE_CREATE |
-                ParcelFileDescriptor.MODE_APPEND;
-        }
-        if ("rw".equals(mode)) {
-            return ParcelFileDescriptor.MODE_READ_WRITE |
-                ParcelFileDescriptor.MODE_CREATE;
-        }
-        if ("rwt".equals(mode)) {
-            return ParcelFileDescriptor.MODE_READ_WRITE |
-                ParcelFileDescriptor.MODE_CREATE |
-                ParcelFileDescriptor.MODE_TRUNCATE;
-        }
-        return ParcelFileDescriptor.MODE_READ_ONLY;
-    }
-
-    private static String getMimeType(File file) {
-        final int dot = file.getName().lastIndexOf('.');
-        if (dot >= 0) {
-            final String extension = file.getName().substring(dot + 1).toLowerCase();
-            final String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
-            if (mimeType != null) {
-                return mimeType;
-            }
-        }
-        return "application/octet-stream";
-    }
-
-    private Uri getChildDocumentsUri(String parentDocumentId) {
-        return DocumentsContract.buildChildDocumentsUri(AUTHORITY, parentDocumentId);
-    }
-
-    private void notifyChildrenChanged(String parentDocumentId) {
-        final ContentResolver resolver = getContext().getContentResolver();
-        resolver.notifyChange(getChildDocumentsUri(parentDocumentId), null, false);
-    }
-
-    private void notifyDocumentChanged(String documentId) {
-        final ContentResolver resolver = getContext().getContentResolver();
-        resolver.notifyChange(DocumentsContract.buildDocumentUri(AUTHORITY, documentId), null, false);
-    }
-
-    private static void deleteRecursively(File file) throws FileNotFoundException {
-        if (file.isDirectory()) {
-            final File[] children = file.listFiles();
-            if (children != null) {
-                for (File child : children) {
-                    deleteRecursively(child);
-                }
-            }
-        }
-        if (!file.delete()) {
-            throw new FileNotFoundException("Unable to delete document: " + file);
-        }
-    }
-
-    private static boolean isInside(File parent, File child) {
-        try {
-            final String parentPath = canonicalPath(parent);
-            final String childPath = canonicalPath(child);
-            return childPath.equals(parentPath) || childPath.startsWith(parentPath + File.separator);
-        } catch (FileNotFoundException e) {
-            return false;
-        }
-    }
-
-    private static boolean sameFile(File a, File b) {
-        try {
-            return canonicalPath(a).equals(canonicalPath(b));
-        } catch (FileNotFoundException e) {
-            return false;
-        }
-    }
-
-    private static String canonicalPath(File file) throws FileNotFoundException {
-        try {
-            return file.getCanonicalPath();
-        } catch (IOException e) {
-            throw asFileNotFound("Unable to resolve path", e);
-        }
-    }
-
-    private static FileNotFoundException asFileNotFound(String message, IOException cause) {
-        final FileNotFoundException exception = new FileNotFoundException(message + ": " + cause.getMessage());
-        exception.initCause(cause);
-        return exception;
-    }
-}
diff --git a/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskHttpClient.java b/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskHttpClient.java
deleted file mode 100644
index be160d6a2d..0000000000
--- a/platforms/android/app/src/main/java/com/twilitrealm/dusk/DuskHttpClient.java
+++ /dev/null
@@ -1,237 +0,0 @@
-package dev.twilitrealm.dusk;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.HttpURLConnection;
-import java.net.MalformedURLException;
-import java.net.SocketTimeoutException;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import javax.net.ssl.HttpsURLConnection;
-
-public final class DuskHttpClient {
-    public static final int ERROR_NONE = 0;
-    public static final int ERROR_INVALID_URL = 1;
-    public static final int ERROR_UNSUPPORTED_SCHEME = 2;
-    public static final int ERROR_TIMEOUT = 3;
-    public static final int ERROR_TOO_LARGE = 4;
-    public static final int ERROR_NETWORK = 5;
-
-    private static final int MAX_REDIRECTS = 5;
-
-    public static final class Response {
-        public int error;
-        public String message;
-        public int statusCode;
-        public String[] headerNames;
-        public String[] headerValues;
-        public byte[] body;
-
-        Response(int error, String message, int statusCode, String[] headerNames,
-                 String[] headerValues, byte[] body) {
-            this.error = error;
-            this.message = message;
-            this.statusCode = statusCode;
-            this.headerNames = headerNames != null ? headerNames : new String[0];
-            this.headerValues = headerValues != null ? headerValues : new String[0];
-            this.body = body != null ? body : new byte[0];
-        }
-    }
-
-    private DuskHttpClient() {
-    }
-
-    public static Response get(String url, String[] headerNames, String[] headerValues,
-                               int timeoutMs, long maxBodyBytes) {
-        if (url == null || url.isEmpty()) {
-            return fail(ERROR_INVALID_URL, "URL is empty");
-        }
-
-        try {
-            URL currentUrl = new URL(url);
-            if (!isHttps(currentUrl)) {
-                return fail(ERROR_UNSUPPORTED_SCHEME, "Only https:// URLs are supported");
-            }
-
-            for (int redirect = 0; redirect <= MAX_REDIRECTS; ++redirect) {
-                HttpsURLConnection connection =
-                        (HttpsURLConnection) currentUrl.openConnection();
-                try {
-                    connection.setRequestMethod("GET");
-                    connection.setConnectTimeout(timeoutMs);
-                    connection.setReadTimeout(timeoutMs);
-                    connection.setUseCaches(false);
-                    connection.setInstanceFollowRedirects(false);
-                    applyHeaders(connection, headerNames, headerValues);
-
-                    int statusCode = connection.getResponseCode();
-                    if (isRedirect(statusCode)) {
-                        String location = connection.getHeaderField("Location");
-                        if (location == null || location.isEmpty()) {
-                            return fail(ERROR_NETWORK, "Redirect response did not include Location",
-                                    statusCode, connection, new byte[0]);
-                        }
-
-                        URL nextUrl = new URL(currentUrl, location);
-                        if (!isHttps(nextUrl)) {
-                            return fail(ERROR_UNSUPPORTED_SCHEME,
-                                    "Only https:// redirects are supported", statusCode,
-                                    connection, new byte[0]);
-                        }
-                        currentUrl = nextUrl;
-                        continue;
-                    }
-
-                    byte[] body = readBody(connection, statusCode, maxBodyBytes);
-                    return success(statusCode, connection, body);
-                } catch (ResponseTooLargeException e) {
-                    return fail(ERROR_TOO_LARGE, "Response body exceeded the configured limit",
-                            safeStatusCode(connection), connection, e.partialBody);
-                } finally {
-                    connection.disconnect();
-                }
-            }
-
-            return fail(ERROR_NETWORK, "Too many redirects");
-        } catch (MalformedURLException e) {
-            return fail(ERROR_INVALID_URL, "Failed to parse URL");
-        } catch (SocketTimeoutException e) {
-            return fail(ERROR_TIMEOUT, "Request timed out");
-        } catch (IOException e) {
-            String message = e.getMessage();
-            return fail(ERROR_NETWORK, message != null ? message : e.toString());
-        } catch (ClassCastException e) {
-            return fail(ERROR_UNSUPPORTED_SCHEME, "Only https:// URLs are supported");
-        }
-    }
-
-    private static void applyHeaders(HttpsURLConnection connection, String[] names,
-                                     String[] values) {
-        if (names == null || values == null) {
-            return;
-        }
-
-        int count = Math.min(names.length, values.length);
-        for (int i = 0; i < count; ++i) {
-            if (names[i] != null && values[i] != null) {
-                connection.setRequestProperty(names[i], values[i]);
-            }
-        }
-    }
-
-    private static boolean isHttps(URL url) {
-        return "https".equalsIgnoreCase(url.getProtocol());
-    }
-
-    private static boolean isRedirect(int statusCode) {
-        return statusCode == HttpURLConnection.HTTP_MOVED_PERM ||
-                statusCode == HttpURLConnection.HTTP_MOVED_TEMP ||
-                statusCode == HttpURLConnection.HTTP_SEE_OTHER ||
-                statusCode == 307 ||
-                statusCode == 308;
-    }
-
-    private static byte[] readBody(HttpsURLConnection connection, int statusCode,
-                                   long maxBodyBytes) throws IOException,
-            ResponseTooLargeException {
-        InputStream stream = statusCode >= HttpURLConnection.HTTP_BAD_REQUEST ?
-                connection.getErrorStream() : connection.getInputStream();
-        if (stream == null) {
-            return new byte[0];
-        }
-
-        try (InputStream bodyStream = stream;
-             ByteArrayOutputStream out = new ByteArrayOutputStream()) {
-            byte[] buffer = new byte[8192];
-            long total = 0;
-            while (true) {
-                int read = bodyStream.read(buffer);
-                if (read < 0) {
-                    return out.toByteArray();
-                }
-                if (read == 0) {
-                    continue;
-                }
-                if (read > maxBodyBytes || total > maxBodyBytes - read) {
-                    throw new ResponseTooLargeException(out.toByteArray());
-                }
-                out.write(buffer, 0, read);
-                total += read;
-            }
-        }
-    }
-
-    private static int safeStatusCode(HttpsURLConnection connection) {
-        try {
-            return connection.getResponseCode();
-        } catch (IOException e) {
-            return 0;
-        }
-    }
-
-    private static Response success(int statusCode, HttpsURLConnection connection, byte[] body) {
-        HeaderLists headers = readHeaders(connection);
-        return new Response(ERROR_NONE, "", statusCode, headers.names, headers.values, body);
-    }
-
-    private static Response fail(int error, String message) {
-        return new Response(error, message, 0, null, null, null);
-    }
-
-    private static Response fail(int error, String message, int statusCode,
-                                 HttpsURLConnection connection, byte[] body) {
-        HeaderLists headers = readHeaders(connection);
-        return new Response(error, message, statusCode, headers.names, headers.values, body);
-    }
-
-    private static HeaderLists readHeaders(HttpsURLConnection connection) {
-        List<String> names = new ArrayList<>();
-        List<String> values = new ArrayList<>();
-
-        Map<String, List<String>> headerFields = connection.getHeaderFields();
-        if (headerFields == null) {
-            return new HeaderLists(new String[0], new String[0]);
-        }
-
-        for (Map.Entry<String, List<String>> entry : headerFields.entrySet()) {
-            String name = entry.getKey();
-            if (name == null) {
-                continue;
-            }
-            List<String> entryValues = entry.getValue();
-            if (entryValues == null || entryValues.isEmpty()) {
-                names.add(name);
-                values.add("");
-                continue;
-            }
-            for (String value : entryValues) {
-                names.add(name);
-                values.add(value != null ? value : "");
-            }
-        }
-
-        return new HeaderLists(names.toArray(new String[0]), values.toArray(new String[0]));
-    }
-
-    private static final class HeaderLists {
-        final String[] names;
-        final String[] values;
-
-        HeaderLists(String[] names, String[] values) {
-            this.names = names;
-            this.values = values;
-        }
-    }
-
-    private static final class ResponseTooLargeException extends Exception {
-        final byte[] partialBody;
-
-        ResponseTooLargeException(byte[] partialBody) {
-            this.partialBody = partialBody;
-        }
-    }
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/HIDDevice.java b/platforms/android/app/src/main/java/org/libsdl/app/HIDDevice.java
deleted file mode 100644
index f96095324b..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/HIDDevice.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package org.libsdl.app;
-
-import android.hardware.usb.UsbDevice;
-
-interface HIDDevice
-{
-    public int getId();
-    public int getVendorId();
-    public int getProductId();
-    public String getSerialNumber();
-    public int getVersion();
-    public String getManufacturerName();
-    public String getProductName();
-    public UsbDevice getDevice();
-    public boolean open();
-    public int writeReport(byte[] report, boolean feature);
-    public boolean readReport(byte[] report, boolean feature);
-    public void setFrozen(boolean frozen);
-    public void close();
-    public void shutdown();
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java b/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
deleted file mode 100644
index bcd8806c41..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
+++ /dev/null
@@ -1,829 +0,0 @@
-package org.libsdl.app;
-
-import android.content.Context;
-import android.bluetooth.BluetoothDevice;
-import android.bluetooth.BluetoothGatt;
-import android.bluetooth.BluetoothGattCallback;
-import android.bluetooth.BluetoothGattCharacteristic;
-import android.bluetooth.BluetoothGattDescriptor;
-import android.bluetooth.BluetoothManager;
-import android.bluetooth.BluetoothProfile;
-import android.bluetooth.BluetoothGattService;
-import android.hardware.usb.UsbDevice;
-import android.os.Handler;
-import android.os.Looper;
-import android.util.Log;
-import android.os.*;
-
-//import com.android.internal.util.HexDump;
-
-import java.lang.Runnable;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.UUID;
-
-import java.util.regex.Pattern;
-import java.util.regex.Matcher;
-
-class HIDDeviceBLESteamController extends BluetoothGattCallback implements HIDDevice {
-
-    private static final String TAG = "hidapi";
-    private HIDDeviceManager mManager;
-    private BluetoothDevice mDevice;
-    private int mDeviceId;
-    private BluetoothGatt mGatt;
-    private boolean mIsRegistered = false;
-    private boolean mIsConnected = false;
-    private boolean mIsChromebook = false;
-    private boolean mIsReconnecting = false;
-    private boolean mHasEnabledNotifications = false;
-    private boolean mHasSeenInputUpdate = false;
-    private boolean mFrozen = false;
-    private LinkedList<GattOperation> mOperations;
-    GattOperation mCurrentOperation = null;
-    private Handler mHandler;
-    private int mProductId = -1;
-    private int mReportId = 0;
-    private UUID mInputCharacteristic;
-
-    private static final int D0G_BLE2_PID = 0x1106;
-    private static final int TRITON_BLE_PID = 0x1303;
-
-
-    private static final int TRANSPORT_AUTO = 0;
-    private static final int TRANSPORT_BREDR = 1;
-    private static final int TRANSPORT_LE = 2;
-
-    private static final int CHROMEBOOK_CONNECTION_CHECK_INTERVAL = 10000;
-
-    static final UUID steamControllerService = UUID.fromString("100F6C32-1735-4313-B402-38567131E5F3");
-    static final UUID inputCharacteristicD0G = UUID.fromString("100F6C33-1735-4313-B402-38567131E5F3");
-    static final UUID inputCharacteristicTriton_0x45 = UUID.fromString("100F6C7A-1735-4313-B402-38567131E5F3");
-    static final UUID inputCharacteristicTriton_0x47 = UUID.fromString("100F6C7C-1735-4313-B402-38567131E5F3");
-    static final UUID reportCharacteristic = UUID.fromString("100F6C34-1735-4313-B402-38567131E5F3");
-    static private final byte[] enterValveMode = new byte[] { (byte)0xC0, (byte)0x87, 0x03, 0x08, 0x07, 0x00 };
-
-    private HashMap<Integer, BluetoothGattCharacteristic> mOutputReportChars = new HashMap<Integer, BluetoothGattCharacteristic>();
-
-    static class GattOperation {
-        private enum Operation {
-            CHR_READ,
-            CHR_WRITE,
-            ENABLE_NOTIFICATION
-        }
-
-        Operation mOp;
-        UUID mUuid;
-        byte[] mValue;
-        BluetoothGatt mGatt;
-        boolean mResult = true;
-        int mDelayMs = 0;
-
-        private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid) {
-            mGatt = gatt;
-            mOp = operation;
-            mUuid = uuid;
-        }
-
-        private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid, int delayMs) {
-            mGatt = gatt;
-            mOp = operation;
-            mUuid = uuid;
-            mDelayMs = delayMs;
-        }        
-
-        private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid, byte[] value) {
-            mGatt = gatt;
-            mOp = operation;
-            mUuid = uuid;
-            mValue = value;
-        }
-
-        private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid, byte[] value, int delayMs) {
-            mGatt = gatt;
-            mOp = operation;
-            mUuid = uuid;
-            mValue = value;
-            mDelayMs = delayMs;
-        }
-
-        public void run() {
-            // This is executed in main thread
-            BluetoothGattCharacteristic chr;
-
-            switch (mOp) {
-                case CHR_READ:
-                    chr = getCharacteristic(mUuid);
-                    //Log.v(TAG, "Reading characteristic " + chr.getUuid());
-                    if (!mGatt.readCharacteristic(chr)) {
-                        Log.e(TAG, "Unable to read characteristic " + mUuid.toString());
-                        mResult = false;
-                        break;
-                    }
-                    mResult = true;
-                    break;
-                case CHR_WRITE:
-                    chr = getCharacteristic(mUuid);
-                    //Log.v(TAG, "Writing characteristic " + chr.getUuid() + " value=" + HexDump.toHexString(value));
-                    chr.setValue(mValue);
-                    if (!mGatt.writeCharacteristic(chr)) {
-                        Log.e(TAG, "Unable to write characteristic " + mUuid.toString());
-                        mResult = false;
-                        break;
-                    }
-                    mResult = true;
-                    break;
-                case ENABLE_NOTIFICATION:
-                    chr = getCharacteristic(mUuid);
-                    //Log.v(TAG, "Writing descriptor of " + chr.getUuid());
-                    if (chr != null) {
-                        BluetoothGattDescriptor cccd = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
-                        if (cccd != null) {
-                            int properties = chr.getProperties();
-                            byte[] value;
-                            if ((properties & BluetoothGattCharacteristic.PROPERTY_NOTIFY) == BluetoothGattCharacteristic.PROPERTY_NOTIFY) {
-                                value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE;
-                            } else if ((properties & BluetoothGattCharacteristic.PROPERTY_INDICATE) == BluetoothGattCharacteristic.PROPERTY_INDICATE) {
-                                value = BluetoothGattDescriptor.ENABLE_INDICATION_VALUE;
-                            } else {
-                                Log.e(TAG, "Unable to start notifications on input characteristic");
-                                mResult = false;
-                                return;
-                            }
-
-                            mGatt.setCharacteristicNotification(chr, true);
-                            cccd.setValue(value);
-                            if (!mGatt.writeDescriptor(cccd)) {
-                                Log.e(TAG, "Unable to write descriptor " + mUuid.toString());
-                                mResult = false;
-                                return;
-                            }
-                            mResult = true;
-                        }
-                    }
-            }
-        }
-
-        public boolean finish() {
-            return mResult;
-        }
-
-        public int getDelayMs() { return mDelayMs; }
-
-        private BluetoothGattCharacteristic getCharacteristic(UUID uuid) {
-            BluetoothGattService valveService = mGatt.getService(steamControllerService);
-            if (valveService == null)
-                return null;
-            return valveService.getCharacteristic(uuid);
-        }
-
-        static public GattOperation readCharacteristic(BluetoothGatt gatt, UUID uuid) {
-            return new GattOperation(gatt, Operation.CHR_READ, uuid);
-        }
-
-        static public GattOperation writeCharacteristic(BluetoothGatt gatt, UUID uuid, byte[] value) {
-            return new GattOperation(gatt, Operation.CHR_WRITE, uuid, value);
-        }
-
-        static public GattOperation enableNotification(BluetoothGatt gatt, UUID uuid) {
-            return new GattOperation(gatt, Operation.ENABLE_NOTIFICATION, uuid);
-        }
-
-        static public GattOperation enableNotification(BluetoothGatt gatt, UUID uuid, int delayMs) {
-            return new GattOperation(gatt, Operation.ENABLE_NOTIFICATION, uuid, delayMs);
-        }
-    }
-
-    HIDDeviceBLESteamController(HIDDeviceManager manager, BluetoothDevice device) {
-        mManager = manager;
-        mDevice = device;
-        mDeviceId = mManager.getDeviceIDForIdentifier(getIdentifier());
-        mIsRegistered = false;
-        mIsChromebook = SDLActivity.isChromebook();
-        mOperations = new LinkedList<GattOperation>();
-        mHandler = new Handler(Looper.getMainLooper());
-
-        mGatt = connectGatt();
-        mHasEnabledNotifications = false;
-        mHasSeenInputUpdate = false;
-        // final HIDDeviceBLESteamController finalThis = this;
-        // mHandler.postDelayed(new Runnable() {
-        //     @Override
-        //     void run() {
-        //         finalThis.checkConnectionForChromebookIssue();
-        //     }
-        // }, CHROMEBOOK_CONNECTION_CHECK_INTERVAL);
-    }
-
-    String getIdentifier() {
-        return String.format("SteamController.%s", mDevice.getAddress());
-    }
-
-    BluetoothGatt getGatt() {
-        return mGatt;
-    }
-
-    // Because on Chromebooks we show up as a dual-mode device, it will attempt to connect TRANSPORT_AUTO, which will use TRANSPORT_BREDR instead
-    // of TRANSPORT_LE.  Let's force ourselves to connect low energy.
-    private BluetoothGatt connectGatt(boolean managed) {
-        if (Build.VERSION.SDK_INT >= 23 /* Android 6.0 (M) */) {
-            try {
-                return mDevice.connectGatt(mManager.getContext(), managed, this, TRANSPORT_LE);
-            } catch (Exception e) {
-                return mDevice.connectGatt(mManager.getContext(), managed, this);
-            }
-        } else {
-            return mDevice.connectGatt(mManager.getContext(), managed, this);
-        }
-    }
-
-    private BluetoothGatt connectGatt() {
-        return connectGatt(false);
-    }
-
-    protected int getConnectionState() {
-
-        Context context = mManager.getContext();
-        if (context == null) {
-            // We are lacking any context to get our Bluetooth information.  We'll just assume disconnected.
-            return BluetoothProfile.STATE_DISCONNECTED;
-        }
-
-        BluetoothManager btManager = (BluetoothManager)context.getSystemService(Context.BLUETOOTH_SERVICE);
-        if (btManager == null) {
-            // This device doesn't support Bluetooth.  We should never be here, because how did
-            // we instantiate a device to start with?
-            return BluetoothProfile.STATE_DISCONNECTED;
-        }
-
-        return btManager.getConnectionState(mDevice, BluetoothProfile.GATT);
-    }
-
-    void reconnect() {
-
-        if (getConnectionState() != BluetoothProfile.STATE_CONNECTED) {
-            mGatt.disconnect();
-            mGatt = connectGatt();
-        }
-
-    }
-
-    protected void checkConnectionForChromebookIssue() {
-        if (!mIsChromebook) {
-            // We only do this on Chromebooks, because otherwise it's really annoying to just attempt
-            // over and over.
-            return;
-        }
-
-        int connectionState = getConnectionState();
-
-        switch (connectionState) {
-            case BluetoothProfile.STATE_CONNECTED:
-                if (!mIsConnected) {
-                    // We are in the Bad Chromebook Place.  We can force a disconnect
-                    // to try to recover.
-                    Log.v(TAG, "Chromebook: We are in a very bad state; the controller shows as connected in the underlying Bluetooth layer, but we never received a callback.  Forcing a reconnect.");
-                    mIsReconnecting = true;
-                    mGatt.disconnect();
-                    mGatt = connectGatt(false);
-                    break;
-                }
-                else if (!isRegistered()) {
-                    if (mGatt.getServices().size() > 0) {
-                        Log.v(TAG, "Chromebook: We are connected to a controller, but never got our registration.  Trying to recover.");
-                        probeService(this);
-                    }
-                    else {
-                        Log.v(TAG, "Chromebook: We are connected to a controller, but never discovered services.  Trying to recover.");
-                        mIsReconnecting = true;
-                        mGatt.disconnect();
-                        mGatt = connectGatt(false);
-                        break;
-                    }
-                }
-                else {
-                    Log.v(TAG, "Chromebook: We are connected, and registered.  Everything's good!");
-                    return;
-                }
-                break;
-
-            case BluetoothProfile.STATE_DISCONNECTED:
-                Log.v(TAG, "Chromebook: We have either been disconnected, or the Chromebook BtGatt.ContextMap bug has bitten us.  Attempting a disconnect/reconnect, but we may not be able to recover.");
-
-                mIsReconnecting = true;
-                mGatt.disconnect();
-                mGatt = connectGatt(false);
-                break;
-
-            case BluetoothProfile.STATE_CONNECTING:
-                Log.v(TAG, "Chromebook: We're still trying to connect.  Waiting a bit longer.");
-                break;
-        }
-
-        final HIDDeviceBLESteamController finalThis = this;
-        mHandler.postDelayed(new Runnable() {
-            @Override
-            public void run() {
-                finalThis.checkConnectionForChromebookIssue();
-            }
-        }, CHROMEBOOK_CONNECTION_CHECK_INTERVAL);
-    }
-
-    private boolean isRegistered() {
-        return mIsRegistered;
-    }
-
-    private void setRegistered() {
-        mIsRegistered = true;
-    }
-
-    private boolean probeService(HIDDeviceBLESteamController controller) {
-
-        if (isRegistered()) {
-            return true;
-        }
-
-        if (!mIsConnected) {
-            return false;
-        }
-
-        Log.v(TAG, "probeService controller=" + controller);
-
-        for (BluetoothGattService service : mGatt.getServices()) {
-            if (service.getUuid().equals(steamControllerService)) {
-                Log.v(TAG, "Found Valve steam controller service " + service.getUuid());
-
-                for (BluetoothGattCharacteristic chr : service.getCharacteristics()) {
-                    if (chr.getUuid().equals(inputCharacteristicTriton_0x45)) {
-                        Log.v(TAG, "Found Triton input characteristic 0x45");
-                        mProductId = TRITON_BLE_PID;
-                        mReportId = 0x45;
-                        mInputCharacteristic = chr.getUuid();
-                    } else if (chr.getUuid().equals(inputCharacteristicTriton_0x47)) {
-                        Log.v(TAG, "Found Triton input characteristic 0x47");
-                        mProductId = TRITON_BLE_PID;
-                        mReportId = 0x47;
-                        mInputCharacteristic = chr.getUuid();
-                    } else if (chr.getUuid().equals(inputCharacteristicD0G)) {
-                        Log.v(TAG, "Found D0G input characteristic");
-                        mProductId = D0G_BLE2_PID;
-                        mReportId = 0x03;
-                        mInputCharacteristic = chr.getUuid();
-                    } else {
-                        Pattern reportPattern = Pattern.compile("100F6C([0-9A-Z]{2})", Pattern.CASE_INSENSITIVE);
-                        Matcher matcher = reportPattern.matcher(chr.getUuid().toString());
-
-                        if (matcher.find()) {
-                            try {
-                                int reportId = Integer.parseInt(matcher.group(1), 16);
-
-                                reportId -= 0x35;
-                                if (reportId >= 0x80) {
-                                    // This is a Triton output report characteristic that we need to care about.
-                                    Log.v(TAG, "Found Triton output report 0x" + Integer.toString(reportId, 16));
-                                    mOutputReportChars.put(reportId, chr);
-                                }
-                            }
-                            catch (NumberFormatException nfe) {
-                                Log.w(TAG, "Could not parse report characteristic " + chr.getUuid().toString() + ": " + nfe.toString());
-                            }
-                        }
-                    }
-                }
-
-                for (BluetoothGattCharacteristic chr : service.getCharacteristics()) {
-                    if (chr.getUuid().equals(mInputCharacteristic)) {
-                        // Start notifications
-                        BluetoothGattDescriptor cccd = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
-                        if (cccd != null) {
-                            enableNotification(chr.getUuid());
-                        }
-                    }
-                }
-                return true;
-            }
-        }
-
-        if ((mGatt.getServices().size() == 0) && mIsChromebook && !mIsReconnecting) {
-            Log.e(TAG, "Chromebook: Discovered services were empty; this almost certainly means the BtGatt.ContextMap bug has bitten us.");
-            mIsConnected = false;
-            mIsReconnecting = true;
-            mGatt.disconnect();
-            mGatt = connectGatt(false);
-        }
-
-        return false;
-    }
-
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private void finishCurrentGattOperation() {
-        GattOperation op = null;
-        synchronized (mOperations) {
-            if (mCurrentOperation != null) {
-                op = mCurrentOperation;
-                mCurrentOperation = null;
-            }
-        }
-        if (op != null) {
-            boolean result = op.finish(); // TODO: Maybe in main thread as well?
-
-            // Our operation failed, let's add it back to the beginning of our queue.
-            if (!result) {
-                mOperations.addFirst(op);
-            }
-        }
-        executeNextGattOperation();
-    }
-
-    private void executeNextGattOperation() {
-        synchronized (mOperations) {
-            if (mCurrentOperation != null)
-                return;
-
-            if (mOperations.isEmpty())
-                return;
-
-            mCurrentOperation = mOperations.removeFirst();
-        }
-
-        Runnable gattOperationRunnable = new Runnable() {
-                @Override
-                public void run() {
-                    synchronized (mOperations) {
-                        if (mCurrentOperation == null) {
-                            Log.e(TAG, "Current operation null in executor?");
-                            return;
-                        }
-
-                        mCurrentOperation.run();
-                        // now wait for the GATT callback and when it comes, finish this operation
-                    }
-                }
-            };
-
-        if (mCurrentOperation.getDelayMs() == 0) {
-            // Run in main thread
-            mHandler.post(gattOperationRunnable);
-        }
-        else {
-            // If we have a delay on this operation, wait before we post it.
-            mHandler.postDelayed(gattOperationRunnable, mCurrentOperation.getDelayMs());
-        }
-
-    }
-
-    private void queueGattOperation(GattOperation op) {
-        synchronized (mOperations) {
-            mOperations.add(op);
-        }
-        executeNextGattOperation();
-    }
-
-    private void enableNotification(UUID chrUuid) {
-        // Add a 500ms delay to notification write for Amazon Fire TV devices, as otherwise if we do this too quickly after connecting
-        // it will return success and then silently drop the operation on the floor.
-        GattOperation op = HIDDeviceBLESteamController.GattOperation.enableNotification(mGatt, chrUuid, 500);
-        queueGattOperation(op);
-
-        // Amazon Fire devices can also silently timeout on writeDescriptor, so
-        // set up a little delayed check that will attempt to write a second time.
-        //
-        // While this only seems to be needed on Amazon Fire TV devices at present, it
-        // doesn't hurt to have a retry on other devices as well.
-        //
-        final HIDDeviceBLESteamController finalThis = this;
-        final UUID finalUuid = chrUuid;
-        mHandler.postDelayed(new Runnable() {
-            @Override
-            public void run() {
-                if (!finalThis.mHasEnabledNotifications) {
-
-                    if (finalThis.mHasSeenInputUpdate) {
-                        // Amazon Five devices may have enabled notifications on the input characteristic and not given us a callback. If we've seen
-                        // input reports, though, somewhat by definition notifications are enabled.
-                        Log.w(TAG, "WriteDescriptor has never returned, but we've seen input reports. Moving on with controller initialization.");
-                        finalThis.mHasEnabledNotifications = true;
-                        finalThis.enableValveMode();
-                        return;
-                    }
-
-                    // Give one more try.
-                    GattOperation retry = HIDDeviceBLESteamController.GattOperation.enableNotification(finalThis.mGatt, finalUuid, 500);
-                    finalThis.queueGattOperation(retry);
-                }
-            }
-        }, 1000);            
-    }
-
-    void writeCharacteristic(UUID uuid, byte[] value) {
-        GattOperation op = HIDDeviceBLESteamController.GattOperation.writeCharacteristic(mGatt, uuid, value);
-        queueGattOperation(op);
-    }
-
-    void readCharacteristic(UUID uuid) {
-        GattOperation op = HIDDeviceBLESteamController.GattOperation.readCharacteristic(mGatt, uuid);
-        queueGattOperation(op);
-    }
-
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    //////////////  BluetoothGattCallback overridden methods
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    @Override
-    public void onConnectionStateChange(BluetoothGatt g, int status, int newState) {
-        //Log.v(TAG, "onConnectionStateChange status=" + status + " newState=" + newState);
-        mIsReconnecting = false;
-        if (newState == 2) {
-            mIsConnected = true;
-            // Run directly, without GattOperation
-            if (!isRegistered()) {
-                mHandler.post(new Runnable() {
-                    @Override
-                    public void run() {
-                        mGatt.discoverServices();
-                    }
-                });
-            }
-        }
-        else if (newState == 0) {
-            mIsConnected = false;
-        }
-
-        // Disconnection is handled in SteamLink using the ACTION_ACL_DISCONNECTED Intent.
-    }
-
-    @Override
-    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
-        //Log.v(TAG, "onServicesDiscovered status=" + status);
-        if (status == 0) {
-            if (gatt.getServices().size() == 0) {
-                Log.v(TAG, "onServicesDiscovered returned zero services; something has gone horribly wrong down in Android's Bluetooth stack.");
-                mIsReconnecting = true;
-                mIsConnected = false;
-                gatt.disconnect();
-                mGatt = connectGatt(false);
-            } else {
-                if (getProductId() == TRITON_BLE_PID) {
-                    // Android will not properly play well with Data Length Extensions without manually requesting a large MTU,
-                    // and Triton controllers require DLE support.
-                    //
-                    // 517 is basically a "magic number" as far as Android's bluetooth code is concerned, so do not change
-                    // this value. It is functionally "please enable data length extensions" on some Android builds.
-                    mGatt.requestMtu(517);
-                }
-
-                probeService(this);
-            }
-        }
-    }
-
-    @Override
-    public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
-        //Log.v(TAG, "onCharacteristicRead status=" + status + " uuid=" + characteristic.getUuid());
-
-        if (characteristic.getUuid().equals(reportCharacteristic) && !mFrozen) {
-            mManager.HIDDeviceReportResponse(getId(), characteristic.getValue());
-        }
-
-        finishCurrentGattOperation();
-    }
-
-    @Override
-    public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
-        //Log.v(TAG, "onCharacteristicWrite status=" + status + " uuid=" + characteristic.getUuid());
-
-        if (characteristic.getUuid().equals(reportCharacteristic)) {
-            // Only register controller with the native side once it has been fully configured
-            if (!isRegistered()) {
-                Log.v(TAG, "Registering Steam Controller with ID: " + getId());
-                mManager.HIDDeviceConnected(getId(), getIdentifier(), getVendorId(), getProductId(), getSerialNumber(), getVersion(), getManufacturerName(), getProductName(), 0, 0, 0, 0, true, mReportId);
-                setRegistered();
-            }
-        }
-
-        finishCurrentGattOperation();
-    }
-
-    @Override
-    public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
-    // Enable this for verbose logging of controller input reports
-        //Log.v(TAG, "onCharacteristicChanged uuid=" + characteristic.getUuid() + " data=" + HexDump.dumpHexString(characteristic.getValue()));
-
-        if (characteristic.getUuid().equals(mInputCharacteristic) && !mFrozen) {
-            mHasSeenInputUpdate = true;
-            mManager.HIDDeviceInputReport(getId(), characteristic.getValue());
-        }
-    }
-
-    @Override
-    public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
-        //Log.v(TAG, "onDescriptorRead status=" + status);
-    }
-
-    private void enableValveMode()
-    {
-        BluetoothGattService valveService = mGatt.getService(steamControllerService);
-        if (valveService == null)
-            return;
-
-        BluetoothGattCharacteristic reportChr = valveService.getCharacteristic(reportCharacteristic);
-        if (reportChr != null) {
-            if (getProductId() == TRITON_BLE_PID) {
-                // For Triton we just mark things registered.
-                Log.v(TAG, "Registering Triton Steam Controller with ID: " + getId());
-                mManager.HIDDeviceConnected(getId(), getIdentifier(), getVendorId(), getProductId(), getSerialNumber(), getVersion(), getManufacturerName(), getProductName(), 0, 0, 0, 0, true, mReportId);
-                setRegistered();
-            } else {
-                // For the original controller, we need to manually enter Valve mode.
-                Log.v(TAG, "Writing report characteristic to enter valve mode");
-                reportChr.setValue(enterValveMode);
-                mGatt.writeCharacteristic(reportChr);
-            }
-        }
-    }
-
-    @Override
-    public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
-        BluetoothGattCharacteristic chr = descriptor.getCharacteristic();
-        //Log.v(TAG, "onDescriptorWrite status=" + status + " uuid=" + chr.getUuid() + " descriptor=" + descriptor.getUuid());
-
-        if (chr.getUuid().equals(mInputCharacteristic)) {
-            mHasEnabledNotifications = true;
-            enableValveMode();
-        }
-
-        finishCurrentGattOperation();
-    }
-
-    @Override
-    public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
-        //Log.v(TAG, "onReliableWriteCompleted status=" + status);
-    }
-
-    @Override
-    public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
-        //Log.v(TAG, "onReadRemoteRssi status=" + status);
-    }
-
-    @Override
-    public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
-        //Log.v(TAG, "onMtuChanged status=" + status);
-    }
-
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    //////// Public API
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    @Override
-    public int getId() {
-        return mDeviceId;
-    }
-
-    @Override
-    public int getVendorId() {
-        // Valve Corporation
-        final int VALVE_USB_VID = 0x28DE;
-        return VALVE_USB_VID;
-    }
-
-    @Override
-    public int getProductId() {
-        if (mProductId > 0) {
-            // We've already set a product ID.
-            return mProductId;
-        }
-
-        if (mDevice.getName().startsWith("Steam Ctrl")) {
-            // We're a newer Triton device
-            mProductId = TRITON_BLE_PID;
-        } else {
-            // We're an OG Steam Controller
-            mProductId = D0G_BLE2_PID;
-        }
-
-        return mProductId;
-    }
-
-    @Override
-    public String getSerialNumber() {
-        // This will be read later via feature report by Steam
-        return "12345";
-    }
-
-    @Override
-    public int getVersion() {
-        return 0;
-    }
-
-    @Override
-    public String getManufacturerName() {
-        return "Valve Corporation";
-    }
-
-    @Override
-    public String getProductName() {
-        return "Steam Controller";
-    }
-
-    @Override
-    public UsbDevice getDevice() {
-        return null;
-    }
-
-    @Override
-    public boolean open() {
-        return true;
-    }
-
-    @Override
-    public int writeReport(byte[] report, boolean feature) {
-        if (!isRegistered()) {
-            Log.e(TAG, "Attempted writeReport before Steam Controller is registered!");
-            if (mIsConnected) {
-                probeService(this);
-            }
-            return -1;
-        }
-
-        if (feature) {
-            // We need to skip the first byte, as that doesn't go over the air
-            byte[] actual_report = Arrays.copyOfRange(report, 1, report.length - 1);
-            //Log.v(TAG, "writeFeatureReport " + HexDump.dumpHexString(actual_report));
-            writeCharacteristic(reportCharacteristic, actual_report);
-            return report.length;
-        } else {
-            // If we're an original-recipe Steam Controller we just write to the characteristic directly.
-            if (getProductId() == D0G_BLE2_PID) {
-                //Log.v(TAG, "writeOutputReport " + HexDump.dumpHexString(report));
-                writeCharacteristic(reportCharacteristic, report);
-                return report.length;
-            }
-
-            // If we're a Triton, we need to find the correct report characteristic.
-            if (report.length > 0) {
-                int reportId = report[0] & 0xFF;
-                BluetoothGattCharacteristic targetedReportCharacteristic = mOutputReportChars.get(reportId);
-                if (targetedReportCharacteristic != null) {
-                    byte[] actual_report = Arrays.copyOfRange(report, 1, report.length - 1);
-                    //Log.v(TAG, "writeOutputReport 0x" + Integer.toString(reportId, 16) + " " + HexDump.dumpHexString(report));
-                    writeCharacteristic(targetedReportCharacteristic.getUuid(), actual_report);
-                    return report.length;
-                } else {
-                    Log.w(TAG, "Got report write request for unknown report type 0x" + Integer.toString(reportId, 16));
-                }
-            }
-        }
-
-        return -1;
-    }
-
-    @Override
-    public boolean readReport(byte[] report, boolean feature) {
-        if (!isRegistered()) {
-            Log.e(TAG, "Attempted readReport before Steam Controller is registered!");
-            if (mIsConnected) {
-                probeService(this);
-            }
-            return false;
-        }
-
-        if (feature) {
-            readCharacteristic(reportCharacteristic);
-            return true;
-        } else {
-            // Not implemented
-            return false;
-        }
-    }
-
-    @Override
-    public void close() {
-    }
-
-    @Override
-    public void setFrozen(boolean frozen) {
-        mFrozen = frozen;
-    }
-
-    @Override
-    public void shutdown() {
-        close();
-
-        BluetoothGatt g = mGatt;
-        if (g != null) {
-            g.disconnect();
-            g.close();
-            mGatt = null;
-        }
-        mManager = null;
-        mIsRegistered = false;
-        mIsConnected = false;
-        mOperations.clear();
-    }
-
-}
-
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceManager.java b/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceManager.java
deleted file mode 100644
index 691416c1c9..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceManager.java
+++ /dev/null
@@ -1,698 +0,0 @@
-package org.libsdl.app;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.app.PendingIntent;
-import android.bluetooth.BluetoothAdapter;
-import android.bluetooth.BluetoothDevice;
-import android.bluetooth.BluetoothManager;
-import android.bluetooth.BluetoothProfile;
-import android.os.Build;
-import android.util.Log;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.content.SharedPreferences;
-import android.content.pm.PackageManager;
-import android.hardware.usb.*;
-import android.os.Handler;
-import android.os.Looper;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-
-public class HIDDeviceManager {
-    private static final String TAG = "hidapi";
-    private static final String ACTION_USB_PERMISSION = "org.libsdl.app.USB_PERMISSION";
-
-    private static HIDDeviceManager sManager;
-    private static int sManagerRefCount = 0;
-
-    static public HIDDeviceManager acquire(Context context) {
-        if (sManagerRefCount == 0) {
-            sManager = new HIDDeviceManager(context);
-        }
-        ++sManagerRefCount;
-        return sManager;
-    }
-
-    static public void release(HIDDeviceManager manager) {
-        if (manager == sManager) {
-            --sManagerRefCount;
-            if (sManagerRefCount == 0) {
-                sManager.close();
-                sManager = null;
-            }
-        }
-    }
-
-    private Context mContext;
-    private HashMap<Integer, HIDDevice> mDevicesById = new HashMap<Integer, HIDDevice>();
-    private HashMap<BluetoothDevice, HIDDeviceBLESteamController> mBluetoothDevices = new HashMap<BluetoothDevice, HIDDeviceBLESteamController>();
-    private int mNextDeviceId = 0;
-    private SharedPreferences mSharedPreferences = null;
-    private boolean mIsChromebook = false;
-    private UsbManager mUsbManager;
-    private Handler mHandler;
-    private BluetoothManager mBluetoothManager;
-    private List<BluetoothDevice> mLastBluetoothDevices;
-
-    private final BroadcastReceiver mUsbBroadcast = new BroadcastReceiver() {
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            String action = intent.getAction();
-            if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
-                UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
-                handleUsbDeviceAttached(usbDevice);
-            } else if (action.equals(UsbManager.ACTION_USB_DEVICE_DETACHED)) {
-                UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
-                handleUsbDeviceDetached(usbDevice);
-            } else if (action.equals(HIDDeviceManager.ACTION_USB_PERMISSION)) {
-                UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
-                handleUsbDevicePermission(usbDevice, intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false));
-            }
-        }
-    };
-
-    private final BroadcastReceiver mBluetoothBroadcast = new BroadcastReceiver() {
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            String action = intent.getAction();
-            // Bluetooth device was connected. If it was a Steam Controller, handle it
-            if (action.equals(BluetoothDevice.ACTION_ACL_CONNECTED)) {
-                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
-                Log.d(TAG, "Bluetooth device connected: " + device);
-
-                if (isSteamController(device)) {
-                    connectBluetoothDevice(device);
-                }
-            }
-
-            // Bluetooth device was disconnected, remove from controller manager (if any)
-            if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) {
-                BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
-                Log.d(TAG, "Bluetooth device disconnected: " + device);
-
-                disconnectBluetoothDevice(device);
-            }
-        }
-    };
-
-    private HIDDeviceManager(final Context context) {
-        mContext = context;
-
-        HIDDeviceRegisterCallback();
-
-        mSharedPreferences = mContext.getSharedPreferences("hidapi", Context.MODE_PRIVATE);
-        mIsChromebook = SDLActivity.isChromebook();
-
-//        if (shouldClear) {
-//            SharedPreferences.Editor spedit = mSharedPreferences.edit();
-//            spedit.clear();
-//            spedit.apply();
-//        }
-//        else
-        {
-            mNextDeviceId = mSharedPreferences.getInt("next_device_id", 0);
-        }
-    }
-
-    Context getContext() {
-        return mContext;
-    }
-
-    int getDeviceIDForIdentifier(String identifier) {
-        SharedPreferences.Editor spedit = mSharedPreferences.edit();
-
-        int result = mSharedPreferences.getInt(identifier, 0);
-        if (result == 0) {
-            result = mNextDeviceId++;
-            spedit.putInt("next_device_id", mNextDeviceId);
-        }
-
-        spedit.putInt(identifier, result);
-        spedit.apply();
-        return result;
-    }
-
-    private void initializeUSB() {
-        mUsbManager = (UsbManager)mContext.getSystemService(Context.USB_SERVICE);
-        if (mUsbManager == null) {
-            return;
-        }
-
-        /*
-        // Logging
-        for (UsbDevice device : mUsbManager.getDeviceList().values()) {
-            Log.i(TAG,"Path: " + device.getDeviceName());
-            Log.i(TAG,"Manufacturer: " + device.getManufacturerName());
-            Log.i(TAG,"Product: " + device.getProductName());
-            Log.i(TAG,"ID: " + device.getDeviceId());
-            Log.i(TAG,"Class: " + device.getDeviceClass());
-            Log.i(TAG,"Protocol: " + device.getDeviceProtocol());
-            Log.i(TAG,"Vendor ID " + device.getVendorId());
-            Log.i(TAG,"Product ID: " + device.getProductId());
-            Log.i(TAG,"Interface count: " + device.getInterfaceCount());
-            Log.i(TAG,"---------------------------------------");
-
-            // Get interface details
-            for (int index = 0; index < device.getInterfaceCount(); index++) {
-                UsbInterface mUsbInterface = device.getInterface(index);
-                Log.i(TAG,"  *****     *****");
-                Log.i(TAG,"  Interface index: " + index);
-                Log.i(TAG,"  Interface ID: " + mUsbInterface.getId());
-                Log.i(TAG,"  Interface class: " + mUsbInterface.getInterfaceClass());
-                Log.i(TAG,"  Interface subclass: " + mUsbInterface.getInterfaceSubclass());
-                Log.i(TAG,"  Interface protocol: " + mUsbInterface.getInterfaceProtocol());
-                Log.i(TAG,"  Endpoint count: " + mUsbInterface.getEndpointCount());
-
-                // Get endpoint details
-                for (int epi = 0; epi < mUsbInterface.getEndpointCount(); epi++)
-                {
-                    UsbEndpoint mEndpoint = mUsbInterface.getEndpoint(epi);
-                    Log.i(TAG,"    ++++   ++++   ++++");
-                    Log.i(TAG,"    Endpoint index: " + epi);
-                    Log.i(TAG,"    Attributes: " + mEndpoint.getAttributes());
-                    Log.i(TAG,"    Direction: " + mEndpoint.getDirection());
-                    Log.i(TAG,"    Number: " + mEndpoint.getEndpointNumber());
-                    Log.i(TAG,"    Interval: " + mEndpoint.getInterval());
-                    Log.i(TAG,"    Packet size: " + mEndpoint.getMaxPacketSize());
-                    Log.i(TAG,"    Type: " + mEndpoint.getType());
-                }
-            }
-        }
-        Log.i(TAG," No more devices connected.");
-        */
-
-        // Register for USB broadcasts and permission completions
-        IntentFilter filter = new IntentFilter();
-        filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
-        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
-        filter.addAction(HIDDeviceManager.ACTION_USB_PERMISSION);
-        if (Build.VERSION.SDK_INT >= 33) { /* Android 13.0 (TIRAMISU) */
-            mContext.registerReceiver(mUsbBroadcast, filter, Context.RECEIVER_EXPORTED);
-        } else {
-            mContext.registerReceiver(mUsbBroadcast, filter);
-        }
-
-        for (UsbDevice usbDevice : mUsbManager.getDeviceList().values()) {
-            handleUsbDeviceAttached(usbDevice);
-        }
-    }
-
-    UsbManager getUSBManager() {
-        return mUsbManager;
-    }
-
-    private void shutdownUSB() {
-        try {
-            mContext.unregisterReceiver(mUsbBroadcast);
-        } catch (Exception e) {
-            // We may not have registered, that's okay
-        }
-    }
-
-    private boolean isHIDDeviceInterface(UsbDevice usbDevice, UsbInterface usbInterface) {
-        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_HID) {
-            return true;
-        }
-        if (isXbox360Controller(usbDevice, usbInterface) || isXboxOneController(usbDevice, usbInterface)) {
-            return true;
-        }
-        return false;
-    }
-
-    private boolean isXbox360Controller(UsbDevice usbDevice, UsbInterface usbInterface) {
-        final int XB360_IFACE_SUBCLASS = 93;
-        final int XB360_IFACE_PROTOCOL = 1; // Wired
-        final int XB360W_IFACE_PROTOCOL = 129; // Wireless
-        final int[] SUPPORTED_VENDORS = {
-            0x0079, // GPD Win 2
-            0x044f, // Thrustmaster
-            0x045e, // Microsoft
-            0x046d, // Logitech
-            0x056e, // Elecom
-            0x06a3, // Saitek
-            0x0738, // Mad Catz
-            0x07ff, // Mad Catz
-            0x0e6f, // PDP
-            0x0f0d, // Hori
-            0x1038, // SteelSeries
-            0x11c9, // Nacon
-            0x12ab, // Unknown
-            0x1430, // RedOctane
-            0x146b, // BigBen
-            0x1532, // Razer Sabertooth
-            0x15e4, // Numark
-            0x162e, // Joytech
-            0x1689, // Razer Onza
-            0x1949, // Lab126, Inc.
-            0x1bad, // Harmonix
-            0x20d6, // PowerA
-            0x24c6, // PowerA
-            0x2c22, // Qanba
-            0x2dc8, // 8BitDo
-            0x3537, // GameSir
-            0x37d7, // Flydigi
-            0x9886, // ASTRO Gaming
-        };
-
-        if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_VENDOR_SPEC &&
-            usbInterface.getInterfaceSubclass() == XB360_IFACE_SUBCLASS &&
-            (usbInterface.getInterfaceProtocol() == XB360_IFACE_PROTOCOL ||
-             usbInterface.getInterfaceProtocol() == XB360W_IFACE_PROTOCOL)) {
-            int vendor_id = usbDevice.getVendorId();
-            for (int supportedVid : SUPPORTED_VENDORS) {
-                if (vendor_id == supportedVid) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private boolean isXboxOneController(UsbDevice usbDevice, UsbInterface usbInterface) {
-        final int XB1_IFACE_SUBCLASS = 71;
-        final int XB1_IFACE_PROTOCOL = 208;
-        final int[] SUPPORTED_VENDORS = {
-            0x03f0, // HP
-            0x044f, // Thrustmaster
-            0x045e, // Microsoft
-            0x0738, // Mad Catz
-            0x0b05, // ASUS
-            0x0e6f, // PDP
-            0x0f0d, // Hori
-            0x10f5, // Turtle Beach
-            0x1532, // Razer Wildcat
-            0x20d6, // PowerA
-            0x24c6, // PowerA
-            0x294b, // Snakebyte
-            0x2dc8, // 8BitDo
-            0x2e24, // Hyperkin
-            0x2e95, // SCUF
-            0x3285, // Nacon
-            0x3537, // GameSir
-            0x366c, // ByoWave
-        };
-
-        if (usbInterface.getId() == 0 &&
-            usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_VENDOR_SPEC &&
-            usbInterface.getInterfaceSubclass() == XB1_IFACE_SUBCLASS &&
-            usbInterface.getInterfaceProtocol() == XB1_IFACE_PROTOCOL) {
-            int vendor_id = usbDevice.getVendorId();
-            for (int supportedVid : SUPPORTED_VENDORS) {
-                if (vendor_id == supportedVid) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private void handleUsbDeviceAttached(UsbDevice usbDevice) {
-        connectHIDDeviceUSB(usbDevice);
-    }
-
-    private void handleUsbDeviceDetached(UsbDevice usbDevice) {
-        List<Integer> devices = new ArrayList<Integer>();
-        for (HIDDevice device : mDevicesById.values()) {
-            if (usbDevice.equals(device.getDevice())) {
-                devices.add(device.getId());
-            }
-        }
-        for (int id : devices) {
-            HIDDevice device = mDevicesById.get(id);
-            mDevicesById.remove(id);
-            device.shutdown();
-            HIDDeviceDisconnected(id);
-        }
-    }
-
-    private void handleUsbDevicePermission(UsbDevice usbDevice, boolean permission_granted) {
-        for (HIDDevice device : mDevicesById.values()) {
-            if (usbDevice.equals(device.getDevice())) {
-                boolean opened = false;
-                if (permission_granted) {
-                    opened = device.open();
-                }
-                HIDDeviceOpenResult(device.getId(), opened);
-            }
-        }
-    }
-
-    private void connectHIDDeviceUSB(UsbDevice usbDevice) {
-        synchronized (this) {
-            int interface_mask = 0;
-            for (int interface_index = 0; interface_index < usbDevice.getInterfaceCount(); interface_index++) {
-                UsbInterface usbInterface = usbDevice.getInterface(interface_index);
-                if (isHIDDeviceInterface(usbDevice, usbInterface)) {
-                    // Check to see if we've already added this interface
-                    // This happens with the Xbox Series X controller which has a duplicate interface 0, which is inactive
-                    int interface_id = usbInterface.getId();
-                    if ((interface_mask & (1 << interface_id)) != 0) {
-                        continue;
-                    }
-                    interface_mask |= (1 << interface_id);
-
-                    HIDDeviceUSB device = new HIDDeviceUSB(this, usbDevice, interface_index);
-                    int id = device.getId();
-                    mDevicesById.put(id, device);
-                    HIDDeviceConnected(id, device.getIdentifier(), device.getVendorId(), device.getProductId(), device.getSerialNumber(), device.getVersion(), device.getManufacturerName(), device.getProductName(), usbInterface.getId(), usbInterface.getInterfaceClass(), usbInterface.getInterfaceSubclass(), usbInterface.getInterfaceProtocol(), false, 0);
-                }
-            }
-        }
-    }
-
-    private void initializeBluetooth() {
-        Log.d(TAG, "Initializing Bluetooth");
-
-        if (Build.VERSION.SDK_INT >= 31 /* Android 12  */ &&
-            mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH_CONNECT, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
-            Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH_CONNECT");
-            return;
-        }
-
-        if (Build.VERSION.SDK_INT <= 30 /* Android 11.0 (R) */ &&
-            mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
-            Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH");
-            return;
-        }
-
-        if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
-            Log.d(TAG, "Couldn't initialize Bluetooth, this version of Android does not support Bluetooth LE");
-            return;
-        }
-
-        // Find bonded bluetooth controllers and create SteamControllers for them
-        mBluetoothManager = (BluetoothManager)mContext.getSystemService(Context.BLUETOOTH_SERVICE);
-        if (mBluetoothManager == null) {
-            // This device doesn't support Bluetooth.
-            return;
-        }
-
-        BluetoothAdapter btAdapter = mBluetoothManager.getAdapter();
-        if (btAdapter == null) {
-            // This device has Bluetooth support in the codebase, but has no available adapters.
-            return;
-        }
-
-        // Get our bonded devices.
-        for (BluetoothDevice device : btAdapter.getBondedDevices()) {
-
-            Log.d(TAG, "Bluetooth device available: " + device);
-            if (isSteamController(device)) {
-                connectBluetoothDevice(device);
-            }
-
-        }
-
-        // NOTE: These don't work on Chromebooks, to my undying dismay.
-        IntentFilter filter = new IntentFilter();
-        filter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
-        filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
-        if (Build.VERSION.SDK_INT >= 33) { /* Android 13.0 (TIRAMISU) */
-            mContext.registerReceiver(mBluetoothBroadcast, filter, Context.RECEIVER_EXPORTED);
-        } else {
-            mContext.registerReceiver(mBluetoothBroadcast, filter);
-        }
-
-        if (mIsChromebook) {
-            mHandler = new Handler(Looper.getMainLooper());
-            mLastBluetoothDevices = new ArrayList<BluetoothDevice>();
-
-            // final HIDDeviceManager finalThis = this;
-            // mHandler.postDelayed(new Runnable() {
-            //     @Override
-            //     public void run() {
-            //         finalThis.chromebookConnectionHandler();
-            //     }
-            // }, 5000);
-        }
-    }
-
-    private void shutdownBluetooth() {
-        try {
-            mContext.unregisterReceiver(mBluetoothBroadcast);
-        } catch (Exception e) {
-            // We may not have registered, that's okay
-        }
-    }
-
-    // Chromebooks do not pass along ACTION_ACL_CONNECTED / ACTION_ACL_DISCONNECTED properly.
-    // This function provides a sort of dummy version of that, watching for changes in the
-    // connected devices and attempting to add controllers as things change.
-    void chromebookConnectionHandler() {
-        if (!mIsChromebook) {
-            return;
-        }
-
-        ArrayList<BluetoothDevice> disconnected = new ArrayList<BluetoothDevice>();
-        ArrayList<BluetoothDevice> connected = new ArrayList<BluetoothDevice>();
-
-        List<BluetoothDevice> currentConnected = mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT);
-
-        for (BluetoothDevice bluetoothDevice : currentConnected) {
-            if (!mLastBluetoothDevices.contains(bluetoothDevice)) {
-                connected.add(bluetoothDevice);
-            }
-        }
-        for (BluetoothDevice bluetoothDevice : mLastBluetoothDevices) {
-            if (!currentConnected.contains(bluetoothDevice)) {
-                disconnected.add(bluetoothDevice);
-            }
-        }
-
-        mLastBluetoothDevices = currentConnected;
-
-        for (BluetoothDevice bluetoothDevice : disconnected) {
-            disconnectBluetoothDevice(bluetoothDevice);
-        }
-        for (BluetoothDevice bluetoothDevice : connected) {
-            connectBluetoothDevice(bluetoothDevice);
-        }
-
-        final HIDDeviceManager finalThis = this;
-        mHandler.postDelayed(new Runnable() {
-            @Override
-            public void run() {
-                finalThis.chromebookConnectionHandler();
-            }
-        }, 10000);
-    }
-
-    boolean connectBluetoothDevice(BluetoothDevice bluetoothDevice) {
-        Log.v(TAG, "connectBluetoothDevice device=" + bluetoothDevice);
-        synchronized (this) {
-            if (mBluetoothDevices.containsKey(bluetoothDevice)) {
-                Log.v(TAG, "Steam controller with address " + bluetoothDevice + " already exists, attempting reconnect");
-
-                HIDDeviceBLESteamController device = mBluetoothDevices.get(bluetoothDevice);
-                device.reconnect();
-
-                return false;
-            }
-            HIDDeviceBLESteamController device = new HIDDeviceBLESteamController(this, bluetoothDevice);
-            int id = device.getId();
-            mBluetoothDevices.put(bluetoothDevice, device);
-            mDevicesById.put(id, device);
-
-            // The Steam Controller will mark itself connected once initialization is complete
-        }
-        return true;
-    }
-
-    void disconnectBluetoothDevice(BluetoothDevice bluetoothDevice) {
-        synchronized (this) {
-            HIDDeviceBLESteamController device = mBluetoothDevices.get(bluetoothDevice);
-            if (device == null)
-                return;
-
-            int id = device.getId();
-            mBluetoothDevices.remove(bluetoothDevice);
-            mDevicesById.remove(id);
-            device.shutdown();
-            HIDDeviceDisconnected(id);
-        }
-    }
-
-    boolean isSteamController(BluetoothDevice bluetoothDevice) {
-        // Sanity check.  If you pass in a null device, by definition it is never a Steam Controller.
-        if (bluetoothDevice == null) {
-            return false;
-        }
-
-        // If the device has no local name, we really don't want to try an equality check against it.
-        if (bluetoothDevice.getName() == null) {
-            return false;
-        }
-
-        // Steam Controllers will always support Bluetooth Low Energy
-        if ((bluetoothDevice.getType() & BluetoothDevice.DEVICE_TYPE_LE) == 0) {
-            return false;
-        }
-
-        // Match on the name either the original Steam Controller or the new second-generation one advertise with.
-        return bluetoothDevice.getName().equals("SteamController") || bluetoothDevice.getName().startsWith("Steam Ctrl");
-    }
-
-    private void close() {
-        shutdownUSB();
-        shutdownBluetooth();
-        synchronized (this) {
-            for (HIDDevice device : mDevicesById.values()) {
-                device.shutdown();
-            }
-            mDevicesById.clear();
-            mBluetoothDevices.clear();
-            HIDDeviceReleaseCallback();
-        }
-    }
-
-    public void setFrozen(boolean frozen) {
-        synchronized (this) {
-            for (HIDDevice device : mDevicesById.values()) {
-                device.setFrozen(frozen);
-            }
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private HIDDevice getDevice(int id) {
-        synchronized (this) {
-            HIDDevice result = mDevicesById.get(id);
-            if (result == null) {
-                Log.v(TAG, "No device for id: " + id);
-                Log.v(TAG, "Available devices: " + mDevicesById.keySet());
-            }
-            return result;
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    ////////// JNI interface functions
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    boolean initialize(boolean usb, boolean bluetooth) {
-        Log.v(TAG, "initialize(" + usb + ", " + bluetooth + ")");
-
-        if (usb) {
-            initializeUSB();
-        }
-        if (bluetooth) {
-            initializeBluetooth();
-        }
-        return true;
-    }
-
-    boolean openDevice(int deviceID) {
-        Log.v(TAG, "openDevice deviceID=" + deviceID);
-        HIDDevice device = getDevice(deviceID);
-        if (device == null) {
-            HIDDeviceDisconnected(deviceID);
-            return false;
-        }
-
-        // Look to see if this is a USB device and we have permission to access it
-        UsbDevice usbDevice = device.getDevice();
-        if (usbDevice != null && !mUsbManager.hasPermission(usbDevice)) {
-            HIDDeviceOpenPending(deviceID);
-            try {
-                final int FLAG_MUTABLE = 0x02000000; // PendingIntent.FLAG_MUTABLE, but don't require SDK 31
-                int flags;
-                if (Build.VERSION.SDK_INT >= 31 /* Android 12.0 (S) */) {
-                    flags = FLAG_MUTABLE;
-                } else {
-                    flags = 0;
-                }
-
-                Intent intent = new Intent(HIDDeviceManager.ACTION_USB_PERMISSION);
-                intent.setPackage(mContext.getPackageName());
-                mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, intent, flags));
-            } catch (Exception e) {
-                Log.v(TAG, "Couldn't request permission for USB device " + usbDevice);
-                HIDDeviceOpenResult(deviceID, false);
-            }
-            return false;
-        }
-
-        try {
-            return device.open();
-        } catch (Exception e) {
-            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
-        }
-        return false;
-    }
-
-    int writeReport(int deviceID, byte[] report, boolean feature) {
-        try {
-            //Log.v(TAG, "writeReport deviceID=" + deviceID + " length=" + report.length);
-            HIDDevice device;
-            device = getDevice(deviceID);
-            if (device == null) {
-                HIDDeviceDisconnected(deviceID);
-                return -1;
-            }
-
-            return device.writeReport(report, feature);
-        } catch (Exception e) {
-            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
-        }
-        return -1;
-    }
-
-    boolean readReport(int deviceID, byte[] report, boolean feature) {
-        try {
-            //Log.v(TAG, "readReport deviceID=" + deviceID);
-            HIDDevice device;
-            device = getDevice(deviceID);
-            if (device == null) {
-                HIDDeviceDisconnected(deviceID);
-                return false;
-            }
-
-            return device.readReport(report, feature);
-        } catch (Exception e) {
-            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
-        }
-        return false;
-    }
-
-    void closeDevice(int deviceID) {
-        try {
-            Log.v(TAG, "closeDevice deviceID=" + deviceID);
-            HIDDevice device;
-            device = getDevice(deviceID);
-            if (device == null) {
-                HIDDeviceDisconnected(deviceID);
-                return;
-            }
-
-            device.close();
-        } catch (Exception e) {
-            Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
-        }
-    }
-
-
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-    /////////////// Native methods
-    //////////////////////////////////////////////////////////////////////////////////////////////////////
-
-    private native void HIDDeviceRegisterCallback();
-    private native void HIDDeviceReleaseCallback();
-
-    native void HIDDeviceConnected(int deviceID, String identifier, int vendorId, int productId, String serial_number, int release_number, String manufacturer_string, String product_string, int interface_number, int interface_class, int interface_subclass, int interface_protocol, boolean bBluetooth, int reportID);
-    native void HIDDeviceOpenPending(int deviceID);
-    native void HIDDeviceOpenResult(int deviceID, boolean opened);
-    native void HIDDeviceDisconnected(int deviceID);
-
-    native void HIDDeviceInputReport(int deviceID, byte[] report);
-    native void HIDDeviceReportResponse(int deviceID, byte[] report);
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceUSB.java b/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceUSB.java
deleted file mode 100644
index 8954639733..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/HIDDeviceUSB.java
+++ /dev/null
@@ -1,354 +0,0 @@
-package org.libsdl.app;
-
-import android.hardware.usb.*;
-import android.os.Build;
-import android.util.Log;
-import java.util.Arrays;
-import java.util.Locale;
-
-class HIDDeviceUSB implements HIDDevice {
-
-    private static final String TAG = "hidapi";
-
-    protected HIDDeviceManager mManager;
-    protected UsbDevice mDevice;
-    protected int mInterfaceIndex;
-    protected int mInterface;
-    protected int mDeviceId;
-    protected UsbDeviceConnection mConnection;
-    protected UsbEndpoint mInputEndpoint;
-    protected UsbEndpoint mOutputEndpoint;
-    protected InputThread mInputThread;
-    protected boolean mRunning;
-    protected boolean mFrozen;
-    protected boolean mClaimed;
-
-    public HIDDeviceUSB(HIDDeviceManager manager, UsbDevice usbDevice, int interface_index) {
-        mManager = manager;
-        mDevice = usbDevice;
-        mInterfaceIndex = interface_index;
-        mInterface = mDevice.getInterface(mInterfaceIndex).getId();
-        mDeviceId = manager.getDeviceIDForIdentifier(getIdentifier());
-        mRunning = false;
-        mClaimed = false;
-    }
-
-    String getIdentifier() {
-        return String.format(Locale.ENGLISH, "%s/%x/%x/%d", mDevice.getDeviceName(), mDevice.getVendorId(), mDevice.getProductId(), mInterfaceIndex);
-    }
-
-    @Override
-    public int getId() {
-        return mDeviceId;
-    }
-
-    @Override
-    public int getVendorId() {
-        return mDevice.getVendorId();
-    }
-
-    @Override
-    public int getProductId() {
-        return mDevice.getProductId();
-    }
-
-    @Override
-    public String getSerialNumber() {
-        String result = null;
-        try {
-            result = mDevice.getSerialNumber();
-        }
-        catch (SecurityException exception) {
-            //Log.w(TAG, "App permissions mean we cannot get serial number for device " + getDeviceName() + " message: " + exception.getMessage());
-        }
-        if (result == null) {
-            result = "";
-        }
-        return result;
-    }
-
-    @Override
-    public int getVersion() {
-        return 0;
-    }
-
-    @Override
-    public String getManufacturerName() {
-        String result;
-        result = mDevice.getManufacturerName();
-        if (result == null) {
-            result = String.format("%x", getVendorId());
-        }
-        return result;
-    }
-
-    @Override
-    public String getProductName() {
-        String result;
-        result = mDevice.getProductName();
-        if (result == null) {
-            result = String.format("%x", getProductId());
-        }
-        return result;
-    }
-
-    @Override
-    public UsbDevice getDevice() {
-        return mDevice;
-    }
-
-    String getDeviceName() {
-        return getManufacturerName() + " " + getProductName() + "(0x" + String.format("%x", getVendorId()) + "/0x" + String.format("%x", getProductId()) + ")";
-    }
-
-    @Override
-    public boolean open() {
-        mConnection = mManager.getUSBManager().openDevice(mDevice);
-        if (mConnection == null) {
-            Log.w(TAG, "Unable to open USB device " + getDeviceName());
-            return false;
-        }
-
-        // Force claim our interface
-        UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
-        if (!mConnection.claimInterface(iface, true)) {
-            Log.w(TAG, "Failed to claim interfaces on USB device " + getDeviceName());
-            close();
-            return false;
-        }
-        mClaimed = true;
-
-        // Find the endpoints
-        for (int j = 0; j < iface.getEndpointCount(); j++) {
-            UsbEndpoint endpt = iface.getEndpoint(j);
-            switch (endpt.getDirection()) {
-            case UsbConstants.USB_DIR_IN:
-                if (mInputEndpoint == null) {
-                    mInputEndpoint = endpt;
-                }
-                break;
-            case UsbConstants.USB_DIR_OUT:
-                if (mOutputEndpoint == null) {
-                    mOutputEndpoint = endpt;
-                }
-                break;
-            }
-        }
-
-        // Make sure the required endpoints were present. The original Steam Controller and the wireless dongle for it do NOT
-        // actually have -- or require -- output endpoints, so we need to accept only an input one for them or else we'll fall
-        // back to the Android system gamepad functionality (and lose our paddles et al).
-        if (mInputEndpoint == null) {
-            Log.w(TAG, "Missing required endpoint on USB device " + getDeviceName());
-            mConnection.releaseInterface(iface);
-            close();
-            return false;
-        }
-
-        // Start listening for input
-        mRunning = true;
-        mInputThread = new InputThread();
-        mInputThread.start();
-
-        return true;
-    }
-
-    @Override
-    public int writeReport(byte[] report, boolean feature) {
-        if (mConnection == null) {
-            Log.w(TAG, "writeReport() called with no device connection");
-            return -1;
-        }
-
-        if (!mClaimed) {
-            Log.w(TAG, "writeReport() called but some other process currently owns the USB device");
-            return -1;
-        }
-
-        if (feature) {
-            int res = -1;
-            int offset = 0;
-            int length = report.length;
-            boolean skipped_report_id = false;
-            byte report_number = report[0];
-
-            if (report_number == 0x0) {
-                ++offset;
-                --length;
-                skipped_report_id = true;
-            }
-
-            res = mConnection.controlTransfer(
-                UsbConstants.USB_TYPE_CLASS | 0x01 /*RECIPIENT_INTERFACE*/ | UsbConstants.USB_DIR_OUT,
-                0x09/*HID set_report*/,
-                (3/*HID feature*/ << 8) | report_number,
-                mInterface,
-                report, offset, length,
-                1000/*timeout millis*/);
-
-            if (res < 0) {
-                Log.w(TAG, "writeFeatureReport() returned " + res + " on device " + getDeviceName());
-                return -1;
-            }
-
-            if (skipped_report_id) {
-                ++length;
-            }
-            return length;
-        } else {
-            if (mOutputEndpoint == null)
-            {
-                Log.e(TAG, "Tried to write an output report to an interface with no output endpoint!");
-                return -1;
-            }
-            int res = mConnection.bulkTransfer(mOutputEndpoint, report, report.length, 1000);
-            if (res != report.length) {
-                Log.w(TAG, "writeOutputReport() returned " + res + " on device " + getDeviceName());
-            }
-            return res;
-        }
-    }
-
-    @Override
-    public boolean readReport(byte[] report, boolean feature) {
-        int res = -1;
-        int offset = 0;
-        int length = report.length;
-        boolean skipped_report_id = false;
-        byte report_number = report[0];
-
-        if (mConnection == null) {
-            Log.w(TAG, "readReport() called with no device connection");
-            return false;
-        }
-        if (!mClaimed) {
-            if (feature) {
-                return false;
-            }
-            return true;            
-        }
-
-        if (report_number == 0x0) {
-            /* Offset the return buffer by 1, so that the report ID
-               will remain in byte 0. */
-            ++offset;
-            --length;
-            skipped_report_id = true;
-        }
-
-        res = mConnection.controlTransfer(
-            UsbConstants.USB_TYPE_CLASS | 0x01 /*RECIPIENT_INTERFACE*/ | UsbConstants.USB_DIR_IN,
-            0x01/*HID get_report*/,
-            ((feature ? 3/*HID feature*/ : 1/*HID Input*/) << 8) | report_number,
-            mInterface,
-            report, offset, length,
-            1000/*timeout millis*/);
-
-        if (res < 0) {
-            Log.w(TAG, "getFeatureReport() returned " + res + " on device " + getDeviceName());
-            return false;
-        }
-
-        if (skipped_report_id) {
-            ++res;
-            ++length;
-        }
-
-        byte[] data;
-        if (res == length) {
-            data = report;
-        } else {
-            data = Arrays.copyOfRange(report, 0, res);
-        }
-        mManager.HIDDeviceReportResponse(mDeviceId, data);
-
-        return true;
-    }
-
-    @Override
-    public void close() {
-        mRunning = false;
-        if (mInputThread != null) {
-            while (mInputThread.isAlive()) {
-                mInputThread.interrupt();
-                try {
-                    mInputThread.join();
-                } catch (InterruptedException e) {
-                    // Keep trying until we're done
-                }
-            }
-            mInputThread = null;
-        }
-        if (mConnection != null) {
-            if (mClaimed) {
-                UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
-                mConnection.releaseInterface(iface);                
-            }
-            mConnection.close();
-            mConnection = null;
-            mClaimed = false;
-        }
-    }
-
-    @Override
-    public void shutdown() {
-        close();
-        mManager = null;
-    }
-
-    @Override
-    public void setFrozen(boolean frozen) {
-        mFrozen = frozen;
-
-        /* If we have a valid device connection and the claim state doesn't match what we want, try to correct that. */
-        if (mConnection != null && mClaimed == mFrozen) {
-            UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
-            if (frozen) {
-                mClaimed = !mConnection.releaseInterface(iface);
-                if (mClaimed) {
-                    Log.e(TAG, "Tried to release claim on USB device, but failed!");
-                }
-            } else {
-                mClaimed = mConnection.claimInterface(iface, true);
-                if (!mClaimed) {
-                    Log.e(TAG, "Tried to regain claim on USB device, but failed!");
-                }
-            }
-        }
-    }
-
-    protected class InputThread extends Thread {
-        @Override
-        public void run() {
-            int packetSize = mInputEndpoint.getMaxPacketSize();
-            byte[] packet = new byte[packetSize];
-            while (mRunning) {
-                int r;
-                try
-                {
-                    r = mConnection.bulkTransfer(mInputEndpoint, packet, packetSize, 1000);
-                }
-                catch (Exception e)
-                {
-                    Log.v(TAG, "Exception in UsbDeviceConnection bulktransfer: " + e);
-                    break;
-                }
-                if (r < 0) {
-                    // Could be a timeout or an I/O error
-                }
-                if (r > 0) {
-                    byte[] data;
-                    if (r == packetSize) {
-                        data = packet;
-                    } else {
-                        data = Arrays.copyOfRange(packet, 0, r);
-                    }
-
-                    if (!mFrozen) {
-                        mManager.HIDDeviceInputReport(mDeviceId, data);
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDL.java b/platforms/android/app/src/main/java/org/libsdl/app/SDL.java
deleted file mode 100644
index d9650a72e4..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDL.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package org.libsdl.app;
-
-import android.app.Activity;
-import android.content.Context;
-
-import java.lang.reflect.Method;
-
-/**
-    SDL library initialization
-*/
-public class SDL {
-
-    // This function should be called first and sets up the native code
-    // so it can call into the Java classes
-    static public void setupJNI() {
-        SDLActivity.nativeSetupJNI();
-        SDLAudioManager.nativeSetupJNI();
-        SDLControllerManager.nativeSetupJNI();
-    }
-
-    // This function should be called each time the activity is started
-    static public void initialize() {
-        setContext(null);
-
-        SDLActivity.initialize();
-        SDLAudioManager.initialize();
-        SDLControllerManager.initialize();
-    }
-
-    // This function stores the current activity (SDL or not)
-    static public void setContext(Activity context) {
-        SDLAudioManager.setContext(context);
-        mContext = context;
-    }
-
-    static public Activity getContext() {
-        return mContext;
-    }
-
-    static void loadLibrary(String libraryName) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
-        loadLibrary(libraryName, mContext);
-    }
-
-    static void loadLibrary(String libraryName, Context context) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
-
-        if (libraryName == null) {
-            throw new NullPointerException("No library name provided.");
-        }
-
-        try {
-            // Let's see if we have ReLinker available in the project.  This is necessary for
-            // some projects that have huge numbers of local libraries bundled, and thus may
-            // trip a bug in Android's native library loader which ReLinker works around.  (If
-            // loadLibrary works properly, ReLinker will simply use the normal Android method
-            // internally.)
-            //
-            // To use ReLinker, just add it as a dependency.  For more information, see
-            // https://github.com/KeepSafe/ReLinker for ReLinker's repository.
-            //
-            Class<?> relinkClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker");
-            Class<?> relinkListenerClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker$LoadListener");
-            Class<?> contextClass = context.getClassLoader().loadClass("android.content.Context");
-            Class<?> stringClass = context.getClassLoader().loadClass("java.lang.String");
-
-            // Get a 'force' instance of the ReLinker, so we can ensure libraries are reinstalled if
-            // they've changed during updates.
-            Method forceMethod = relinkClass.getDeclaredMethod("force");
-            Object relinkInstance = forceMethod.invoke(null);
-            Class<?> relinkInstanceClass = relinkInstance.getClass();
-
-            // Actually load the library!
-            Method loadMethod = relinkInstanceClass.getDeclaredMethod("loadLibrary", contextClass, stringClass, stringClass, relinkListenerClass);
-            loadMethod.invoke(relinkInstance, context, libraryName, null, null);
-        }
-        catch (final Throwable e) {
-            // Fall back
-            try {
-                System.loadLibrary(libraryName);
-            }
-            catch (final UnsatisfiedLinkError ule) {
-                throw ule;
-            }
-            catch (final SecurityException se) {
-                throw se;
-            }
-        }
-    }
-
-    protected static Activity mContext;
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLActivity.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLActivity.java
deleted file mode 100644
index dcc49852ac..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLActivity.java
+++ /dev/null
@@ -1,2240 +0,0 @@
-package org.libsdl.app;
-
-import android.app.Activity;
-import android.app.AlertDialog;
-import android.app.Dialog;
-import android.app.UiModeManager;
-import android.content.ActivityNotFoundException;
-import android.content.ClipboardManager;
-import android.content.ClipData;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.content.pm.ActivityInfo;
-import android.content.pm.ApplicationInfo;
-import android.content.pm.PackageManager;
-import android.content.res.Configuration;
-import android.graphics.Bitmap;
-import android.graphics.Color;
-import android.graphics.PorterDuff;
-import android.graphics.drawable.Drawable;
-import android.hardware.Sensor;
-import android.net.Uri;
-import android.os.Build;
-import android.os.Bundle;
-import android.os.Handler;
-import android.os.LocaleList;
-import android.os.Message;
-import android.os.ParcelFileDescriptor;
-import android.util.DisplayMetrics;
-import android.util.Log;
-import android.util.SparseArray;
-import android.view.Display;
-import android.view.Gravity;
-import android.view.InputDevice;
-import android.view.KeyEvent;
-import android.view.PointerIcon;
-import android.view.Surface;
-import android.view.View;
-import android.view.ViewGroup;
-import android.view.Window;
-import android.view.WindowManager;
-import android.view.inputmethod.InputConnection;
-import android.view.inputmethod.InputMethodManager;
-import android.webkit.MimeTypeMap;
-import android.widget.Button;
-import android.widget.LinearLayout;
-import android.widget.RelativeLayout;
-import android.widget.TextView;
-import android.widget.Toast;
-
-import java.io.FileNotFoundException;
-import java.util.ArrayList;
-import java.util.Hashtable;
-import java.util.Locale;
-
-
-/**
-    SDL Activity
-*/
-public class SDLActivity extends Activity implements View.OnSystemUiVisibilityChangeListener {
-    private static final String TAG = "SDL";
-    private static final int SDL_MAJOR_VERSION = 3;
-    private static final int SDL_MINOR_VERSION = 4;
-    private static final int SDL_MICRO_VERSION = 10;
-/*
-    // Display InputType.SOURCE/CLASS of events and devices
-    //
-    // SDLActivity.debugSource(device.getSources(), "device[" + device.getName() + "]");
-    // SDLActivity.debugSource(event.getSource(), "event");
-    public static void debugSource(int sources, String prefix) {
-        int s = sources;
-        int s_copy = sources;
-        String cls = "";
-        String src = "";
-        int tst = 0;
-        int FLAG_TAINTED = 0x80000000;
-
-        if ((s & InputDevice.SOURCE_CLASS_BUTTON) != 0)     cls += " BUTTON";
-        if ((s & InputDevice.SOURCE_CLASS_JOYSTICK) != 0)   cls += " JOYSTICK";
-        if ((s & InputDevice.SOURCE_CLASS_POINTER) != 0)    cls += " POINTER";
-        if ((s & InputDevice.SOURCE_CLASS_POSITION) != 0)   cls += " POSITION";
-        if ((s & InputDevice.SOURCE_CLASS_TRACKBALL) != 0)  cls += " TRACKBALL";
-
-
-        int s2 = s_copy & ~InputDevice.SOURCE_ANY; // keep class bits
-        s2 &= ~(  InputDevice.SOURCE_CLASS_BUTTON
-                | InputDevice.SOURCE_CLASS_JOYSTICK
-                | InputDevice.SOURCE_CLASS_POINTER
-                | InputDevice.SOURCE_CLASS_POSITION
-                | InputDevice.SOURCE_CLASS_TRACKBALL);
-
-        if (s2 != 0) cls += "Some_Unknown";
-
-        s2 = s_copy & InputDevice.SOURCE_ANY; // keep source only, no class;
-
-        if (Build.VERSION.SDK_INT >= 23) {
-            tst = InputDevice.SOURCE_BLUETOOTH_STYLUS;
-            if ((s & tst) == tst) src += " BLUETOOTH_STYLUS";
-            s2 &= ~tst;
-        }
-
-        tst = InputDevice.SOURCE_DPAD;
-        if ((s & tst) == tst) src += " DPAD";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_GAMEPAD;
-        if ((s & tst) == tst) src += " GAMEPAD";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_HDMI;
-        if ((s & tst) == tst) src += " HDMI";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_JOYSTICK;
-        if ((s & tst) == tst) src += " JOYSTICK";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_KEYBOARD;
-        if ((s & tst) == tst) src += " KEYBOARD";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_MOUSE;
-        if ((s & tst) == tst) src += " MOUSE";
-        s2 &= ~tst;
-
-        if (Build.VERSION.SDK_INT >= 26) {
-            tst = InputDevice.SOURCE_MOUSE_RELATIVE;
-            if ((s & tst) == tst) src += " MOUSE_RELATIVE";
-            s2 &= ~tst;
-
-            tst = InputDevice.SOURCE_ROTARY_ENCODER;
-            if ((s & tst) == tst) src += " ROTARY_ENCODER";
-            s2 &= ~tst;
-        }
-        tst = InputDevice.SOURCE_STYLUS;
-        if ((s & tst) == tst) src += " STYLUS";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_TOUCHPAD;
-        if ((s & tst) == tst) src += " TOUCHPAD";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_TOUCHSCREEN;
-        if ((s & tst) == tst) src += " TOUCHSCREEN";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_TOUCH_NAVIGATION;
-        if ((s & tst) == tst) src += " TOUCH_NAVIGATION";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_TRACKBALL;
-        if ((s & tst) == tst) src += " TRACKBALL";
-        s2 &= ~tst;
-
-        tst = InputDevice.SOURCE_ANY;
-        if ((s & tst) == tst) src += " ANY";
-        s2 &= ~tst;
-
-        if (s == FLAG_TAINTED) src += " FLAG_TAINTED";
-        s2 &= ~FLAG_TAINTED;
-
-        if (s2 != 0) src += " Some_Unknown";
-
-        Log.v(TAG, prefix + "int=" + s_copy + " CLASS={" + cls + " } source(s):" + src);
-    }
-*/
-
-    public static boolean mIsResumedCalled, mHasFocus;
-    public static final boolean mHasMultiWindow = (Build.VERSION.SDK_INT >= 24  /* Android 7.0 (N) */);
-
-    // Cursor types
-    // private static final int SDL_SYSTEM_CURSOR_NONE = -1;
-    private static final int SDL_SYSTEM_CURSOR_ARROW = 0;
-    private static final int SDL_SYSTEM_CURSOR_IBEAM = 1;
-    private static final int SDL_SYSTEM_CURSOR_WAIT = 2;
-    private static final int SDL_SYSTEM_CURSOR_CROSSHAIR = 3;
-    private static final int SDL_SYSTEM_CURSOR_WAITARROW = 4;
-    private static final int SDL_SYSTEM_CURSOR_SIZENWSE = 5;
-    private static final int SDL_SYSTEM_CURSOR_SIZENESW = 6;
-    private static final int SDL_SYSTEM_CURSOR_SIZEWE = 7;
-    private static final int SDL_SYSTEM_CURSOR_SIZENS = 8;
-    private static final int SDL_SYSTEM_CURSOR_SIZEALL = 9;
-    private static final int SDL_SYSTEM_CURSOR_NO = 10;
-    private static final int SDL_SYSTEM_CURSOR_HAND = 11;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_TOPLEFT = 12;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_TOP = 13;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_TOPRIGHT = 14;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_RIGHT = 15;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_BOTTOMRIGHT = 16;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_BOTTOM = 17;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_BOTTOMLEFT = 18;
-    private static final int SDL_SYSTEM_CURSOR_WINDOW_LEFT = 19;
-
-    protected static final int SDL_ORIENTATION_UNKNOWN = 0;
-    protected static final int SDL_ORIENTATION_LANDSCAPE = 1;
-    protected static final int SDL_ORIENTATION_LANDSCAPE_FLIPPED = 2;
-    protected static final int SDL_ORIENTATION_PORTRAIT = 3;
-    protected static final int SDL_ORIENTATION_PORTRAIT_FLIPPED = 4;
-
-    protected static int mCurrentRotation;
-    protected static Locale mCurrentLocale;
-
-    // Handle the state of the native layer
-    public enum NativeState {
-           INIT, RESUMED, PAUSED
-    }
-
-    public static NativeState mNextNativeState;
-    public static NativeState mCurrentNativeState;
-
-    /** If shared libraries (e.g. SDL or the native application) could not be loaded. */
-    public static boolean mBrokenLibraries = true;
-
-    // Main components
-    protected static SDLActivity mSingleton;
-    protected static SDLSurface mSurface;
-    protected static SDLDummyEdit mTextEdit;
-    protected static ViewGroup mLayout;
-    protected static SDLClipboardHandler mClipboardHandler;
-    protected static Hashtable<Integer, PointerIcon> mCursors;
-    protected static int mLastCursorID;
-    protected static SDLGenericMotionListener_API14 mMotionListener;
-    protected static HIDDeviceManager mHIDDeviceManager;
-
-    // This is what SDL runs in. It invokes SDL_main(), eventually
-    protected static Thread mSDLThread;
-    protected static boolean mSDLMainFinished = false;
-    protected static boolean mActivityCreated = false;
-    private static SDLFileDialogState mFileDialogState = null;
-    protected static boolean mDispatchingKeyEvent = false;
-
-    public static SDLGenericMotionListener_API14 getMotionListener() {
-        if (mMotionListener == null) {
-            if (Build.VERSION.SDK_INT >= 29 /* Android 10 (Q) */) {
-                mMotionListener = new SDLGenericMotionListener_API29();
-            } else if (Build.VERSION.SDK_INT >= 26 /* Android 8.0 (O) */) {
-                mMotionListener = new SDLGenericMotionListener_API26();
-            } else if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-                mMotionListener = new SDLGenericMotionListener_API24();
-            } else {
-                mMotionListener = new SDLGenericMotionListener_API14();
-            }
-        }
-
-        return mMotionListener;
-    }
-
-    /**
-     * The application entry point, called on a dedicated thread (SDLThread).
-     * The default implementation uses the getMainSharedObject() and getMainFunction() methods
-     * to invoke native code from the specified shared library.
-     * It can be overridden by derived classes.
-     */
-    protected void main() {
-        String library = SDLActivity.mSingleton.getMainSharedObject();
-        String function = SDLActivity.mSingleton.getMainFunction();
-        String[] arguments = SDLActivity.mSingleton.getArguments();
-
-        Log.v("SDL", "Running main function " + function + " from library " + library);
-        SDLActivity.nativeRunMain(library, function, arguments);
-        Log.v("SDL", "Finished main function");
-    }
-
-    /**
-     * This method returns the name of the shared object with the application entry point
-     * It can be overridden by derived classes.
-     */
-    protected String getMainSharedObject() {
-        String library;
-        String[] libraries = SDLActivity.mSingleton.getLibraries();
-        if (libraries.length > 0) {
-            library = "lib" + libraries[libraries.length - 1] + ".so";
-        } else {
-            library = "libmain.so";
-        }
-        return getContext().getApplicationInfo().nativeLibraryDir + "/" + library;
-    }
-
-    /**
-     * This method returns the name of the application entry point
-     * It can be overridden by derived classes.
-     */
-    protected String getMainFunction() {
-        return "SDL_main";
-    }
-
-    /**
-     * This method is called by SDL before loading the native shared libraries.
-     * It can be overridden to provide names of shared libraries to be loaded.
-     * The default implementation returns the defaults. It never returns null.
-     * An array returned by a new implementation must at least contain "SDL3".
-     * Also keep in mind that the order the libraries are loaded may matter.
-     * @return names of shared libraries to be loaded (e.g. "SDL3", "main").
-     */
-    protected String[] getLibraries() {
-        return new String[] {
-            "SDL3",
-            // "SDL3_image",
-            // "SDL3_mixer",
-            // "SDL3_net",
-            // "SDL3_ttf",
-            "main"
-        };
-    }
-
-    // Load the .so
-    public void loadLibraries() {
-       for (String lib : getLibraries()) {
-          SDL.loadLibrary(lib, this);
-       }
-    }
-
-    /**
-     * This method is called by SDL before starting the native application thread.
-     * It can be overridden to provide the arguments after the application name.
-     * The default implementation returns an empty array. It never returns null.
-     * @return arguments for the native application.
-     */
-    protected String[] getArguments() {
-        return new String[0];
-    }
-
-    public static void initialize() {
-        // The static nature of the singleton and Android quirkyness force us to initialize everything here
-        // Otherwise, when exiting the app and returning to it, these variables *keep* their pre exit values
-        mSingleton = null;
-        mSurface = null;
-        mTextEdit = null;
-        mLayout = null;
-        mClipboardHandler = null;
-        mCursors = new Hashtable<Integer, PointerIcon>();
-        mLastCursorID = 0;
-        mSDLThread = null;
-        mIsResumedCalled = false;
-        mHasFocus = true;
-        mNextNativeState = NativeState.INIT;
-        mCurrentNativeState = NativeState.INIT;
-    }
-
-    protected SDLSurface createSDLSurface(Context context) {
-        return new SDLSurface(context);
-    }
-
-    // Setup
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        Log.v(TAG, "Manufacturer: " + Build.MANUFACTURER);
-        Log.v(TAG, "Device: " + Build.DEVICE);
-        Log.v(TAG, "Model: " + Build.MODEL);
-        Log.v(TAG, "onCreate()");
-        super.onCreate(savedInstanceState);
-
-
-        /* Control activity re-creation */
-        if (mSDLMainFinished || mActivityCreated) {
-              boolean allow_recreate = SDLActivity.nativeAllowRecreateActivity();
-              if (mSDLMainFinished) {
-                  Log.v(TAG, "SDL main() finished");
-              }
-              if (allow_recreate) {
-                  Log.v(TAG, "activity re-created");
-              } else {
-                  Log.v(TAG, "activity finished");
-                  System.exit(0);
-                  return;
-              }
-        }
-
-        mActivityCreated = true;
-
-        try {
-            Thread.currentThread().setName("SDLActivity");
-        } catch (Exception e) {
-            Log.v(TAG, "modify thread properties failed " + e.toString());
-        }
-
-        // Load shared libraries
-        String errorMsgBrokenLib = "";
-        try {
-            loadLibraries();
-            mBrokenLibraries = false; /* success */
-        } catch(UnsatisfiedLinkError e) {
-            System.err.println(e.getMessage());
-            mBrokenLibraries = true;
-            errorMsgBrokenLib = e.getMessage();
-        } catch(Exception e) {
-            System.err.println(e.getMessage());
-            mBrokenLibraries = true;
-            errorMsgBrokenLib = e.getMessage();
-        }
-
-        if (!mBrokenLibraries) {
-            String expected_version = String.valueOf(SDL_MAJOR_VERSION) + "." +
-                                      String.valueOf(SDL_MINOR_VERSION) + "." +
-                                      String.valueOf(SDL_MICRO_VERSION);
-            String version = nativeGetVersion();
-            if (!version.equals(expected_version)) {
-                mBrokenLibraries = true;
-                errorMsgBrokenLib = "SDL C/Java version mismatch (expected " + expected_version + ", got " + version + ")";
-            }
-        }
-
-        if (mBrokenLibraries) {
-            mSingleton = this;
-            AlertDialog.Builder dlgAlert  = new AlertDialog.Builder(this);
-            dlgAlert.setMessage("An error occurred while trying to start the application. Please try again and/or reinstall."
-                  + System.getProperty("line.separator")
-                  + System.getProperty("line.separator")
-                  + "Error: " + errorMsgBrokenLib);
-            dlgAlert.setTitle("SDL Error");
-            dlgAlert.setPositiveButton("Exit",
-                new DialogInterface.OnClickListener() {
-                    @Override
-                    public void onClick(DialogInterface dialog,int id) {
-                        // if this button is clicked, close current activity
-                        SDLActivity.mSingleton.finish();
-                    }
-                });
-           dlgAlert.setCancelable(false);
-           dlgAlert.create().show();
-
-           return;
-        }
-
-
-        /* Control activity re-creation */
-        /* Robustness: check that the native code is run for the first time.
-         * (Maybe Activity was reset, but not the native code.) */
-        {
-            int run_count = SDLActivity.nativeCheckSDLThreadCounter(); /* get and increment a native counter */
-            if (run_count != 0) {
-                boolean allow_recreate = SDLActivity.nativeAllowRecreateActivity();
-                if (allow_recreate) {
-                    Log.v(TAG, "activity re-created // run_count: " + run_count);
-                } else {
-                    Log.v(TAG, "activity finished // run_count: " + run_count);
-                    System.exit(0);
-                    return;
-                }
-            }
-        }
-
-        // Set up JNI
-        SDL.setupJNI();
-
-        // Initialize state
-        SDL.initialize();
-
-        // So we can call stuff from static callbacks
-        mSingleton = this;
-        SDL.setContext(this);
-
-        mClipboardHandler = new SDLClipboardHandler();
-
-        mHIDDeviceManager = HIDDeviceManager.acquire(this);
-
-        // Set up the surface
-        mSurface = createSDLSurface(this);
-
-        mLayout = new RelativeLayout(this);
-        mLayout.addView(mSurface);
-
-        // Get our current screen orientation and pass it down.
-        SDLActivity.nativeSetNaturalOrientation(SDLActivity.getNaturalOrientation());
-        mCurrentRotation = SDLActivity.getCurrentRotation();
-        SDLActivity.onNativeRotationChanged(mCurrentRotation);
-
-        try {
-            if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
-                mCurrentLocale = getContext().getResources().getConfiguration().locale;
-            } else {
-                mCurrentLocale = getContext().getResources().getConfiguration().getLocales().get(0);
-            }
-        } catch(Exception ignored) {
-        }
-
-        switch (getContext().getResources().getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK) {
-        case Configuration.UI_MODE_NIGHT_NO:
-            SDLActivity.onNativeDarkModeChanged(false);
-            break;
-        case Configuration.UI_MODE_NIGHT_YES:
-            SDLActivity.onNativeDarkModeChanged(true);
-            break;
-        }
-
-        setContentView(mLayout);
-
-        setWindowStyle(false);
-
-        getWindow().getDecorView().setOnSystemUiVisibilityChangeListener(this);
-
-        // Get filename from "Open with" of another application
-        Intent intent = getIntent();
-        if (intent != null && intent.getData() != null) {
-            String filename = intent.getData().getPath();
-            if (filename != null) {
-                Log.v(TAG, "Got filename: " + filename);
-                SDLActivity.onNativeDropFile(filename);
-            }
-        }
-    }
-
-    protected void pauseNativeThread() {
-        mNextNativeState = NativeState.PAUSED;
-        mIsResumedCalled = false;
-
-        if (SDLActivity.mBrokenLibraries) {
-            return;
-        }
-
-        SDLActivity.handleNativeState();
-    }
-
-    protected void resumeNativeThread() {
-        mNextNativeState = NativeState.RESUMED;
-        mIsResumedCalled = true;
-
-        if (SDLActivity.mBrokenLibraries) {
-           return;
-        }
-
-        SDLActivity.handleNativeState();
-    }
-
-    // Events
-    @Override
-    protected void onPause() {
-        Log.v(TAG, "onPause()");
-        super.onPause();
-
-        if (mHIDDeviceManager != null) {
-            mHIDDeviceManager.setFrozen(true);
-        }        
-
-        if (!mHasMultiWindow) {
-            pauseNativeThread();
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        Log.v(TAG, "onResume()");
-        super.onResume();
-
-        if (mHIDDeviceManager != null) {
-            mHIDDeviceManager.setFrozen(false);
-        }        
-
-        if (!mHasMultiWindow) {
-            resumeNativeThread();
-        }
-    }
-
-    @Override
-    protected void onStop() {
-        Log.v(TAG, "onStop()");
-        super.onStop();
-        if (mHasMultiWindow) {
-            pauseNativeThread();
-        }
-    }
-
-    @Override
-    protected void onStart() {
-        Log.v(TAG, "onStart()");
-        super.onStart();
-        if (mHasMultiWindow) {
-            resumeNativeThread();
-        }
-    }
-
-    public static int getNaturalOrientation() {
-        int result = SDL_ORIENTATION_UNKNOWN;
-
-        Activity activity = getContext();
-        if (activity != null) {
-            Configuration config = activity.getResources().getConfiguration();
-            Display display = activity.getWindowManager().getDefaultDisplay();
-            int rotation = display.getRotation();
-            if (((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) &&
-                    config.orientation == Configuration.ORIENTATION_LANDSCAPE) ||
-                ((rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) &&
-                    config.orientation == Configuration.ORIENTATION_PORTRAIT)) {
-                result = SDL_ORIENTATION_LANDSCAPE;
-            } else {
-                result = SDL_ORIENTATION_PORTRAIT;
-            }
-        }
-        return result;
-    }
-
-    public static int getCurrentRotation() {
-        int result = 0;
-
-        Activity activity = getContext();
-        if (activity != null) {
-            Display display = activity.getWindowManager().getDefaultDisplay();
-            switch (display.getRotation()) {
-                case Surface.ROTATION_0:
-                    result = 0;
-                    break;
-                case Surface.ROTATION_90:
-                    result = 90;
-                    break;
-                case Surface.ROTATION_180:
-                    result = 180;
-                    break;
-                case Surface.ROTATION_270:
-                    result = 270;
-                    break;
-            }
-        }
-        return result;
-    }
-
-    @Override
-    public void onWindowFocusChanged(boolean hasFocus) {
-        super.onWindowFocusChanged(hasFocus);
-        Log.v(TAG, "onWindowFocusChanged(): " + hasFocus);
-
-        // If we are gaining focus, we can always try to restore our USB devices. If we are losing focus,
-        // only try to relinquish them if we don't have background events allowed (for multi-window Android setups).
-        if (hasFocus || !SDLActivity.nativeGetHintBoolean("SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS", false)) {
-            if (mHIDDeviceManager != null) {
-                mHIDDeviceManager.setFrozen(!hasFocus);
-            }            
-        }
-
-        if (SDLActivity.mBrokenLibraries) {
-           return;
-        }
-
-        mHasFocus = hasFocus;
-        if (hasFocus) {
-           mNextNativeState = NativeState.RESUMED;
-           SDLActivity.getMotionListener().reclaimRelativeMouseModeIfNeeded();
-
-           SDLActivity.handleNativeState();
-           nativeFocusChanged(true);
-
-        } else {
-           nativeFocusChanged(false);
-           if (!mHasMultiWindow) {
-               mNextNativeState = NativeState.PAUSED;
-               SDLActivity.handleNativeState();
-           }
-        }
-    }
-
-    @Override
-    public void onTrimMemory(int level) {
-        Log.v(TAG, "onTrimMemory()");
-        super.onTrimMemory(level);
-
-        if (SDLActivity.mBrokenLibraries) {
-           return;
-        }
-
-        SDLActivity.nativeLowMemory();
-    }
-
-    @Override
-    public void onConfigurationChanged(Configuration newConfig) {
-        Log.v(TAG, "onConfigurationChanged()");
-        super.onConfigurationChanged(newConfig);
-
-        if (SDLActivity.mBrokenLibraries) {
-           return;
-        }
-
-        if (mCurrentLocale == null || !mCurrentLocale.equals(newConfig.locale)) {
-            mCurrentLocale = newConfig.locale;
-            SDLActivity.onNativeLocaleChanged();
-        }
-
-        switch (newConfig.uiMode & Configuration.UI_MODE_NIGHT_MASK) {
-        case Configuration.UI_MODE_NIGHT_NO:
-            SDLActivity.onNativeDarkModeChanged(false);
-            break;
-        case Configuration.UI_MODE_NIGHT_YES:
-            SDLActivity.onNativeDarkModeChanged(true);
-            break;
-        }
-    }
-
-    @Override
-    protected void onDestroy() {
-        Log.v(TAG, "onDestroy()");
-
-        if (mHIDDeviceManager != null) {
-            HIDDeviceManager.release(mHIDDeviceManager);
-            mHIDDeviceManager = null;
-        }
-
-        SDLAudioManager.release(this);
-
-        if (SDLActivity.mBrokenLibraries) {
-           super.onDestroy();
-           return;
-        }
-
-        if (SDLActivity.mSDLThread != null) {
-
-            // Send Quit event to "SDLThread" thread
-            SDLActivity.nativeSendQuit();
-
-            // Wait for "SDLThread" thread to end
-            try {
-                // Use a timeout because:
-                // C SDLmain() thread might have started (mSDLThread.start() called)
-                // while the SDL_Init() might not have been called yet,
-                // and so the previous QUIT event will be discarded by SDL_Init() and app is running, not exiting.
-                SDLActivity.mSDLThread.join(1000);
-            } catch(Exception e) {
-                Log.v(TAG, "Problem stopping SDLThread: " + e);
-            }
-        }
-
-        SDLActivity.nativeQuit();
-
-        super.onDestroy();
-    }
-
-    @Override
-    public void onBackPressed() {
-        // Check if we want to block the back button in case of mouse right click.
-        //
-        // If we do, the normal hardware back button will no longer work and people have to use home,
-        // but the mouse right click will work.
-        //
-        boolean trapBack = SDLActivity.nativeGetHintBoolean("SDL_ANDROID_TRAP_BACK_BUTTON", false);
-        if (trapBack) {
-            // Exit and let the mouse handler handle this button (if appropriate)
-            return;
-        }
-
-        // Default system back button behavior.
-        if (!isFinishing()) {
-            super.onBackPressed();
-        }
-    }
-
-    @Override
-    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
-        super.onActivityResult(requestCode, resultCode, data);
-
-        if (mFileDialogState != null && mFileDialogState.requestCode == requestCode) {
-            /* This is our file dialog */
-            String[] filelist = null;
-
-            if (data != null) {
-                Uri singleFileUri = data.getData();
-
-                if (singleFileUri == null) {
-                    /* Use Intent.getClipData to get multiple choices */
-                    ClipData clipData = data.getClipData();
-                    assert clipData != null;
-
-                    filelist = new String[clipData.getItemCount()];
-
-                    for (int i = 0; i < filelist.length; i++) {
-                        String uri = clipData.getItemAt(i).getUri().toString();
-                        filelist[i] = uri;
-                    }
-                } else {
-                    /* Only one file is selected. */
-                    filelist = new String[]{singleFileUri.toString()};
-                }
-            } else {
-                /* User cancelled the request. */
-                filelist = new String[0];
-            }
-
-            // TODO: Detect the file MIME type and pass the filter value accordingly.
-            SDLActivity.onNativeFileDialog(requestCode, filelist, -1);
-            mFileDialogState = null;
-        }
-    }
-
-    // Called by JNI from SDL.
-    public static void manualBackButton() {
-        mSingleton.pressBackButton();
-    }
-
-    // Used to get us onto the activity's main thread
-    public void pressBackButton() {
-        runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                if (!SDLActivity.this.isFinishing()) {
-                    SDLActivity.this.superOnBackPressed();
-                }
-            }
-        });
-    }
-
-    // Used to access the system back behavior.
-    public void superOnBackPressed() {
-        super.onBackPressed();
-    }
-
-    @Override
-    public boolean dispatchKeyEvent(KeyEvent event) {
-
-        if (SDLActivity.mBrokenLibraries) {
-           return false;
-        }
-
-        int keyCode = event.getKeyCode();
-        // Ignore certain special keys so they're handled by Android
-        if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
-            keyCode == KeyEvent.KEYCODE_VOLUME_UP ||
-            keyCode == KeyEvent.KEYCODE_CAMERA ||
-            keyCode == KeyEvent.KEYCODE_ZOOM_IN || /* API 11 */
-            keyCode == KeyEvent.KEYCODE_ZOOM_OUT /* API 11 */
-            ) {
-            return false;
-        }
-        mDispatchingKeyEvent = true;
-        boolean result = super.dispatchKeyEvent(event);
-        mDispatchingKeyEvent = false;
-        return result;
-    }
-
-    public static boolean dispatchingKeyEvent() {
-        return mDispatchingKeyEvent;
-    }
-
-    /* Transition to next state */
-    public static void handleNativeState() {
-
-        if (mNextNativeState == mCurrentNativeState) {
-            // Already in same state, discard.
-            return;
-        }
-
-        // Try a transition to init state
-        if (mNextNativeState == NativeState.INIT) {
-
-            mCurrentNativeState = mNextNativeState;
-            return;
-        }
-
-        // Try a transition to paused state
-        if (mNextNativeState == NativeState.PAUSED) {
-            if (mSDLThread != null) {
-                nativePause();
-            }
-            if (mSurface != null) {
-                mSurface.handlePause();
-            }
-            mCurrentNativeState = mNextNativeState;
-            return;
-        }
-
-        // Try a transition to resumed state
-        if (mNextNativeState == NativeState.RESUMED) {
-            if (mSurface.mIsSurfaceReady && (mHasFocus || mHasMultiWindow) && mIsResumedCalled) {
-                if (mSDLThread == null) {
-                    // This is the entry point to the C app.
-                    // Start up the C app thread and enable sensor input for the first time
-                    // FIXME: Why aren't we enabling sensor input at start?
-
-                    mSDLThread = new Thread(new SDLMain(), "SDLThread");
-                    mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true);
-                    mSDLThread.start();
-
-                    // No nativeResume(), don't signal Android_ResumeSem
-                } else {
-                    nativeResume();
-                }
-                mSurface.handleResume();
-
-                mCurrentNativeState = mNextNativeState;
-            }
-        }
-    }
-
-    // Messages from the SDLMain thread
-    protected static final int COMMAND_CHANGE_TITLE = 1;
-    protected static final int COMMAND_CHANGE_WINDOW_STYLE = 2;
-    protected static final int COMMAND_TEXTEDIT_HIDE = 3;
-    protected static final int COMMAND_SET_KEEP_SCREEN_ON = 5;
-    protected static final int COMMAND_USER = 0x8000;
-
-    protected static boolean mFullscreenModeActive;
-
-    /**
-     * This method is called by SDL if SDL did not handle a message itself.
-     * This happens if a received message contains an unsupported command.
-     * Method can be overwritten to handle Messages in a different class.
-     * @param command the command of the message.
-     * @param param the parameter of the message. May be null.
-     * @return if the message was handled in overridden method.
-     */
-    protected boolean onUnhandledMessage(int command, Object param) {
-        return false;
-    }
-
-    /**
-     * A Handler class for Messages from native SDL applications.
-     * It uses current Activities as target (e.g. for the title).
-     * static to prevent implicit references to enclosing object.
-     */
-    protected static class SDLCommandHandler extends Handler {
-        @Override
-        public void handleMessage(Message msg) {
-            Context context = getContext();
-            if (context == null) {
-                Log.e(TAG, "error handling message, getContext() returned null");
-                return;
-            }
-            switch (msg.arg1) {
-            case COMMAND_CHANGE_TITLE:
-                if (context instanceof Activity) {
-                    ((Activity) context).setTitle((String)msg.obj);
-                } else {
-                    Log.e(TAG, "error handling message, getContext() returned no Activity");
-                }
-                break;
-            case COMMAND_CHANGE_WINDOW_STYLE:
-                if (context instanceof Activity) {
-                    Window window = ((Activity) context).getWindow();
-                    if (window != null) {
-                        if ((msg.obj instanceof Integer) && ((Integer) msg.obj != 0)) {
-                            int flags = View.SYSTEM_UI_FLAG_FULLSCREEN |
-                                    View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
-                                    View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
-                                    View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
-                                    View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
-                                    View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.INVISIBLE;
-                            window.getDecorView().setSystemUiVisibility(flags);
-                            window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
-                            window.clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
-                            SDLActivity.mFullscreenModeActive = true;
-                        } else {
-                            int flags = View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_VISIBLE;
-                            window.getDecorView().setSystemUiVisibility(flags);
-                            window.addFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
-                            window.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
-                            SDLActivity.mFullscreenModeActive = false;
-                        }
-                        if (Build.VERSION.SDK_INT >= 30 /* Android 11 (R) */) {
-                            window.getAttributes().layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS;
-                        }
-                        if (Build.VERSION.SDK_INT >= 30 /* Android 11 (R) */ &&
-                            Build.VERSION.SDK_INT < 35 /* Android 15 */) {
-                            SDLActivity.onNativeInsetsChanged(0, 0, 0, 0);
-                        }
-                    }
-                } else {
-                    Log.e(TAG, "error handling message, getContext() returned no Activity");
-                }
-                break;
-            case COMMAND_TEXTEDIT_HIDE:
-                if (mTextEdit != null) {
-                    // Note: On some devices setting view to GONE creates a flicker in landscape.
-                    // Setting the View's sizes to 0 is similar to GONE but without the flicker.
-                    // The sizes will be set to useful values when the keyboard is shown again.
-                    mTextEdit.setLayoutParams(new RelativeLayout.LayoutParams(0, 0));
-
-                    InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
-                    imm.hideSoftInputFromWindow(mTextEdit.getWindowToken(), 0);
-
-                    onNativeScreenKeyboardHidden();
-
-                    mSurface.requestFocus();
-                }
-                break;
-            case COMMAND_SET_KEEP_SCREEN_ON:
-            {
-                if (context instanceof Activity) {
-                    Window window = ((Activity) context).getWindow();
-                    if (window != null) {
-                        if ((msg.obj instanceof Integer) && ((Integer) msg.obj != 0)) {
-                            window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-                        } else {
-                            window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
-                        }
-                    }
-                }
-                break;
-            }
-            default:
-                if ((context instanceof SDLActivity) && !((SDLActivity) context).onUnhandledMessage(msg.arg1, msg.obj)) {
-                    Log.e(TAG, "error handling message, command is " + msg.arg1);
-                }
-            }
-        }
-    }
-
-    // Handler for the messages
-    Handler commandHandler = new SDLCommandHandler();
-
-    // Send a message from the SDLMain thread
-    protected boolean sendCommand(int command, Object data) {
-        Message msg = commandHandler.obtainMessage();
-        msg.arg1 = command;
-        msg.obj = data;
-        boolean result = commandHandler.sendMessage(msg);
-
-        if (command == COMMAND_CHANGE_WINDOW_STYLE) {
-            // Ensure we don't return until the resize has actually happened,
-            // or 500ms have passed.
-
-            boolean bShouldWait = false;
-
-            if (data instanceof Integer) {
-                // Let's figure out if we're already laid out fullscreen or not.
-                Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
-                DisplayMetrics realMetrics = new DisplayMetrics();
-                display.getRealMetrics(realMetrics);
-
-                boolean bFullscreenLayout = ((realMetrics.widthPixels == mSurface.getWidth()) &&
-                        (realMetrics.heightPixels == mSurface.getHeight()));
-
-                if ((Integer) data == 1) {
-                    // If we aren't laid out fullscreen or actively in fullscreen mode already, we're going
-                    // to change size and should wait for surfaceChanged() before we return, so the size
-                    // is right back in native code.  If we're already laid out fullscreen, though, we're
-                    // not going to change size even if we change decor modes, so we shouldn't wait for
-                    // surfaceChanged() -- which may not even happen -- and should return immediately.
-                    bShouldWait = !bFullscreenLayout;
-                } else {
-                    // If we're laid out fullscreen (even if the status bar and nav bar are present),
-                    // or are actively in fullscreen, we're going to change size and should wait for
-                    // surfaceChanged before we return, so the size is right back in native code.
-                    bShouldWait = bFullscreenLayout;
-                }
-            }
-
-            if (bShouldWait && (getContext() != null)) {
-                // We'll wait for the surfaceChanged() method, which will notify us
-                // when called.  That way, we know our current size is really the
-                // size we need, instead of grabbing a size that's still got
-                // the navigation and/or status bars before they're hidden.
-                //
-                // We'll wait for up to half a second, because some devices
-                // take a surprisingly long time for the surface resize, but
-                // then we'll just give up and return.
-                //
-                synchronized (getContext()) {
-                    try {
-                        getContext().wait(500);
-                    } catch (InterruptedException ie) {
-                        ie.printStackTrace();
-                    }
-                }
-            }
-        }
-
-        return result;
-    }
-
-    // C functions we call
-    public static native String nativeGetVersion();
-    public static native void nativeSetupJNI();
-    public static native void nativeInitMainThread();
-    public static native void nativeCleanupMainThread();
-    public static native int nativeRunMain(String library, String function, Object arguments);
-    public static native void nativeLowMemory();
-    public static native void nativeSendQuit();
-    public static native void nativeQuit();
-    public static native void nativePause();
-    public static native void nativeResume();
-    public static native void nativeFocusChanged(boolean hasFocus);
-    public static native void onNativeDropFile(String filename);
-    public static native void nativeSetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, float density, float rate);
-    public static native void onNativeResize();
-    public static native void onNativeKeyDown(int keycode);
-    public static native void onNativeKeyUp(int keycode);
-    public static native boolean onNativeSoftReturnKey();
-    public static native void onNativeKeyboardFocusLost();
-    public static native void onNativeMouse(int button, int action, float x, float y, boolean relative);
-    public static native void onNativeTouch(int touchDevId, int pointerFingerId,
-                                            int action, float x,
-                                            float y, float p);
-    public static native void onNativePen(int penId, int device_type, int button, int action, float x, float y, float p);
-    public static native void onNativeAccel(float x, float y, float z);
-    public static native void onNativeClipboardChanged();
-    public static native void onNativeSurfaceCreated();
-    public static native void onNativeSurfaceChanged();
-    public static native void onNativeSurfaceDestroyed();
-    public static native void onNativeScreenKeyboardShown();
-    public static native void onNativeScreenKeyboardHidden();
-    public static native String nativeGetHint(String name);
-    public static native boolean nativeGetHintBoolean(String name, boolean default_value);
-    public static native void nativeSetenv(String name, String value);
-    public static native void nativeSetNaturalOrientation(int orientation);
-    public static native void onNativeRotationChanged(int rotation);
-    public static native void onNativeInsetsChanged(int left, int right, int top, int bottom);
-    public static native void nativeAddTouch(int touchId, String name);
-    public static native void nativePermissionResult(int requestCode, boolean result);
-    public static native void onNativeLocaleChanged();
-    public static native void onNativeDarkModeChanged(boolean enabled);
-    public static native boolean nativeAllowRecreateActivity();
-    public static native int nativeCheckSDLThreadCounter();
-    public static native void onNativeFileDialog(int requestCode, String[] filelist, int filter);
-    public static native void onNativePinchStart();
-    public static native void onNativePinchUpdate(float scale);
-    public static native void onNativePinchEnd();
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean setActivityTitle(String title) {
-        // Called from SDLMain() thread and can't directly affect the view
-        return mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void setWindowStyle(boolean fullscreen) {
-        // Called from SDLMain() thread and can't directly affect the view
-        mSingleton.sendCommand(COMMAND_CHANGE_WINDOW_STYLE, fullscreen ? 1 : 0);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     * This is a static method for JNI convenience, it calls a non-static method
-     * so that is can be overridden
-     */
-    public static void setOrientation(int w, int h, boolean resizable, String hint)
-    {
-        if (mSingleton != null) {
-            mSingleton.setOrientationBis(w, h, resizable, hint);
-        }
-    }
-
-    /**
-     * This can be overridden
-     */
-    public void setOrientationBis(int w, int h, boolean resizable, String hint)
-    {
-        int orientation_landscape = -1;
-        int orientation_portrait = -1;
-
-        if (w <= 1 || h <= 1) {
-            // Invalid width/height, ignore this request
-            return;
-        }
-
-        /* If set, hint "explicitly controls which UI orientations are allowed". */
-        if (hint.contains("LandscapeRight") && hint.contains("LandscapeLeft")) {
-            orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE;
-        } else if (hint.contains("LandscapeLeft")) {
-            orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
-        } else if (hint.contains("LandscapeRight")) {
-            orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
-        }
-
-        /* exact match to 'Portrait' to distinguish with PortraitUpsideDown */
-        boolean contains_Portrait = hint.contains("Portrait ") || hint.endsWith("Portrait");
-
-        if (contains_Portrait && hint.contains("PortraitUpsideDown")) {
-            orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_USER_PORTRAIT;
-        } else if (contains_Portrait) {
-            orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
-        } else if (hint.contains("PortraitUpsideDown")) {
-            orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
-        }
-
-        boolean is_landscape_allowed = (orientation_landscape != -1);
-        boolean is_portrait_allowed = (orientation_portrait != -1);
-        int req; /* Requested orientation */
-
-        /* No valid hint, nothing is explicitly allowed */
-        if (!is_portrait_allowed && !is_landscape_allowed) {
-            if (resizable) {
-                /* All orientations are allowed, respecting user orientation lock setting */
-                req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
-            } else {
-                /* Fixed window and nothing specified. Get orientation from w/h of created window */
-                req = (w > h ? ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
-            }
-        } else {
-            /* At least one orientation is allowed */
-            if (resizable) {
-                if (is_portrait_allowed && is_landscape_allowed) {
-                    /* hint allows both landscape and portrait, promote to full user */
-                    req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
-                } else {
-                    /* Use the only one allowed "orientation" */
-                    req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);
-                }
-            } else {
-                /* Fixed window and both orientations are allowed. Choose one. */
-                if (is_portrait_allowed && is_landscape_allowed) {
-                    req = (w > h ? orientation_landscape : orientation_portrait);
-                } else {
-                    /* Use the only one allowed "orientation" */
-                    req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);
-                }
-            }
-        }
-
-        Log.v(TAG, "setOrientation() requestedOrientation=" + req + " width=" + w +" height="+ h +" resizable=" + resizable + " hint=" + hint);
-        mSingleton.setRequestedOrientation(req);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void minimizeWindow() {
-
-        if (mSingleton == null) {
-            return;
-        }
-
-        Intent startMain = new Intent(Intent.ACTION_MAIN);
-        startMain.addCategory(Intent.CATEGORY_HOME);
-        startMain.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
-        mSingleton.startActivity(startMain);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean shouldMinimizeOnFocusLoss() {
-        return false;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean supportsRelativeMouse()
-    {
-        // DeX mode in Samsung Experience 9.0 and earlier doesn't support relative mice properly under
-        // Android 7 APIs, and simply returns no data under Android 8 APIs.
-        //
-        // This is fixed in Samsung Experience 9.5, which corresponds to Android 8.1.0, and
-        // thus SDK version 27.  If we are in DeX mode and not API 27 or higher, as a result,
-        // we should stick to relative mode.
-        //
-        if (Build.VERSION.SDK_INT < 27 /* Android 8.1 (O_MR1) */ && isDeXMode()) {
-            return false;
-        }
-
-        return SDLActivity.getMotionListener().supportsRelativeMouse();
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean setRelativeMouseEnabled(boolean enabled)
-    {
-        if (enabled && !supportsRelativeMouse()) {
-            return false;
-        }
-
-        return SDLActivity.getMotionListener().setRelativeMouseEnabled(enabled);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean sendMessage(int command, int param) {
-        if (mSingleton == null) {
-            return false;
-        }
-        return mSingleton.sendCommand(command, param);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static Activity getContext() {
-        return SDL.getContext();
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean isAndroidTV() {
-        UiModeManager uiModeManager = (UiModeManager) getContext().getSystemService(UI_MODE_SERVICE);
-        if (uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION) {
-            return true;
-        }
-        if (Build.MANUFACTURER.equals("MINIX") && Build.MODEL.equals("NEO-U1")) {
-            return true;
-        }
-        if (Build.MANUFACTURER.equals("Amlogic") &&
-            (Build.MODEL.startsWith("TV") ||
-             Build.MODEL.equals("X96-W") ||
-             Build.MODEL.equals("A95X-R1"))) {
-            return true;
-        }
-        return false;
-    }
-
-    public static boolean isVRHeadset() {
-        if (Build.MANUFACTURER.equals("Oculus") && Build.MODEL.startsWith("Quest")) {
-            return true;
-        }
-        if (Build.MANUFACTURER.equals("Pico")) {
-            return true;
-        }
-        return false;
-    }
-
-    public static double getDiagonal()
-    {
-        DisplayMetrics metrics = new DisplayMetrics();
-        Activity activity = getContext();
-        if (activity == null) {
-            return 0.0;
-        }
-        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
-
-        double dWidthInches = metrics.widthPixels / (double)metrics.xdpi;
-        double dHeightInches = metrics.heightPixels / (double)metrics.ydpi;
-
-        return Math.sqrt((dWidthInches * dWidthInches) + (dHeightInches * dHeightInches));
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean isTablet() {
-        // If our diagonal size is seven inches or greater, we consider ourselves a tablet.
-        return (getDiagonal() >= 7.0);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean isChromebook() {
-        // https://stackoverflow.com/questions/39784415/how-to-detect-programmatically-if-android-app-is-running-in-chrome-book-or-in
-        if (getContext() != null) {
-            if (getContext().getPackageManager().hasSystemFeature("org.chromium.arc")
-                || getContext().getPackageManager().hasSystemFeature("org.chromium.arc.device_management")) {
-                return true;
-            }
-        }
-
-        // Running on AVD emulator
-        boolean isChromebookEmulator = (Build.MODEL != null && Build.MODEL.startsWith("sdk_gpc_"));
-        return isChromebookEmulator;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean isDeXMode() {
-        if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
-            return false;
-        }
-        try {
-            final Configuration config = getContext().getResources().getConfiguration();
-            final Class<?> configClass = config.getClass();
-            return configClass.getField("SEM_DESKTOP_MODE_ENABLED").getInt(configClass)
-                    == configClass.getField("semDesktopModeEnabled").getInt(config);
-        } catch(Exception ignored) {
-            return false;
-        }
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean getManifestEnvironmentVariables() {
-        try {
-            if (getContext() == null) {
-                return false;
-            }
-
-            ApplicationInfo applicationInfo = getContext().getPackageManager().getApplicationInfo(getContext().getPackageName(), PackageManager.GET_META_DATA);
-            Bundle bundle = applicationInfo.metaData;
-            if (bundle == null) {
-                return false;
-            }
-            String prefix = "SDL_ENV.";
-            final int trimLength = prefix.length();
-            for (String key : bundle.keySet()) {
-                if (key.startsWith(prefix)) {
-                    String name = key.substring(trimLength);
-                    String value = bundle.get(key).toString();
-                    nativeSetenv(name, value);
-                }
-            }
-            /* environment variables set! */
-            return true;
-        } catch (Exception e) {
-           Log.v(TAG, "exception " + e.toString());
-        }
-        return false;
-    }
-
-    // This method is called by SDLControllerManager's API 26 Generic Motion Handler.
-    public static View getContentView() {
-        return mLayout;
-    }
-
-    static class ShowTextInputTask implements Runnable {
-        /*
-         * This is used to regulate the pan&scan method to have some offset from
-         * the bottom edge of the input region and the top edge of an input
-         * method (soft keyboard)
-         */
-        static final int HEIGHT_PADDING = 15;
-
-        public int input_type;
-        public int x, y, w, h;
-
-        public ShowTextInputTask(int input_type, int x, int y, int w, int h) {
-            this.input_type = input_type;
-            this.x = x;
-            this.y = y;
-            this.w = w;
-            this.h = h;
-
-            /* Minimum size of 1 pixel, so it takes focus. */
-            if (this.w <= 0) {
-                this.w = 1;
-            }
-            if (this.h + HEIGHT_PADDING <= 0) {
-                this.h = 1 - HEIGHT_PADDING;
-            }
-        }
-
-        @Override
-        public void run() {
-            RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(w, h + HEIGHT_PADDING);
-            params.leftMargin = x;
-            params.topMargin = y;
-
-            if (mTextEdit == null) {
-                mTextEdit = new SDLDummyEdit(getContext());
-
-                mLayout.addView(mTextEdit, params);
-            } else {
-                mTextEdit.setLayoutParams(params);
-            }
-            mTextEdit.setInputType(input_type);
-
-            mTextEdit.setVisibility(View.VISIBLE);
-            mTextEdit.requestFocus();
-
-            InputMethodManager imm = (InputMethodManager) getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
-            imm.showSoftInput(mTextEdit, 0);
-
-            if (imm.isAcceptingText()) {
-                onNativeScreenKeyboardShown();
-            }
-        }
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean showTextInput(int input_type, int x, int y, int w, int h) {
-        // Transfer the task to the main thread as a Runnable
-        return mSingleton.commandHandler.post(new ShowTextInputTask(input_type, x, y, w, h));
-    }
-
-    public static boolean isTextInputEvent(KeyEvent event) {
-
-        // Key pressed with Ctrl should be sent as SDL_KEYDOWN/SDL_KEYUP and not SDL_TEXTINPUT
-        if (event.isCtrlPressed()) {
-            return false;
-        }
-
-        return event.isPrintingKey() || event.getKeyCode() == KeyEvent.KEYCODE_SPACE;
-    }
-
-    public static boolean handleKeyEvent(View v, int keyCode, KeyEvent event, InputConnection ic) {
-        int deviceId = event.getDeviceId();
-        int source = event.getSource();
-
-        if (source == InputDevice.SOURCE_UNKNOWN) {
-            InputDevice device = InputDevice.getDevice(deviceId);
-            if (device != null) {
-                source = device.getSources();
-            }
-        }
-
-//        if (event.getAction() == KeyEvent.ACTION_DOWN) {
-//            Log.v("SDL", "key down: " + keyCode + ", deviceId = " + deviceId + ", source = " + source);
-//        } else if (event.getAction() == KeyEvent.ACTION_UP) {
-//            Log.v("SDL", "key up: " + keyCode + ", deviceId = " + deviceId + ", source = " + source);
-//        }
-
-        // Dispatch the different events depending on where they come from
-        // Some SOURCE_JOYSTICK, SOURCE_DPAD or SOURCE_GAMEPAD are also SOURCE_KEYBOARD
-        // So, we try to process them as JOYSTICK/DPAD/GAMEPAD events first, if that fails we try them as KEYBOARD
-        //
-        // Furthermore, it's possible a game controller has SOURCE_KEYBOARD and
-        // SOURCE_JOYSTICK, while its key events arrive from the keyboard source
-        // So, retrieve the device itself and check all of its sources
-        if (SDLControllerManager.isDeviceSDLJoystick(deviceId)) {
-            // Note that we process events with specific key codes here
-            if (event.getAction() == KeyEvent.ACTION_DOWN) {
-                if (SDLControllerManager.onNativePadDown(deviceId, keyCode, event.getScanCode())) {
-                    return true;
-                }
-            } else if (event.getAction() == KeyEvent.ACTION_UP) {
-                if (SDLControllerManager.onNativePadUp(deviceId, keyCode, event.getScanCode())) {
-                    return true;
-                }
-            }
-        }
-
-        if ((source & InputDevice.SOURCE_MOUSE) == InputDevice.SOURCE_MOUSE) {
-            if (SDLActivity.isVRHeadset()) {
-                // The Oculus Quest controller back button comes in as source mouse, so accept that
-            } else {
-                // on some devices key events are sent for mouse BUTTON_BACK/FORWARD presses
-                // they are ignored here because sending them as mouse input to SDL is messy
-                if ((keyCode == KeyEvent.KEYCODE_BACK) || (keyCode == KeyEvent.KEYCODE_FORWARD)) {
-                    switch (event.getAction()) {
-                    case KeyEvent.ACTION_DOWN:
-                    case KeyEvent.ACTION_UP:
-                        // mark the event as handled or it will be handled by system
-                        // handling KEYCODE_BACK by system will call onBackPressed()
-                        return true;
-                    }
-                }
-            }
-        }
-
-        if (event.getAction() == KeyEvent.ACTION_DOWN) {
-            onNativeKeyDown(keyCode);
-
-            if (isTextInputEvent(event)) {
-                if (ic != null) {
-                    ic.commitText(String.valueOf((char) event.getUnicodeChar()), 1);
-                } else {
-                    SDLInputConnection.nativeCommitText(String.valueOf((char) event.getUnicodeChar()), 1);
-                }
-            }
-            return true;
-        } else if (event.getAction() == KeyEvent.ACTION_UP) {
-            onNativeKeyUp(keyCode);
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static Surface getNativeSurface() {
-        if (SDLActivity.mSurface == null) {
-            return null;
-        }
-        return SDLActivity.mSurface.getNativeSurface();
-    }
-
-    // Input
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void initTouch() {
-        int[] ids = InputDevice.getDeviceIds();
-
-        for (int id : ids) {
-            InputDevice device = InputDevice.getDevice(id);
-            /* Allow SOURCE_TOUCHSCREEN and also Virtual InputDevices because they can send TOUCHSCREEN events */
-            if (device != null && ((device.getSources() & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN
-                    || device.isVirtual())) {
-
-                nativeAddTouch(device.getId(), device.getName());
-            }
-        }
-    }
-
-    // Messagebox
-
-    /** Result of current messagebox. Also used for blocking the calling thread. */
-    protected final int[] messageboxSelection = new int[1];
-
-    /**
-     * This method is called by SDL using JNI.
-     * Shows the messagebox from UI thread and block calling thread.
-     * buttonFlags, buttonIds and buttonTexts must have same length.
-     * @param buttonFlags array containing flags for every button.
-     * @param buttonIds array containing id for every button.
-     * @param buttonTexts array containing text for every button.
-     * @param colors null for default or array of length 5 containing colors.
-     * @return button id or -1.
-     */
-    public int messageboxShowMessageBox(
-            final int flags,
-            final String title,
-            final String message,
-            final int[] buttonFlags,
-            final int[] buttonIds,
-            final String[] buttonTexts,
-            final int[] colors) {
-
-        messageboxSelection[0] = -1;
-
-        // sanity checks
-
-        if ((buttonFlags.length != buttonIds.length) && (buttonIds.length != buttonTexts.length)) {
-            return -1; // implementation broken
-        }
-
-        // collect arguments for Dialog
-
-        final Bundle args = new Bundle();
-        args.putInt("flags", flags);
-        args.putString("title", title);
-        args.putString("message", message);
-        args.putIntArray("buttonFlags", buttonFlags);
-        args.putIntArray("buttonIds", buttonIds);
-        args.putStringArray("buttonTexts", buttonTexts);
-        args.putIntArray("colors", colors);
-
-        // trigger Dialog creation on UI thread
-
-        runOnUiThread(new Runnable() {
-            @Override
-            public void run() {
-                messageboxCreateAndShow(args);
-            }
-        });
-
-        // block the calling thread
-
-        synchronized (messageboxSelection) {
-            try {
-                messageboxSelection.wait();
-            } catch (InterruptedException ex) {
-                ex.printStackTrace();
-                return -1;
-            }
-        }
-
-        // return selected value
-
-        return messageboxSelection[0];
-    }
-
-    protected void messageboxCreateAndShow(Bundle args) {
-
-        // TODO set values from "flags" to messagebox dialog
-
-        // get colors
-
-        int[] colors = args.getIntArray("colors");
-        int backgroundColor;
-        int textColor;
-        int buttonBorderColor;
-        int buttonBackgroundColor;
-        int buttonSelectedColor;
-        if (colors != null) {
-            int i = -1;
-            backgroundColor = colors[++i];
-            textColor = colors[++i];
-            buttonBorderColor = colors[++i];
-            buttonBackgroundColor = colors[++i];
-            buttonSelectedColor = colors[++i];
-        } else {
-            backgroundColor = Color.TRANSPARENT;
-            textColor = Color.TRANSPARENT;
-            buttonBorderColor = Color.TRANSPARENT;
-            buttonBackgroundColor = Color.TRANSPARENT;
-            buttonSelectedColor = Color.TRANSPARENT;
-        }
-
-        // create dialog with title and a listener to wake up calling thread
-
-        final AlertDialog dialog = new AlertDialog.Builder(this).create();
-        dialog.setTitle(args.getString("title"));
-        dialog.setCancelable(false);
-        dialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
-            @Override
-            public void onDismiss(DialogInterface unused) {
-                synchronized (messageboxSelection) {
-                    messageboxSelection.notify();
-                }
-            }
-        });
-
-        // create text
-
-        TextView message = new TextView(this);
-        message.setGravity(Gravity.CENTER);
-        message.setText(args.getString("message"));
-        if (textColor != Color.TRANSPARENT) {
-            message.setTextColor(textColor);
-        }
-
-        // create buttons
-
-        int[] buttonFlags = args.getIntArray("buttonFlags");
-        int[] buttonIds = args.getIntArray("buttonIds");
-        String[] buttonTexts = args.getStringArray("buttonTexts");
-
-        final SparseArray<Button> mapping = new SparseArray<Button>();
-
-        LinearLayout buttons = new LinearLayout(this);
-        buttons.setOrientation(LinearLayout.HORIZONTAL);
-        buttons.setGravity(Gravity.CENTER);
-        for (int i = 0; i < buttonTexts.length; ++i) {
-            Button button = new Button(this);
-            final int id = buttonIds[i];
-            button.setOnClickListener(new View.OnClickListener() {
-                @Override
-                public void onClick(View v) {
-                    messageboxSelection[0] = id;
-                    dialog.dismiss();
-                }
-            });
-            if (buttonFlags[i] != 0) {
-                // see SDL_messagebox.h
-                if ((buttonFlags[i] & 0x00000001) != 0) {
-                    mapping.put(KeyEvent.KEYCODE_ENTER, button);
-                }
-                if ((buttonFlags[i] & 0x00000002) != 0) {
-                    mapping.put(KeyEvent.KEYCODE_ESCAPE, button); /* API 11 */
-                }
-            }
-            button.setText(buttonTexts[i]);
-            if (textColor != Color.TRANSPARENT) {
-                button.setTextColor(textColor);
-            }
-            if (buttonBorderColor != Color.TRANSPARENT) {
-                // TODO set color for border of messagebox button
-            }
-            if (buttonBackgroundColor != Color.TRANSPARENT) {
-                Drawable drawable = button.getBackground();
-                if (drawable == null) {
-                    // setting the color this way removes the style
-                    button.setBackgroundColor(buttonBackgroundColor);
-                } else {
-                    // setting the color this way keeps the style (gradient, padding, etc.)
-                    drawable.setColorFilter(buttonBackgroundColor, PorterDuff.Mode.MULTIPLY);
-                }
-            }
-            if (buttonSelectedColor != Color.TRANSPARENT) {
-                // TODO set color for selected messagebox button
-            }
-            buttons.addView(button);
-        }
-
-        // create content
-
-        LinearLayout content = new LinearLayout(this);
-        content.setOrientation(LinearLayout.VERTICAL);
-        content.addView(message);
-        content.addView(buttons);
-        if (backgroundColor != Color.TRANSPARENT) {
-            content.setBackgroundColor(backgroundColor);
-        }
-
-        // add content to dialog and return
-
-        dialog.setView(content);
-        dialog.setOnKeyListener(new Dialog.OnKeyListener() {
-            @Override
-            public boolean onKey(DialogInterface d, int keyCode, KeyEvent event) {
-                Button button = mapping.get(keyCode);
-                if (button != null) {
-                    if (event.getAction() == KeyEvent.ACTION_UP) {
-                        button.performClick();
-                    }
-                    return true; // also for ignored actions
-                }
-                return false;
-            }
-        });
-
-        dialog.show();
-    }
-
-    private final Runnable rehideSystemUi = new Runnable() {
-        @Override
-        public void run() {
-            int flags = View.SYSTEM_UI_FLAG_FULLSCREEN |
-                    View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
-                    View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
-                    View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
-                    View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
-                    View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.INVISIBLE;
-
-            SDLActivity.this.getWindow().getDecorView().setSystemUiVisibility(flags);
-        }
-    };
-
-    public void onSystemUiVisibilityChange(int visibility) {
-        if (SDLActivity.mFullscreenModeActive && ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0 || (visibility & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0)) {
-
-            Handler handler = getWindow().getDecorView().getHandler();
-            if (handler != null) {
-                handler.removeCallbacks(rehideSystemUi); // Prevent a hide loop.
-                handler.postDelayed(rehideSystemUi, 2000);
-            }
-
-        }
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean clipboardHasText() {
-        return mClipboardHandler.clipboardHasText();
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static String clipboardGetText() {
-        return mClipboardHandler.clipboardGetText();
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void clipboardSetText(String string) {
-        mClipboardHandler.clipboardSetText(string);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static int createCustomCursor(int[] colors, int width, int height, int hotSpotX, int hotSpotY) {
-        Bitmap bitmap = Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888);
-        ++mLastCursorID;
-
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            try {
-                mCursors.put(mLastCursorID, PointerIcon.create(bitmap, hotSpotX, hotSpotY));
-            } catch (Exception e) {
-                return 0;
-            }
-        } else {
-            return 0;
-        }
-        return mLastCursorID;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void destroyCustomCursor(int cursorID) {
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            try {
-                mCursors.remove(cursorID);
-            } catch (Exception e) {
-            }
-        }
-        return;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean setCustomCursor(int cursorID) {
-
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            try {
-                mSurface.setPointerIcon(mCursors.get(cursorID));
-            } catch (Exception e) {
-                return false;
-            }
-        } else {
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean setSystemCursor(int cursorID) {
-        int cursor_type = 0; //PointerIcon.TYPE_NULL;
-        switch (cursorID) {
-        case SDL_SYSTEM_CURSOR_ARROW:
-            cursor_type = 1000; //PointerIcon.TYPE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_IBEAM:
-            cursor_type = 1008; //PointerIcon.TYPE_TEXT;
-            break;
-        case SDL_SYSTEM_CURSOR_WAIT:
-            cursor_type = 1004; //PointerIcon.TYPE_WAIT;
-            break;
-        case SDL_SYSTEM_CURSOR_CROSSHAIR:
-            cursor_type = 1007; //PointerIcon.TYPE_CROSSHAIR;
-            break;
-        case SDL_SYSTEM_CURSOR_WAITARROW:
-            cursor_type = 1004; //PointerIcon.TYPE_WAIT;
-            break;
-        case SDL_SYSTEM_CURSOR_SIZENWSE:
-            cursor_type = 1017; //PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_SIZENESW:
-            cursor_type = 1016; //PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_SIZEWE:
-            cursor_type = 1014; //PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_SIZENS:
-            cursor_type = 1015; //PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_SIZEALL:
-            cursor_type = 1020; //PointerIcon.TYPE_GRAB;
-            break;
-        case SDL_SYSTEM_CURSOR_NO:
-            cursor_type = 1012; //PointerIcon.TYPE_NO_DROP;
-            break;
-        case SDL_SYSTEM_CURSOR_HAND:
-            cursor_type = 1002; //PointerIcon.TYPE_HAND;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_TOPLEFT:
-            cursor_type = 1017; //PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_TOP:
-            cursor_type = 1015; //PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_TOPRIGHT:
-            cursor_type = 1016; //PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_RIGHT:
-            cursor_type = 1014; //PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_BOTTOMRIGHT:
-            cursor_type = 1017; //PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_BOTTOM:
-            cursor_type = 1015; //PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_BOTTOMLEFT:
-            cursor_type = 1016; //PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
-            break;
-        case SDL_SYSTEM_CURSOR_WINDOW_LEFT:
-            cursor_type = 1014; //PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
-            break;
-        }
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            try {
-                mSurface.setPointerIcon(PointerIcon.getSystemIcon(getContext(), cursor_type));
-            } catch (Exception e) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static void requestPermission(String permission, int requestCode) {
-        if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
-            nativePermissionResult(requestCode, true);
-            return;
-        }
-
-        Activity activity = getContext();
-        if (activity.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
-            activity.requestPermissions(new String[]{permission}, requestCode);
-        } else {
-            nativePermissionResult(requestCode, true);
-        }
-    }
-
-    @Override
-    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
-        boolean result = (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED);
-        nativePermissionResult(requestCode, result);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean openURL(String url)
-    {
-        try {
-            Intent i = new Intent(Intent.ACTION_VIEW);
-            i.setData(Uri.parse(url));
-
-            int flags = Intent.FLAG_ACTIVITY_NO_HISTORY
-                      | Intent.FLAG_ACTIVITY_MULTIPLE_TASK
-                      | Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
-            i.addFlags(flags);
-
-            mSingleton.startActivity(i);
-        } catch (Exception ex) {
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean showToast(String message, int duration, int gravity, int xOffset, int yOffset)
-    {
-        if(null == mSingleton) {
-            return false;
-        }
-
-        try
-        {
-            class OneShotTask implements Runnable {
-                private final String mMessage;
-                private final int mDuration;
-                private final int mGravity;
-                private final int mXOffset;
-                private final int mYOffset;
-
-                OneShotTask(String message, int duration, int gravity, int xOffset, int yOffset) {
-                    mMessage  = message;
-                    mDuration = duration;
-                    mGravity  = gravity;
-                    mXOffset  = xOffset;
-                    mYOffset  = yOffset;
-                }
-
-                public void run() {
-                    try
-                    {
-                        Toast toast = Toast.makeText(mSingleton, mMessage, mDuration);
-                        if (mGravity >= 0) {
-                            toast.setGravity(mGravity, mXOffset, mYOffset);
-                        }
-                        toast.show();
-                    } catch(Exception ex) {
-                        Log.e(TAG, ex.getMessage());
-                    }
-                }
-            }
-            mSingleton.runOnUiThread(new OneShotTask(message, duration, gravity, xOffset, yOffset));
-        } catch(Exception ex) {
-            return false;
-        }
-        return true;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static int openFileDescriptor(String uri, String mode) throws Exception {
-        if (mSingleton == null) {
-            return -1;
-        }
-
-        try {
-            ParcelFileDescriptor pfd = mSingleton.getContentResolver().openFileDescriptor(Uri.parse(uri), mode);
-            return pfd != null ? pfd.detachFd() : -1;
-        } catch (FileNotFoundException | SecurityException e) {
-            e.printStackTrace();
-            return -1;
-        }
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static boolean showFileDialog(String[] filters, boolean allowMultiple, boolean forWrite, int requestCode) {
-        if (mSingleton == null) {
-            return false;
-        }
-
-        if (forWrite) {
-            allowMultiple = false;
-        }
-
-        /* Convert string list of extensions to their respective MIME types */
-        ArrayList<String> mimes = new ArrayList<>();
-        MimeTypeMap mimeTypeMap = MimeTypeMap.getSingleton();
-        if (filters != null) {
-            for (String pattern : filters) {
-                String[] extensions = pattern.split(";");
-
-                if (extensions.length == 1 && extensions[0].equals("*")) {
-                    /* Handle "*" special case */
-                    mimes.add("*/*");
-                } else {
-                    for (String ext : extensions) {
-                        String mime = mimeTypeMap.getMimeTypeFromExtension(ext);
-                        if (mime != null) {
-                            mimes.add(mime);
-                        }
-                    }
-                }
-            }
-        }
-
-        /* Display the file dialog */
-        Intent intent = new Intent(forWrite ? Intent.ACTION_CREATE_DOCUMENT : Intent.ACTION_OPEN_DOCUMENT);
-        intent.addCategory(Intent.CATEGORY_OPENABLE);
-        intent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, allowMultiple);
-        switch (mimes.size()) {
-            case 0:
-                intent.setType("*/*");
-                break;
-            case 1:
-                intent.setType(mimes.get(0));
-                break;
-            default:
-                intent.setType("*/*");
-                intent.putExtra(Intent.EXTRA_MIME_TYPES, mimes.toArray(new String[]{}));
-        }
-
-        try {
-            mSingleton.startActivityForResult(intent, requestCode);
-        } catch (ActivityNotFoundException e) {
-            Log.e(TAG, "Unable to open file dialog.", e);
-            return false;
-        }
-
-        /* Save current dialog state */
-        mFileDialogState = new SDLFileDialogState();
-        mFileDialogState.requestCode = requestCode;
-        mFileDialogState.multipleChoice = allowMultiple;
-        return true;
-    }
-
-    /* Internal class used to track active open file dialog */
-    static class SDLFileDialogState {
-        int requestCode;
-        boolean multipleChoice;
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    public static String getPreferredLocales() {
-        String result = "";
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7 (N) */) {
-            LocaleList locales = LocaleList.getAdjustedDefault();
-            for (int i = 0; i < locales.size(); i++) {
-                if (i != 0) result += ",";
-                result += formatLocale(locales.get(i));
-            }
-        } else if (mCurrentLocale != null) {
-            result = formatLocale(mCurrentLocale);
-        }
-        return result;
-    }
-
-    public static String formatLocale(Locale locale) {
-        String result = "";
-        String lang = "";
-        if (locale.getLanguage() == "in") {
-            // Indonesian is "id" according to ISO 639.2, but on Android is "in" because of Java backwards compatibility
-            lang = "id";
-        } else if (locale.getLanguage() == "") {
-            // Make sure language is never empty
-            lang = "und";
-        } else {
-            lang = locale.getLanguage();
-        }
-
-        if (locale.getCountry() == "") {
-            result = lang;
-        } else {
-            result = lang + "_" + locale.getCountry();
-        }
-        return result;
-    }
-}
-
-/**
-    Simple runnable to start the SDL application
-*/
-class SDLMain implements Runnable {
-    @Override
-    public void run() {
-        // Runs SDLActivity.main()
-
-        try {
-            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_DISPLAY);
-        } catch (Exception e) {
-            Log.v("SDL", "modify thread properties failed " + e.toString());
-        }
-
-        SDLActivity.nativeInitMainThread();
-        SDLActivity.mSingleton.main();
-        SDLActivity.nativeCleanupMainThread();
-
-        if (SDLActivity.mSingleton != null && !SDLActivity.mSingleton.isFinishing()) {
-            // Let's finish the Activity
-            SDLActivity.mSDLThread = null;
-            SDLActivity.mSDLMainFinished = true;
-            SDLActivity.mSingleton.finish();
-        }  // else: Activity is already being destroyed
-
-    }
-}
-
-class SDLClipboardHandler implements
-    ClipboardManager.OnPrimaryClipChangedListener {
-
-    protected ClipboardManager mClipMgr;
-
-    SDLClipboardHandler() {
-       mClipMgr = (ClipboardManager) SDL.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
-       mClipMgr.addPrimaryClipChangedListener(this);
-    }
-
-    public boolean clipboardHasText() {
-        if (Build.VERSION.SDK_INT >= 28 /* Android 9 (P) */) {
-            return mClipMgr.hasPrimaryClip();
-        } else {
-            return mClipMgr.hasText();
-        }
-    }
-
-    public String clipboardGetText() {
-        ClipData clip = mClipMgr.getPrimaryClip();
-        if (clip != null) {
-            ClipData.Item item = clip.getItemAt(0);
-            if (item != null) {
-                CharSequence text = item.getText();
-                if (text != null) {
-                    return text.toString();
-                }
-            }
-        }
-        return null;
-    }
-
-    public void clipboardSetText(String string) {
-        mClipMgr.removePrimaryClipChangedListener(this);
-        if (string.isEmpty()) {
-            if (Build.VERSION.SDK_INT >= 28 /* Android 9 (P) */) {
-                mClipMgr.clearPrimaryClip();
-            } else {
-                ClipData clip = ClipData.newPlainText(null, "");
-                mClipMgr.setPrimaryClip(clip);
-            }
-        } else {
-            ClipData clip = ClipData.newPlainText(null, string);
-            mClipMgr.setPrimaryClip(clip);
-        }
-        mClipMgr.addPrimaryClipChangedListener(this);
-    }
-
-    @Override
-    public void onPrimaryClipChanged() {
-        SDLActivity.onNativeClipboardChanged();
-    }
-}
-
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLAudioManager.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLAudioManager.java
deleted file mode 100644
index 43706fa409..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLAudioManager.java
+++ /dev/null
@@ -1,126 +0,0 @@
-package org.libsdl.app;
-
-import android.content.Context;
-import android.media.AudioDeviceCallback;
-import android.media.AudioDeviceInfo;
-import android.media.AudioManager;
-import android.os.Build;
-import android.util.Log;
-
-import java.util.Arrays;
-import java.util.ArrayList;
-
-class SDLAudioManager {
-    protected static final String TAG = "SDLAudio";
-
-    protected static Context mContext;
-
-    private static AudioDeviceCallback mAudioDeviceCallback;
-
-    static void initialize() {
-        mAudioDeviceCallback = null;
-
-        if(Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */)
-        {
-            mAudioDeviceCallback = new AudioDeviceCallback() {
-                @Override
-                public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
-                    for (AudioDeviceInfo deviceInfo : addedDevices) {
-                        nativeAddAudioDevice(deviceInfo.isSink(), deviceInfo.getProductName().toString(), deviceInfo.getId());
-                    }
-                }
-
-                @Override
-                public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
-                    for (AudioDeviceInfo deviceInfo : removedDevices) {
-                        nativeRemoveAudioDevice(deviceInfo.isSink(), deviceInfo.getId());
-                    }
-                }
-            };
-        }
-    }
-
-    static void setContext(Context context) {
-        mContext = context;
-    }
-
-    static void release(Context context) {
-        // no-op atm
-    }
-
-    // Audio
-
-    private static AudioDeviceInfo getInputAudioDeviceInfo(int deviceId) {
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-            for (AudioDeviceInfo deviceInfo : audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)) {
-                if (deviceInfo.getId() == deviceId) {
-                    return deviceInfo;
-                }
-            }
-        }
-        return null;
-    }
-
-    private static AudioDeviceInfo getPlaybackAudioDeviceInfo(int deviceId) {
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-            for (AudioDeviceInfo deviceInfo : audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)) {
-                if (deviceInfo.getId() == deviceId) {
-                    return deviceInfo;
-                }
-            }
-        }
-        return null;
-    }
-
-    static void registerAudioDeviceCallback() {
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-            // get an initial list now, before hotplug callbacks fire.
-            for (AudioDeviceInfo dev : audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)) {
-                if (dev.getType() == AudioDeviceInfo.TYPE_TELEPHONY) {
-                    continue;  // Device cannot be opened
-                }
-                nativeAddAudioDevice(dev.isSink(), dev.getProductName().toString(), dev.getId());
-            }
-            for (AudioDeviceInfo dev : audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)) {
-                nativeAddAudioDevice(dev.isSink(), dev.getProductName().toString(), dev.getId());
-            }
-            audioManager.registerAudioDeviceCallback(mAudioDeviceCallback, null);
-        }
-    }
-
-    static void unregisterAudioDeviceCallback() {
-        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-            AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
-            audioManager.unregisterAudioDeviceCallback(mAudioDeviceCallback);
-        }
-    }
-
-    /** This method is called by SDL using JNI. */
-    static void audioSetThreadPriority(boolean recording, int device_id) {
-        try {
-
-            /* Set thread name */
-            if (recording) {
-                Thread.currentThread().setName("SDLAudioC" + device_id);
-            } else {
-                Thread.currentThread().setName("SDLAudioP" + device_id);
-            }
-
-            /* Set thread priority */
-            android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_AUDIO);
-
-        } catch (Exception e) {
-            Log.v(TAG, "modify thread properties failed " + e.toString());
-        }
-    }
-
-    static native void nativeSetupJNI();
-
-    static native void nativeRemoveAudioDevice(boolean recording, int deviceId);
-
-    static native void nativeAddAudioDevice(boolean recording, String name, int deviceId);
-
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLControllerManager.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLControllerManager.java
deleted file mode 100644
index 8681d050b7..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLControllerManager.java
+++ /dev/null
@@ -1,1010 +0,0 @@
-package org.libsdl.app;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-import android.content.Context;
-import android.hardware.lights.Light;
-import android.hardware.lights.LightsRequest;
-import android.hardware.lights.LightsManager;
-import android.hardware.lights.LightState;
-import android.hardware.Sensor;
-import android.hardware.SensorEvent;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
-import android.graphics.Color;
-import android.os.Build;
-import android.os.VibrationEffect;
-import android.os.Vibrator;
-import android.os.VibratorManager;
-import android.util.Log;
-import android.view.InputDevice;
-import android.view.KeyEvent;
-import android.view.MotionEvent;
-import android.view.View;
-
-
-public class SDLControllerManager
-{
-
-    static native void nativeSetupJNI();
-
-    static native void nativeAddJoystick(int device_id, String name, String desc,
-                                                int vendor_id, int product_id,
-                                                int button_mask,
-                                                int naxes, int axis_mask, int nhats, boolean can_rumble, boolean has_rgb_led,
-                                                boolean has_accelerometer, boolean has_gyroscope);
-    static native void nativeRemoveJoystick(int device_id);
-    static native void nativeAddHaptic(int device_id, String name);
-    static native void nativeRemoveHaptic(int device_id);
-    static public native boolean onNativePadDown(int device_id, int keycode, int scancode);
-    static public native boolean onNativePadUp(int device_id, int keycode, int scancode);
-    static native void onNativeJoy(int device_id, int axis,
-                                          float value);
-    static native void onNativeHat(int device_id, int hat_id,
-                                          int x, int y);
-    static native void onNativeJoySensor(int device_id, int sensor_type, long sensor_timestamp, float x, float y, float z);
-
-    protected static SDLJoystickHandler mJoystickHandler;
-    protected static SDLHapticHandler mHapticHandler;
-
-    private static final String TAG = "SDLControllerManager";
-
-    static void initialize() {
-        if (mJoystickHandler == null) {
-            mJoystickHandler = new SDLJoystickHandler();
-        }
-
-        if (mHapticHandler == null) {
-            if (Build.VERSION.SDK_INT >= 31 /* Android 12.0 (S) */) {
-                mHapticHandler = new SDLHapticHandler_API31();
-            } else if (Build.VERSION.SDK_INT >= 26 /* Android 8.0 (O) */) {
-                mHapticHandler = new SDLHapticHandler_API26();
-            } else {
-                mHapticHandler = new SDLHapticHandler();
-            }
-        }
-    }
-
-    // Joystick glue code, just a series of stubs that redirect to the SDLJoystickHandler instance
-    static public boolean handleJoystickMotionEvent(MotionEvent event) {
-        return mJoystickHandler.handleMotionEvent(event);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void pollInputDevices() {
-        mJoystickHandler.pollInputDevices();
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void joystickSetLED(int device_id, int red, int green, int blue) {
-        mJoystickHandler.setLED(device_id, red, green, blue);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void joystickSetSensorsEnabled(int device_id, boolean enabled) {
-        mJoystickHandler.setSensorsEnabled(device_id, enabled);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void pollHapticDevices() {
-        mHapticHandler.pollHapticDevices();
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void hapticRun(int device_id, float intensity, int length) {
-        mHapticHandler.run(device_id, intensity, length);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void hapticRumble(int device_id, float low_frequency_intensity, float high_frequency_intensity, int length) {
-        mHapticHandler.rumble(device_id, low_frequency_intensity, high_frequency_intensity, length);
-    }
-
-    /**
-     * This method is called by SDL using JNI.
-     */
-    static void hapticStop(int device_id)
-    {
-        mHapticHandler.stop(device_id);
-    }
-
-    // Check if a given device is considered a possible SDL joystick
-    static public boolean isDeviceSDLJoystick(int deviceId) {
-        InputDevice device = InputDevice.getDevice(deviceId);
-        // We cannot use InputDevice.isVirtual before API 16, so let's accept
-        // only nonnegative device ids (VIRTUAL_KEYBOARD equals -1)
-        if ((device == null) || (deviceId < 0)) {
-            return false;
-        }
-        int sources = device.getSources();
-
-        /* This is called for every button press, so let's not spam the logs */
-        /*
-        if ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
-            Log.v(TAG, "Input device " + device.getName() + " has class joystick.");
-        }
-        if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) {
-            Log.v(TAG, "Input device " + device.getName() + " is a dpad.");
-        }
-        if ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD) {
-            Log.v(TAG, "Input device " + device.getName() + " is a gamepad.");
-        }
-        */
-
-        return ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0 ||
-                ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) ||
-                ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD)
-        );
-    }
-
-}
-
-
-/* Actual joystick functionality available for API >= 19 devices */
-class SDLJoystickHandler {
-
-    static class SDLJoystick {
-        int device_id;
-        String name;
-        String desc;
-        ArrayList<InputDevice.MotionRange> axes;
-        ArrayList<InputDevice.MotionRange> hats;
-        ArrayList<Light> lights;
-        LightsManager.LightsSession lightsSession;
-        SensorManager sensorManager;
-        SDLJoySensorListener sensorListener;
-        Sensor accelerometerSensor;
-        Sensor gyroscopeSensor;
-    }
-    static class RangeComparator implements Comparator<InputDevice.MotionRange> {
-        @Override
-        public int compare(InputDevice.MotionRange arg0, InputDevice.MotionRange arg1) {
-            // Some controllers, like the Moga Pro 2, return AXIS_GAS (22) for right trigger and AXIS_BRAKE (23) for left trigger - swap them so they're sorted in the right order for SDL
-            int arg0Axis = arg0.getAxis();
-            int arg1Axis = arg1.getAxis();
-            if (arg0Axis == MotionEvent.AXIS_GAS) {
-                arg0Axis = MotionEvent.AXIS_BRAKE;
-            } else if (arg0Axis == MotionEvent.AXIS_BRAKE) {
-                arg0Axis = MotionEvent.AXIS_GAS;
-            }
-            if (arg1Axis == MotionEvent.AXIS_GAS) {
-                arg1Axis = MotionEvent.AXIS_BRAKE;
-            } else if (arg1Axis == MotionEvent.AXIS_BRAKE) {
-                arg1Axis = MotionEvent.AXIS_GAS;
-            }
-
-            // Make sure the AXIS_Z is sorted between AXIS_RY and AXIS_RZ.
-            // This is because the usual pairing are:
-            // - AXIS_X + AXIS_Y (left stick).
-            // - AXIS_RX, AXIS_RY (sometimes the right stick, sometimes triggers).
-            // - AXIS_Z, AXIS_RZ (sometimes the right stick, sometimes triggers).
-            // This sorts the axes in the above order, which tends to be correct
-            // for Xbox-ish game pads that have the right stick on RX/RY and the
-            // triggers on Z/RZ.
-            //
-            // Gamepads that don't have AXIS_Z/AXIS_RZ but use
-            // AXIS_LTRIGGER/AXIS_RTRIGGER are unaffected by this.
-            //
-            // References:
-            // - https://developer.android.com/develop/ui/views/touch-and-input/game-controllers/controller-input
-            // - https://www.kernel.org/doc/html/latest/input/gamepad.html
-            if (arg0Axis == MotionEvent.AXIS_Z) {
-                arg0Axis = MotionEvent.AXIS_RZ - 1;
-            } else if (arg0Axis > MotionEvent.AXIS_Z && arg0Axis < MotionEvent.AXIS_RZ) {
-                --arg0Axis;
-            }
-            if (arg1Axis == MotionEvent.AXIS_Z) {
-                arg1Axis = MotionEvent.AXIS_RZ - 1;
-            } else if (arg1Axis > MotionEvent.AXIS_Z && arg1Axis < MotionEvent.AXIS_RZ) {
-                --arg1Axis;
-            }
-
-            return arg0Axis - arg1Axis;
-        }
-    }
-
-    private final ArrayList<SDLJoystick> mJoysticks;
-
-    SDLJoystickHandler() {
-
-        mJoysticks = new ArrayList<SDLJoystick>();
-    }
-
-    /**
-     * Handles adding and removing of input devices.
-     */
-    synchronized void pollInputDevices() {
-        int[] deviceIds = InputDevice.getDeviceIds();
-
-        for (int device_id : deviceIds) {
-            if (SDLControllerManager.isDeviceSDLJoystick(device_id)) {
-                SDLJoystick joystick = getJoystick(device_id);
-                if (joystick == null) {
-                    InputDevice joystickDevice = InputDevice.getDevice(device_id);
-                    joystick = new SDLJoystick();
-                    joystick.device_id = device_id;
-                    joystick.name = joystickDevice.getName();
-                    joystick.desc = getJoystickDescriptor(joystickDevice);
-                    joystick.axes = new ArrayList<InputDevice.MotionRange>();
-                    joystick.hats = new ArrayList<InputDevice.MotionRange>();
-                    java.util.Set<Integer> axisStrsSet = new java.util.HashSet<Integer>();
-                    joystick.lights = new ArrayList<Light>();
-
-                    List<InputDevice.MotionRange> ranges = joystickDevice.getMotionRanges();
-                    Collections.sort(ranges, new RangeComparator());
-                    for (InputDevice.MotionRange range : ranges) {
-                        if (((range.getSource() & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) && axisStrsSet.add(range.getAxis())) {
-                            if (range.getAxis() == MotionEvent.AXIS_HAT_X || range.getAxis() == MotionEvent.AXIS_HAT_Y) {
-                                joystick.hats.add(range);
-                            } else {
-                                joystick.axes.add(range);
-                            }
-                        }
-                    }
-
-                    boolean can_rumble = false;
-                    boolean has_rgb_led = false;
-                    boolean has_accelerometer = false;
-                    boolean has_gyroscope = false;
-                    if (Build.VERSION.SDK_INT >= 31 /* Android 12.0 (S) */) {
-                        VibratorManager vibratorManager = joystickDevice.getVibratorManager();
-                        int[] vibrators = vibratorManager.getVibratorIds();
-                        if (vibrators.length > 0) {
-                            can_rumble = true;
-                        }
-                        LightsManager lightsManager = joystickDevice.getLightsManager();
-                        List<Light> lights = lightsManager.getLights();
-                        for (Light light : lights) {
-                            if (light.hasRgbControl()) {
-                                joystick.lights.add(light);
-                            }
-                        }
-                        if (!joystick.lights.isEmpty()) {
-                            joystick.lightsSession = lightsManager.openSession();
-                            has_rgb_led = true;
-                        }
-                        SensorManager sensorManager = joystickDevice.getSensorManager();
-                        if (sensorManager != null) {
-                            joystick.sensorManager = sensorManager;
-                            joystick.sensorListener = new SDLJoySensorListener(joystick.device_id);
-                            joystick.accelerometerSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
-                            if (joystick.accelerometerSensor != null) {
-                                has_accelerometer = true;
-                            }
-                            joystick.gyroscopeSensor = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
-                            if (joystick.gyroscopeSensor != null) {
-                                has_gyroscope = true;
-                            }
-                        }
-                    }
-
-                    mJoysticks.add(joystick);
-                    SDLControllerManager.nativeAddJoystick(joystick.device_id, joystick.name, joystick.desc,
-                            getVendorId(joystickDevice), getProductId(joystickDevice),
-                            getButtonMask(joystickDevice), joystick.axes.size(), getAxisMask(joystick.axes), joystick.hats.size()/2, can_rumble, has_rgb_led,
-                            has_accelerometer, has_gyroscope);
-                }
-            }
-        }
-
-        /* Check removed devices */
-        ArrayList<Integer> removedDevices = null;
-        for (SDLJoystick joystick : mJoysticks) {
-            int device_id = joystick.device_id;
-            int i;
-            for (i = 0; i < deviceIds.length; i++) {
-                if (device_id == deviceIds[i]) break;
-            }
-            if (i == deviceIds.length) {
-                if (removedDevices == null) {
-                    removedDevices = new ArrayList<Integer>();
-                }
-                removedDevices.add(device_id);
-            }
-        }
-
-        if (removedDevices != null) {
-            for (int device_id : removedDevices) {
-                SDLControllerManager.nativeRemoveJoystick(device_id);
-                for (int i = 0; i < mJoysticks.size(); i++) {
-                    if (mJoysticks.get(i).device_id == device_id) {
-                        if (Build.VERSION.SDK_INT >= 31 /* Android 12.0 (S) */) {
-                            if (mJoysticks.get(i).lightsSession != null) {
-                                try {
-                                    mJoysticks.get(i).lightsSession.close();
-                                } catch (Exception e) {
-                                    // Session may already be unregistered when device disconnects
-                                }
-                                mJoysticks.get(i).lightsSession = null;
-                            }
-                        }
-                        mJoysticks.remove(i);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    synchronized protected SDLJoystick getJoystick(int device_id) {
-        for (SDLJoystick joystick : mJoysticks) {
-            if (joystick.device_id == device_id) {
-                return joystick;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Handles given MotionEvent.
-     * @param event the event to be handled.
-     * @return if given event was processed.
-     */
-    boolean handleMotionEvent(MotionEvent event) {
-        int actionPointerIndex = event.getActionIndex();
-        int action = event.getActionMasked();
-        if (action == MotionEvent.ACTION_MOVE) {
-            SDLJoystick joystick = getJoystick(event.getDeviceId());
-            if (joystick != null) {
-                for (int i = 0; i < joystick.axes.size(); i++) {
-                    InputDevice.MotionRange range = joystick.axes.get(i);
-                    /* Normalize the value to -1...1 */
-                    float value = (event.getAxisValue(range.getAxis(), actionPointerIndex) - range.getMin()) / range.getRange() * 2.0f - 1.0f;
-                    SDLControllerManager.onNativeJoy(joystick.device_id, i, value);
-                }
-                for (int i = 0; i < joystick.hats.size() / 2; i++) {
-                    int hatX = Math.round(event.getAxisValue(joystick.hats.get(2 * i).getAxis(), actionPointerIndex));
-                    int hatY = Math.round(event.getAxisValue(joystick.hats.get(2 * i + 1).getAxis(), actionPointerIndex));
-                    SDLControllerManager.onNativeHat(joystick.device_id, i, hatX, hatY);
-                }
-            }
-        }
-        return true;
-    }
-
-    String getJoystickDescriptor(InputDevice joystickDevice) {
-        String desc = joystickDevice.getDescriptor();
-
-        if (desc != null && !desc.isEmpty()) {
-            return desc;
-        }
-
-        return joystickDevice.getName();
-    }
-
-    int getProductId(InputDevice joystickDevice) {
-        return joystickDevice.getProductId();
-    }
-
-    int getVendorId(InputDevice joystickDevice) {
-        return joystickDevice.getVendorId();
-    }
-
-    int getAxisMask(List<InputDevice.MotionRange> ranges) {
-        // For compatibility, keep computing the axis mask like before,
-        // only really distinguishing 2, 4 and 6 axes.
-        int axis_mask = 0;
-        if (ranges.size() >= 2) {
-            // ((1 << SDL_GAMEPAD_AXIS_LEFTX) | (1 << SDL_GAMEPAD_AXIS_LEFTY))
-            axis_mask |= 0x0003;
-        }
-        if (ranges.size() >= 4) {
-            // ((1 << SDL_GAMEPAD_AXIS_RIGHTX) | (1 << SDL_GAMEPAD_AXIS_RIGHTY))
-            axis_mask |= 0x000c;
-        }
-        if (ranges.size() >= 6) {
-            // ((1 << SDL_GAMEPAD_AXIS_LEFT_TRIGGER) | (1 << SDL_GAMEPAD_AXIS_RIGHT_TRIGGER))
-            axis_mask |= 0x0030;
-        }
-        // Also add an indicator bit for whether the sorting order has changed.
-        // This serves to disable outdated gamecontrollerdb.txt mappings.
-        boolean have_z = false;
-        boolean have_past_z_before_rz = false;
-        for (InputDevice.MotionRange range : ranges) {
-            int axis = range.getAxis();
-            if (axis == MotionEvent.AXIS_Z) {
-                have_z = true;
-            } else if (axis > MotionEvent.AXIS_Z && axis < MotionEvent.AXIS_RZ) {
-                have_past_z_before_rz = true;
-            }
-        }
-        if (have_z && have_past_z_before_rz) {
-            // If both these exist, the compare() function changed sorting order.
-            // Set a bit to indicate this fact.
-            axis_mask |= 0x8000;
-        }
-        return axis_mask;
-    }
-
-    int getButtonMask(InputDevice joystickDevice) {
-        int button_mask = 0;
-        int[] keys = new int[] {
-            KeyEvent.KEYCODE_BUTTON_A,
-            KeyEvent.KEYCODE_BUTTON_B,
-            KeyEvent.KEYCODE_BUTTON_X,
-            KeyEvent.KEYCODE_BUTTON_Y,
-            KeyEvent.KEYCODE_BACK,
-            KeyEvent.KEYCODE_MENU,
-            KeyEvent.KEYCODE_BUTTON_MODE,
-            KeyEvent.KEYCODE_BUTTON_START,
-            KeyEvent.KEYCODE_BUTTON_THUMBL,
-            KeyEvent.KEYCODE_BUTTON_THUMBR,
-            KeyEvent.KEYCODE_BUTTON_L1,
-            KeyEvent.KEYCODE_BUTTON_R1,
-            KeyEvent.KEYCODE_DPAD_UP,
-            KeyEvent.KEYCODE_DPAD_DOWN,
-            KeyEvent.KEYCODE_DPAD_LEFT,
-            KeyEvent.KEYCODE_DPAD_RIGHT,
-            KeyEvent.KEYCODE_BUTTON_SELECT,
-            KeyEvent.KEYCODE_DPAD_CENTER,
-
-            // These don't map into any SDL controller buttons directly
-            KeyEvent.KEYCODE_BUTTON_L2,
-            KeyEvent.KEYCODE_BUTTON_R2,
-            KeyEvent.KEYCODE_BUTTON_C,
-            KeyEvent.KEYCODE_BUTTON_Z,
-            KeyEvent.KEYCODE_BUTTON_1,
-            KeyEvent.KEYCODE_BUTTON_2,
-            KeyEvent.KEYCODE_BUTTON_3,
-            KeyEvent.KEYCODE_BUTTON_4,
-            KeyEvent.KEYCODE_BUTTON_5,
-            KeyEvent.KEYCODE_BUTTON_6,
-            KeyEvent.KEYCODE_BUTTON_7,
-            KeyEvent.KEYCODE_BUTTON_8,
-            KeyEvent.KEYCODE_BUTTON_9,
-            KeyEvent.KEYCODE_BUTTON_10,
-            KeyEvent.KEYCODE_BUTTON_11,
-            KeyEvent.KEYCODE_BUTTON_12,
-            KeyEvent.KEYCODE_BUTTON_13,
-            KeyEvent.KEYCODE_BUTTON_14,
-            KeyEvent.KEYCODE_BUTTON_15,
-            KeyEvent.KEYCODE_BUTTON_16,
-        };
-        int[] masks = new int[] {
-            (1 << 0),   // A -> A
-            (1 << 1),   // B -> B
-            (1 << 2),   // X -> X
-            (1 << 3),   // Y -> Y
-            (1 << 4),   // BACK -> BACK
-            (1 << 6),   // MENU -> START
-            (1 << 5),   // MODE -> GUIDE
-            (1 << 6),   // START -> START
-            (1 << 7),   // THUMBL -> LEFTSTICK
-            (1 << 8),   // THUMBR -> RIGHTSTICK
-            (1 << 9),   // L1 -> LEFTSHOULDER
-            (1 << 10),  // R1 -> RIGHTSHOULDER
-            (1 << 11),  // DPAD_UP -> DPAD_UP
-            (1 << 12),  // DPAD_DOWN -> DPAD_DOWN
-            (1 << 13),  // DPAD_LEFT -> DPAD_LEFT
-            (1 << 14),  // DPAD_RIGHT -> DPAD_RIGHT
-            (1 << 4),   // SELECT -> BACK
-            (1 << 0),   // DPAD_CENTER -> A
-            (1 << 15),  // L2 -> ??
-            (1 << 16),  // R2 -> ??
-            (1 << 17),  // C -> ??
-            (1 << 18),  // Z -> ??
-            (1 << 20),  // 1 -> ??
-            (1 << 21),  // 2 -> ??
-            (1 << 22),  // 3 -> ??
-            (1 << 23),  // 4 -> ??
-            (1 << 24),  // 5 -> ??
-            (1 << 25),  // 6 -> ??
-            (1 << 26),  // 7 -> ??
-            (1 << 27),  // 8 -> ??
-            (1 << 28),  // 9 -> ??
-            (1 << 29),  // 10 -> ??
-            (1 << 30),  // 11 -> ??
-            (1 << 31),  // 12 -> ??
-            // We're out of room...
-            0xFFFFFFFF,  // 13 -> ??
-            0xFFFFFFFF,  // 14 -> ??
-            0xFFFFFFFF,  // 15 -> ??
-            0xFFFFFFFF,  // 16 -> ??
-        };
-        boolean[] has_keys = joystickDevice.hasKeys(keys);
-        for (int i = 0; i < keys.length; ++i) {
-            if (has_keys[i]) {
-                button_mask |= masks[i];
-            }
-        }
-        return button_mask;
-    }
-
-    void setLED(int device_id, int red, int green, int blue) {
-        if (Build.VERSION.SDK_INT < 31 /* Android 12.0 (S) */) {
-            return;
-        }
-        SDLJoystick joystick = getJoystick(device_id);
-        if (joystick == null || joystick.lights.isEmpty()) {
-            return;
-        }
-        LightsRequest.Builder lightsRequest = new LightsRequest.Builder();
-        LightState lightState = new LightState.Builder().setColor(Color.rgb(red, green, blue)).build();
-        for (Light light : joystick.lights) {
-            if (light.hasRgbControl()) {
-                lightsRequest.addLight(light, lightState);
-            }
-        }
-        joystick.lightsSession.requestLights(lightsRequest.build());
-    }
-
-    void setSensorsEnabled(int device_id, boolean enabled) {
-        if (Build.VERSION.SDK_INT < 31 /* Android 12.0 (S) */) {
-            return;
-        }
-        SDLJoystick joystick = getJoystick(device_id);
-        if (joystick == null || joystick.sensorManager == null) {
-            return;
-        }
-        if (enabled) {
-            if (joystick.accelerometerSensor != null) {
-                SDLSensorManager.registerListener(joystick.sensorManager, joystick.sensorListener, joystick.accelerometerSensor, SensorManager.SENSOR_DELAY_GAME);
-            }
-            if (joystick.gyroscopeSensor != null) {
-                SDLSensorManager.registerListener(joystick.sensorManager, joystick.sensorListener, joystick.gyroscopeSensor, SensorManager.SENSOR_DELAY_GAME);
-            }
-        } else {
-            if (joystick.accelerometerSensor != null) {
-                SDLSensorManager.unregisterListener(joystick.sensorManager, joystick.sensorListener, joystick.accelerometerSensor);
-            }
-            if (joystick.gyroscopeSensor != null) {
-                SDLSensorManager.unregisterListener(joystick.sensorManager, joystick.sensorListener, joystick.gyroscopeSensor);
-            }
-        }
-    }
-}
-
-class SDLHapticHandler_API31 extends SDLHapticHandler {
-    @Override
-    void run(int device_id, float intensity, int length) {
-        SDLHaptic haptic = getHaptic(device_id);
-        if (haptic != null) {
-            vibrate(haptic.vib, intensity, length);
-        }
-    }
-
-    @Override
-    void rumble(int device_id, float low_frequency_intensity, float high_frequency_intensity, int length) {
-        InputDevice device = InputDevice.getDevice(device_id);
-        if (device == null) {
-            return;
-        }
-
-        if (Build.VERSION.SDK_INT < 31 /* Android 12.0 (S) */) {
-            /* Silence 'lint' warning */
-            return;
-        }
-
-        VibratorManager manager = device.getVibratorManager();
-        int[] vibrators = manager.getVibratorIds();
-        if (vibrators.length >= 2) {
-            vibrate(manager.getVibrator(vibrators[0]), low_frequency_intensity, length);
-            vibrate(manager.getVibrator(vibrators[1]), high_frequency_intensity, length);
-        } else if (vibrators.length == 1) {
-            float intensity = (low_frequency_intensity * 0.6f) + (high_frequency_intensity * 0.4f);
-            vibrate(manager.getVibrator(vibrators[0]), intensity, length);
-        }
-    }
-
-    private void vibrate(Vibrator vibrator, float intensity, int length) {
-
-        if (Build.VERSION.SDK_INT < 31 /* Android 12.0 (S) */) {
-            /* Silence 'lint' warning */
-            return;
-        }
-
-        if (intensity == 0.0f) {
-            vibrator.cancel();
-            return;
-        }
-
-        int value = Math.round(intensity * 255);
-        if (value > 255) {
-            value = 255;
-        }
-        if (value < 1) {
-            vibrator.cancel();
-            return;
-        }
-        try {
-            vibrator.vibrate(VibrationEffect.createOneShot(length, value));
-        }
-        catch (Exception e) {
-            // Fall back to the generic method, which uses DEFAULT_AMPLITUDE, but works even if
-            // something went horribly wrong with the Android 8.0 APIs.
-            vibrator.vibrate(length);
-        }
-    }
-}
-
-class SDLHapticHandler_API26 extends SDLHapticHandler {
-    @Override
-    void run(int device_id, float intensity, int length) {
-
-        if (Build.VERSION.SDK_INT < 26 /* Android 8.0 (O) */) {
-            /* Silence 'lint' warning */
-            return;
-        }
-
-        SDLHaptic haptic = getHaptic(device_id);
-        if (haptic != null) {
-            if (intensity == 0.0f) {
-                stop(device_id);
-                return;
-            }
-
-            int vibeValue = Math.round(intensity * 255);
-
-            if (vibeValue > 255) {
-                vibeValue = 255;
-            }
-            if (vibeValue < 1) {
-                stop(device_id);
-                return;
-            }
-            try {
-                haptic.vib.vibrate(VibrationEffect.createOneShot(length, vibeValue));
-            }
-            catch (Exception e) {
-                // Fall back to the generic method, which uses DEFAULT_AMPLITUDE, but works even if
-                // something went horribly wrong with the Android 8.0 APIs.
-                haptic.vib.vibrate(length);
-            }
-        }
-    }
-}
-
-class SDLHapticHandler {
-
-    static class SDLHaptic {
-        int device_id;
-        String name;
-        Vibrator vib;
-    }
-
-    private final ArrayList<SDLHaptic> mHaptics;
-
-    SDLHapticHandler() {
-        mHaptics = new ArrayList<SDLHaptic>();
-    }
-
-    void run(int device_id, float intensity, int length) {
-        SDLHaptic haptic = getHaptic(device_id);
-        if (haptic != null) {
-            haptic.vib.vibrate(length);
-        }
-    }
-
-    void rumble(int device_id, float low_frequency_intensity, float high_frequency_intensity, int length) {
-        // Not supported in older APIs
-    }
-
-    void stop(int device_id) {
-        SDLHaptic haptic = getHaptic(device_id);
-        if (haptic != null) {
-            haptic.vib.cancel();
-        }
-    }
-
-    synchronized void pollHapticDevices() {
-
-        final int deviceId_VIBRATOR_SERVICE = 999999;
-        boolean hasVibratorService = false;
-
-        /* Check VIBRATOR_SERVICE */
-        Vibrator vib = (Vibrator) SDL.getContext().getSystemService(Context.VIBRATOR_SERVICE);
-        if (vib != null) {
-            hasVibratorService = vib.hasVibrator();
-
-            if (hasVibratorService) {
-                SDLHaptic haptic = getHaptic(deviceId_VIBRATOR_SERVICE);
-                if (haptic == null) {
-                    haptic = new SDLHaptic();
-                    haptic.device_id = deviceId_VIBRATOR_SERVICE;
-                    haptic.name = "VIBRATOR_SERVICE";
-                    haptic.vib = vib;
-                    mHaptics.add(haptic);
-                    SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
-                }
-            }
-        }
-
-        /* Check removed devices */
-        ArrayList<Integer> removedDevices = null;
-        for (SDLHaptic haptic : mHaptics) {
-            int device_id = haptic.device_id;
-            if (device_id != deviceId_VIBRATOR_SERVICE || !hasVibratorService) {
-                if (removedDevices == null) {
-                    removedDevices = new ArrayList<Integer>();
-                }
-                removedDevices.add(device_id);
-            }  // else: don't remove the vibrator if it is still present
-        }
-
-        if (removedDevices != null) {
-            for (int device_id : removedDevices) {
-                SDLControllerManager.nativeRemoveHaptic(device_id);
-                for (int i = 0; i < mHaptics.size(); i++) {
-                    if (mHaptics.get(i).device_id == device_id) {
-                        mHaptics.remove(i);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    synchronized protected SDLHaptic getHaptic(int device_id) {
-        for (SDLHaptic haptic : mHaptics) {
-            if (haptic.device_id == device_id) {
-                return haptic;
-            }
-        }
-        return null;
-    }
-}
-
-class SDLGenericMotionListener_API14 implements View.OnGenericMotionListener {
-    protected static final int SDL_PEN_DEVICE_TYPE_UNKNOWN = 0;
-    protected static final int SDL_PEN_DEVICE_TYPE_DIRECT = 1;
-    protected static final int SDL_PEN_DEVICE_TYPE_INDIRECT = 2;
-
-    // Generic Motion (mouse hover, joystick...) events go here
-    @Override
-    public boolean onGenericMotion(View v, MotionEvent event) {
-        if (event.getSource() == InputDevice.SOURCE_JOYSTICK)
-            return SDLControllerManager.handleJoystickMotionEvent(event);
-
-        float x, y;
-        int action = event.getActionMasked();
-        int pointerCount = event.getPointerCount();
-        boolean consumed = false;
-
-        for (int i = 0; i < pointerCount; i++) {
-            int toolType = event.getToolType(i);
-
-            if (toolType == MotionEvent.TOOL_TYPE_MOUSE) {
-                switch (action) {
-                    case MotionEvent.ACTION_SCROLL:
-                        x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, i);
-                        y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, i);
-                        SDLActivity.onNativeMouse(0, action, x, y, false);
-                        consumed = true;
-                        break;
-
-                    case MotionEvent.ACTION_HOVER_MOVE:
-                        x = getEventX(event, i);
-                        y = getEventY(event, i);
-
-                        SDLActivity.onNativeMouse(0, action, x, y, checkRelativeEvent(event));
-                        consumed = true;
-                        break;
-
-                    default:
-                        break;
-                }
-            } else if (toolType == MotionEvent.TOOL_TYPE_STYLUS || toolType == MotionEvent.TOOL_TYPE_ERASER) {
-                switch (action) {
-                    case MotionEvent.ACTION_HOVER_ENTER:
-                    case MotionEvent.ACTION_HOVER_MOVE:
-                    case MotionEvent.ACTION_HOVER_EXIT:
-                        x = event.getX(i);
-                        y = event.getY(i);
-                        float p = event.getPressure(i);
-                        if (p > 1.0f) {
-                            // may be larger than 1.0f on some devices
-                            // see the documentation of getPressure(i)
-                            p = 1.0f;
-                        }
-
-                        // BUTTON_STYLUS_PRIMARY is 2^5, so shift by 4, and apply SDL_PEN_INPUT_DOWN/SDL_PEN_INPUT_ERASER_TIP
-                        int buttons = (event.getButtonState() >> 4) | (1 << (toolType == MotionEvent.TOOL_TYPE_STYLUS ? 0 : 30));
-                        if ((event.getButtonState() & MotionEvent.BUTTON_TERTIARY) != 0) {
-                            buttons |= 0x08;
-                        }
-
-                        SDLActivity.onNativePen(event.getPointerId(i), getPenDeviceType(event.getDevice()), buttons, action, x, y, p);
-                        consumed = true;
-                        break;
-                }
-            }
-        }
-
-        return consumed;
-    }
-
-    boolean supportsRelativeMouse() {
-        return false;
-    }
-
-    boolean inRelativeMode() {
-        return false;
-    }
-
-    boolean setRelativeMouseEnabled(boolean enabled) {
-        return false;
-    }
-
-    void reclaimRelativeMouseModeIfNeeded() {
-
-    }
-
-    boolean checkRelativeEvent(MotionEvent event) {
-        return inRelativeMode();
-    }
-
-    float getEventX(MotionEvent event, int pointerIndex) {
-        return event.getX(pointerIndex);
-    }
-
-    float getEventY(MotionEvent event, int pointerIndex) {
-        return event.getY(pointerIndex);
-    }
-
-    int getPenDeviceType(InputDevice penDevice) {
-        return SDL_PEN_DEVICE_TYPE_UNKNOWN;
-    }
-}
-
-class SDLGenericMotionListener_API24 extends SDLGenericMotionListener_API14 {
-    // Generic Motion (mouse hover, joystick...) events go here
-
-    private boolean mRelativeModeEnabled;
-
-    @Override
-    boolean supportsRelativeMouse() {
-        return true;
-    }
-
-    @Override
-    boolean inRelativeMode() {
-        return mRelativeModeEnabled;
-    }
-
-    @Override
-    boolean setRelativeMouseEnabled(boolean enabled) {
-        mRelativeModeEnabled = enabled;
-        return true;
-    }
-
-    @Override
-    float getEventX(MotionEvent event, int pointerIndex) {
-        if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
-            /* Silence 'lint' warning */
-            return 0;
-        }
-
-        if (mRelativeModeEnabled && event.getToolType(pointerIndex) == MotionEvent.TOOL_TYPE_MOUSE) {
-            return event.getAxisValue(MotionEvent.AXIS_RELATIVE_X, pointerIndex);
-        } else {
-            return event.getX(pointerIndex);
-        }
-    }
-
-    @Override
-    float getEventY(MotionEvent event, int pointerIndex) {
-        if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
-            /* Silence 'lint' warning */
-            return 0;
-        }
-
-        if (mRelativeModeEnabled && event.getToolType(pointerIndex) == MotionEvent.TOOL_TYPE_MOUSE) {
-            return event.getAxisValue(MotionEvent.AXIS_RELATIVE_Y, pointerIndex);
-        } else {
-            return event.getY(pointerIndex);
-        }
-    }
-}
-
-class SDLGenericMotionListener_API26 extends SDLGenericMotionListener_API24 {
-    // Generic Motion (mouse hover, joystick...) events go here
-    private boolean mRelativeModeEnabled;
-
-    @Override
-    boolean supportsRelativeMouse() {
-        return (!SDLActivity.isDeXMode() || Build.VERSION.SDK_INT >= 27 /* Android 8.1 (O_MR1) */);
-    }
-
-    @Override
-    boolean inRelativeMode() {
-        return mRelativeModeEnabled;
-    }
-
-    @Override
-    boolean setRelativeMouseEnabled(boolean enabled) {
-
-        if (Build.VERSION.SDK_INT < 26 /* Android 8.0 (O) */) {
-            /* Silence 'lint' warning */
-            return false;
-        }
-
-        if (!SDLActivity.isDeXMode() || Build.VERSION.SDK_INT >= 27 /* Android 8.1 (O_MR1) */) {
-            if (enabled) {
-                SDLActivity.getContentView().requestPointerCapture();
-            } else {
-                SDLActivity.getContentView().releasePointerCapture();
-            }
-            mRelativeModeEnabled = enabled;
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    void reclaimRelativeMouseModeIfNeeded() {
-
-        if (Build.VERSION.SDK_INT < 26 /* Android 8.0 (O) */) {
-            /* Silence 'lint' warning */
-            return;
-        }
-
-        if (mRelativeModeEnabled && !SDLActivity.isDeXMode()) {
-            SDLActivity.getContentView().requestPointerCapture();
-        }
-    }
-
-    @Override
-    boolean checkRelativeEvent(MotionEvent event) {
-        if (Build.VERSION.SDK_INT < 26 /* Android 8.0 (O) */) {
-            /* Silence 'lint' warning */
-            return false;
-        }
-        return event.getSource() == InputDevice.SOURCE_MOUSE_RELATIVE;
-    }
-
-    @Override
-    float getEventX(MotionEvent event, int pointerIndex) {
-        // Relative mouse in capture mode will only have relative for X/Y
-        return event.getX(pointerIndex);
-    }
-
-    @Override
-    float getEventY(MotionEvent event, int pointerIndex) {
-        // Relative mouse in capture mode will only have relative for X/Y
-        return event.getY(pointerIndex);
-    }
-}
-
-class SDLGenericMotionListener_API29 extends SDLGenericMotionListener_API26 {
-    @Override
-    int getPenDeviceType(InputDevice penDevice)
-    {
-        if (penDevice == null) {
-            return SDL_PEN_DEVICE_TYPE_UNKNOWN;
-        }
-
-        return penDevice.isExternal() ? SDL_PEN_DEVICE_TYPE_INDIRECT : SDL_PEN_DEVICE_TYPE_DIRECT;
-    }
-}
-
-class SDLJoySensorListener implements SensorEventListener {
-    int device_id;
-
-    public SDLJoySensorListener(int device_id) {
-        this.device_id = device_id;
-    }
-
-    @Override
-    public void onAccuracyChanged(Sensor sensor, int accuracy) {}
-
-    @Override
-    public void onSensorChanged(SensorEvent event) {
-        SDLControllerManager.onNativeJoySensor(device_id, event.sensor.getType(), event.timestamp, event.values[0], event.values[1], event.values[2]);
-    }
-}
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLDummyEdit.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLDummyEdit.java
deleted file mode 100644
index 61d8fe8508..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLDummyEdit.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package org.libsdl.app;
-
-import android.content.*;
-import android.text.InputType;
-import android.view.*;
-import android.view.inputmethod.EditorInfo;
-import android.view.inputmethod.InputConnection;
-
-/* This is a fake invisible editor view that receives the input and defines the
- * pan&scan region
- */
-public class SDLDummyEdit extends View implements View.OnKeyListener
-{
-    InputConnection ic;
-    int input_type;
-
-    SDLDummyEdit(Context context) {
-        super(context);
-        setFocusableInTouchMode(true);
-        setFocusable(true);
-        setOnKeyListener(this);
-    }
-
-    void setInputType(int input_type) {
-        this.input_type = input_type;
-    }
-
-    @Override
-    public boolean onCheckIsTextEditor() {
-        return true;
-    }
-
-    @Override
-    public boolean onKey(View v, int keyCode, KeyEvent event) {
-        return SDLActivity.handleKeyEvent(v, keyCode, event, ic);
-    }
-
-    //
-    @Override
-    public boolean onKeyPreIme (int keyCode, KeyEvent event) {
-        // As seen on StackOverflow: http://stackoverflow.com/questions/7634346/keyboard-hide-event
-        // FIXME: Discussion at http://bugzilla.libsdl.org/show_bug.cgi?id=1639
-        // FIXME: This is not a 100% effective solution to the problem of detecting if the keyboard is showing or not
-        // FIXME: A more effective solution would be to assume our Layout to be RelativeLayout or LinearLayout
-        // FIXME: And determine the keyboard presence doing this: http://stackoverflow.com/questions/2150078/how-to-check-visibility-of-software-keyboard-in-android
-        // FIXME: An even more effective way would be if Android provided this out of the box, but where would the fun be in that :)
-        if (event.getAction()==KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
-            if (SDLActivity.mTextEdit != null && SDLActivity.mTextEdit.getVisibility() == View.VISIBLE) {
-                SDLActivity.onNativeKeyboardFocusLost();
-            }
-        }
-        return super.onKeyPreIme(keyCode, event);
-    }
-
-    @Override
-    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
-        ic = new SDLInputConnection(this, true);
-
-        outAttrs.inputType = input_type;
-        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI |
-                              EditorInfo.IME_FLAG_NO_FULLSCREEN /* API 11 */;
-
-        return ic;
-    }
-}
-
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLInputConnection.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLInputConnection.java
deleted file mode 100644
index fdc2994c15..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLInputConnection.java
+++ /dev/null
@@ -1,136 +0,0 @@
-package org.libsdl.app;
-
-import android.content.*;
-import android.os.Build;
-import android.text.Editable;
-import android.view.*;
-import android.view.inputmethod.BaseInputConnection;
-import android.widget.EditText;
-
-class SDLInputConnection extends BaseInputConnection
-{
-    protected EditText mEditText;
-    protected String mCommittedText = "";
-
-    SDLInputConnection(View targetView, boolean fullEditor) {
-        super(targetView, fullEditor);
-        mEditText = new EditText(SDL.getContext());
-    }
-
-    @Override
-    public Editable getEditable() {
-        return mEditText.getEditableText();
-    }
-
-    @Override
-    public boolean sendKeyEvent(KeyEvent event) {
-        /*
-         * This used to handle the keycodes from soft keyboard (and IME-translated input from hardkeyboard)
-         * However, as of Ice Cream Sandwich and later, almost all soft keyboard doesn't generate key presses
-         * and so we need to generate them ourselves in commitText.  To avoid duplicates on the handful of keys
-         * that still do, we empty this out.
-         */
-
-        /*
-         * Return DOES still generate a key event, however.  So rather than using it as the 'click a button' key
-         * as we do with physical keyboards, let's just use it to hide the keyboard.
-         */
-
-        if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
-            if (SDLActivity.onNativeSoftReturnKey()) {
-                return true;
-            }
-        }
-
-        return super.sendKeyEvent(event);
-    }
-
-    @Override
-    public boolean commitText(CharSequence text, int newCursorPosition) {
-        if (!super.commitText(text, newCursorPosition)) {
-            return false;
-        }
-        updateText();
-        return true;
-    }
-
-    @Override
-    public boolean setComposingText(CharSequence text, int newCursorPosition) {
-        if (!super.setComposingText(text, newCursorPosition)) {
-            return false;
-        }
-        updateText();
-        return true;
-    }
-
-    @Override
-    public boolean deleteSurroundingText(int beforeLength, int afterLength) {
-        // Workaround to capture backspace key. Ref: http://stackoverflow.com/questions>/14560344/android-backspace-in-webview-baseinputconnection
-        // and https://bugzilla.libsdl.org/show_bug.cgi?id=2265
-        if (beforeLength > 0 && afterLength == 0) {
-            // backspace(s)
-            while (beforeLength-- > 0) {
-                nativeGenerateScancodeForUnichar('\b');
-            }
-            return true;
-       }
-
-        if (!super.deleteSurroundingText(beforeLength, afterLength)) {
-            return false;
-        }
-        updateText();
-        return true;
-    }
-
-    protected void updateText() {
-        final Editable content = getEditable();
-        if (content == null) {
-            return;
-        }
-
-        String text = content.toString();
-        int compareLength = Math.min(text.length(), mCommittedText.length());
-        int matchLength, offset;
-
-        /* Backspace over characters that are no longer in the string */
-        for (matchLength = 0; matchLength < compareLength; ) {
-            int codePoint = mCommittedText.codePointAt(matchLength);
-            if (codePoint != text.codePointAt(matchLength)) {
-                break;
-            }
-            matchLength += Character.charCount(codePoint);
-        }
-        /* FIXME: This doesn't handle graphemes, like '🌬️' */
-        for (offset = matchLength; offset < mCommittedText.length(); ) {
-            int codePoint = mCommittedText.codePointAt(offset);
-            nativeGenerateScancodeForUnichar('\b');
-            offset += Character.charCount(codePoint);
-        }
-
-        if (matchLength < text.length()) {
-            String pendingText = text.subSequence(matchLength, text.length()).toString();
-            if (!SDLActivity.dispatchingKeyEvent()) {
-                for (offset = 0; offset < pendingText.length(); ) {
-                    int codePoint = pendingText.codePointAt(offset);
-                    if (codePoint == '\n') {
-                        if (SDLActivity.onNativeSoftReturnKey()) {
-                            return;
-                        }
-                    }
-                    /* Higher code points don't generate simulated scancodes */
-                    if (codePoint > 0 && codePoint < 128) {
-                        nativeGenerateScancodeForUnichar((char)codePoint);
-                    }
-                    offset += Character.charCount(codePoint);
-                }
-            }
-            SDLInputConnection.nativeCommitText(pendingText, 0);
-        }
-        mCommittedText = text;
-    }
-
-    public static native void nativeCommitText(String text, int newCursorPosition);
-
-    public static native void nativeGenerateScancodeForUnichar(char c);
-}
-
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLSensorManager.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLSensorManager.java
deleted file mode 100644
index 586e3fab6e..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLSensorManager.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.libsdl.app;
-
-import android.hardware.Sensor;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
-
-// This class coordinates synchronized access to sensor manager registration
-//
-// This prevents a java.util.ConcurrentModificationException exception on
-// Android 16, specifically on the Samsung Tab S9 Ultra.
-
-class SDLSensorManager
-{
-    static private SDLSensorManager mManager = new SDLSensorManager();
-
-    public static void registerListener(SensorManager manager, SensorEventListener listener, Sensor sensor, int samplingPeriodUs) {
-        mManager.RegisterListener(manager, listener, sensor, samplingPeriodUs);
-    }
-
-    public static void unregisterListener(SensorManager manager, SensorEventListener listener, Sensor sensor) {
-        mManager.UnregisterListener(manager, listener, sensor);
-    }
-
-    private synchronized void RegisterListener(SensorManager manager, SensorEventListener listener, Sensor sensor, int samplingPeriodUs) {
-        manager.registerListener(listener, sensor, samplingPeriodUs, null);
-    }
-
-    private synchronized void UnregisterListener(SensorManager manager, SensorEventListener listener, Sensor sensor) {
-        manager.unregisterListener(listener, sensor);
-    }
-}
-
diff --git a/platforms/android/app/src/main/java/org/libsdl/app/SDLSurface.java b/platforms/android/app/src/main/java/org/libsdl/app/SDLSurface.java
deleted file mode 100644
index 8d56658958..0000000000
--- a/platforms/android/app/src/main/java/org/libsdl/app/SDLSurface.java
+++ /dev/null
@@ -1,469 +0,0 @@
-package org.libsdl.app;
-
-
-import android.content.Context;
-import android.content.pm.ActivityInfo;
-import android.graphics.Insets;
-import android.hardware.Sensor;
-import android.hardware.SensorEvent;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
-import android.os.Build;
-import android.util.DisplayMetrics;
-import android.util.Log;
-import android.view.Display;
-import android.view.InputDevice;
-import android.view.KeyEvent;
-import android.view.MotionEvent;
-import android.view.PointerIcon;
-import android.view.Surface;
-import android.view.SurfaceHolder;
-import android.view.SurfaceView;
-import android.view.View;
-import android.view.WindowInsets;
-import android.view.WindowManager;
-
-import android.view.ScaleGestureDetector;
-
-/**
-    SDLSurface. This is what we draw on, so we need to know when it's created
-    in order to do anything useful.
-
-    Because of this, that's where we set up the SDL thread
-*/
-public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
-    View.OnApplyWindowInsetsListener, View.OnKeyListener, View.OnTouchListener,
-    SensorEventListener, ScaleGestureDetector.OnScaleGestureListener {
-
-    private static native void auroraNativeSetSurfaceReady(boolean ready);
-
-    // Sensors
-    protected SensorManager mSensorManager;
-    protected Display mDisplay;
-
-    // Keep track of the surface size to normalize touch events
-    protected float mWidth, mHeight;
-
-    // Is SurfaceView ready for rendering
-    protected boolean mIsSurfaceReady;
-
-    // Is on-screen keyboard visible
-    protected boolean mKeyboardVisible;
-
-    // Pinch events
-    private final ScaleGestureDetector scaleGestureDetector;
-
-    // Startup
-    protected SDLSurface(Context context) {
-        super(context);
-        getHolder().addCallback(this);
-
-        scaleGestureDetector = new ScaleGestureDetector(context, this);
-
-        setFocusable(true);
-        setFocusableInTouchMode(true);
-        requestFocus();
-        setOnApplyWindowInsetsListener(this);
-        setOnKeyListener(this);
-        setOnTouchListener(this);
-
-        mDisplay = ((WindowManager)context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
-        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
-
-        setOnGenericMotionListener(SDLActivity.getMotionListener());
-
-        // Some arbitrary defaults to avoid a potential division by zero
-        mWidth = 1.0f;
-        mHeight = 1.0f;
-
-        mIsSurfaceReady = false;
-    }
-
-    protected void handlePause() {
-        enableSensor(Sensor.TYPE_ACCELEROMETER, false);
-    }
-
-    protected void handleResume() {
-        setFocusable(true);
-        setFocusableInTouchMode(true);
-        requestFocus();
-        setOnApplyWindowInsetsListener(this);
-        setOnKeyListener(this);
-        setOnTouchListener(this);
-        enableSensor(Sensor.TYPE_ACCELEROMETER, true);
-    }
-
-    protected Surface getNativeSurface() {
-        return getHolder().getSurface();
-    }
-
-    // Called when we have a valid drawing surface
-    @Override
-    public void surfaceCreated(SurfaceHolder holder) {
-        Log.v("SDL", "surfaceCreated()");
-        auroraNativeSetSurfaceReady(false);
-        SDLActivity.onNativeSurfaceCreated();
-    }
-
-    // Called when we lose the surface
-    @Override
-    public void surfaceDestroyed(SurfaceHolder holder) {
-        Log.v("SDL", "surfaceDestroyed()");
-        auroraNativeSetSurfaceReady(false);
-
-        // Transition to pause, if needed
-        SDLActivity.mNextNativeState = SDLActivity.NativeState.PAUSED;
-        SDLActivity.handleNativeState();
-
-        mIsSurfaceReady = false;
-        SDLActivity.onNativeSurfaceDestroyed();
-    }
-
-    // Called when the surface is resized
-    @Override
-    public void surfaceChanged(SurfaceHolder holder,
-                               int format, int width, int height) {
-        Log.v("SDL", "surfaceChanged()");
-
-        if (SDLActivity.mSingleton == null) {
-            return;
-        }
-
-        mWidth = width;
-        mHeight = height;
-        int nDeviceWidth = width;
-        int nDeviceHeight = height;
-        float density = 1.0f;
-        try
-        {
-            DisplayMetrics realMetrics = new DisplayMetrics();
-            mDisplay.getRealMetrics( realMetrics );
-            nDeviceWidth = realMetrics.widthPixels;
-            nDeviceHeight = realMetrics.heightPixels;
-            // Use densityDpi instead of density to more closely match what the UI scale is
-            density = (float)realMetrics.densityDpi / 160.0f;
-        } catch(Exception ignored) {
-        }
-
-        synchronized(SDLActivity.getContext()) {
-            // In case we're waiting on a size change after going fullscreen, send a notification.
-            SDLActivity.getContext().notifyAll();
-        }
-
-        Log.v("SDL", "Window size: " + width + "x" + height);
-        Log.v("SDL", "Device size: " + nDeviceWidth + "x" + nDeviceHeight);
-        SDLActivity.nativeSetScreenResolution(width, height, nDeviceWidth, nDeviceHeight, density, mDisplay.getRefreshRate());
-        SDLActivity.onNativeResize();
-
-        // Prevent a screen distortion glitch,
-        // for instance when the device is in Landscape and a Portrait App is resumed.
-        boolean skip = false;
-        int requestedOrientation = SDLActivity.mSingleton.getRequestedOrientation();
-
-        if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT || requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
-            if (mWidth > mHeight) {
-               skip = true;
-            }
-        } else if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE || requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
-            if (mWidth < mHeight) {
-               skip = true;
-            }
-        }
-
-        // Special Patch for Square Resolution: Black Berry Passport
-        if (skip) {
-           double min = Math.min(mWidth, mHeight);
-           double max = Math.max(mWidth, mHeight);
-
-           if (max / min < 1.20) {
-              Log.v("SDL", "Don't skip on such aspect-ratio. Could be a square resolution.");
-              skip = false;
-           }
-        }
-
-        // Don't skip if we might be multi-window or have popup dialogs
-        if (skip) {
-            if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
-                skip = false;
-            }
-        }
-
-        if (skip) {
-           Log.v("SDL", "Skip .. Surface is not ready.");
-           mIsSurfaceReady = false;
-           return;
-        }
-
-        /* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
-        SDLActivity.onNativeSurfaceChanged();
-
-        /* Surface is ready */
-        mIsSurfaceReady = true;
-        auroraNativeSetSurfaceReady(true);
-
-        SDLActivity.mNextNativeState = SDLActivity.NativeState.RESUMED;
-        SDLActivity.handleNativeState();
-    }
-
-    // Window inset
-    @Override
-    public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {
-        if (Build.VERSION.SDK_INT >= 30 /* Android 11 (R) */) {
-            Insets combined = insets.getInsets(WindowInsets.Type.systemBars() |
-                                               WindowInsets.Type.systemGestures() |
-                                               WindowInsets.Type.mandatorySystemGestures() |
-                                               WindowInsets.Type.tappableElement() |
-                                               WindowInsets.Type.displayCutout());
-
-            SDLActivity.onNativeInsetsChanged(combined.left, combined.right, combined.top, combined.bottom);
-
-            if (insets.isVisible(WindowInsets.Type.ime())) {
-                if (!mKeyboardVisible) {
-                    mKeyboardVisible = true;
-                    SDLActivity.onNativeScreenKeyboardShown();
-                }
-            } else {
-                if (mKeyboardVisible) {
-                    mKeyboardVisible = false;
-                    SDLActivity.onNativeScreenKeyboardHidden();
-                }
-            }
-        }
-
-        // Pass these to any child views in case they need them
-        return insets;
-    }
-
-    // Key events
-    @Override
-    public boolean onKey(View v, int keyCode, KeyEvent event) {
-        return SDLActivity.handleKeyEvent(v, keyCode, event, null);
-    }
-
-    private float getNormalizedX(float x)
-    {
-        if (mWidth <= 1) {
-            return 0.5f;
-        } else {
-            return (x / (mWidth - 1));
-        }
-    }
-
-    private float getNormalizedY(float y)
-    {
-        if (mHeight <= 1) {
-            return 0.5f;
-        } else {
-            return (y / (mHeight - 1));
-        }
-    }
-
-    // Touch events
-    @Override
-    public boolean onTouch(View v, MotionEvent event) {
-        /* Ref: http://developer.android.com/training/gestures/multi.html */
-        int touchDevId = event.getDeviceId();
-        final int pointerCount = event.getPointerCount();
-        int action = event.getActionMasked();
-        int pointerId;
-        int i = 0;
-        float x,y,p;
-
-        if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN)
-            i = event.getActionIndex();
-
-        do {
-            int toolType = event.getToolType(i);
-
-            if (toolType == MotionEvent.TOOL_TYPE_MOUSE) {
-                int buttonState = event.getButtonState();
-                boolean relative = false;
-
-                // We need to check if we're in relative mouse mode and get the axis offset rather than the x/y values
-                // if we are. We'll leverage our existing mouse motion listener
-                SDLGenericMotionListener_API14 motionListener = SDLActivity.getMotionListener();
-                x = motionListener.getEventX(event, i);
-                y = motionListener.getEventY(event, i);
-                relative = motionListener.inRelativeMode();
-
-                SDLActivity.onNativeMouse(buttonState, action, x, y, relative);
-            } else if (toolType == MotionEvent.TOOL_TYPE_STYLUS || toolType == MotionEvent.TOOL_TYPE_ERASER) {
-                pointerId = event.getPointerId(i);
-                x = event.getX(i);
-                y = event.getY(i);
-                p = event.getPressure(i);
-                if (p > 1.0f) {
-                    // may be larger than 1.0f on some devices
-                    // see the documentation of getPressure(i)
-                    p = 1.0f;
-                }
-
-                // BUTTON_STYLUS_PRIMARY is 2^5, so shift by 4, and apply SDL_PEN_INPUT_DOWN/SDL_PEN_INPUT_ERASER_TIP
-                int buttonState = (event.getButtonState() >> 4) | (1 << (toolType == MotionEvent.TOOL_TYPE_STYLUS ? 0 : 30));
-                if ((event.getButtonState() & MotionEvent.BUTTON_TERTIARY) != 0) {
-                    buttonState |= 0x08;
-                }
-
-                SDLActivity.onNativePen(pointerId, SDLActivity.getMotionListener().getPenDeviceType(event.getDevice()), buttonState, action, x, y, p);
-            } else { // MotionEvent.TOOL_TYPE_FINGER or MotionEvent.TOOL_TYPE_UNKNOWN
-                pointerId = event.getPointerId(i);
-                x = getNormalizedX(event.getX(i));
-                y = getNormalizedY(event.getY(i));
-                p = event.getPressure(i);
-                if (p > 1.0f) {
-                    // may be larger than 1.0f on some devices
-                    // see the documentation of getPressure(i)
-                    p = 1.0f;
-                }
-
-                SDLActivity.onNativeTouch(touchDevId, pointerId, action, x, y, p);
-            }
-
-            // Non-primary up/down
-            if (action == MotionEvent.ACTION_POINTER_UP || action == MotionEvent.ACTION_POINTER_DOWN)
-                break;
-        } while (++i < pointerCount);
-
-        scaleGestureDetector.onTouchEvent(event);
-
-        return true;
-    }
-
-    // Sensor events
-    protected void enableSensor(int sensortype, boolean enabled) {
-        // TODO: This uses getDefaultSensor - what if we have >1 accels?
-        if (enabled) {
-            SDLSensorManager.registerListener(mSensorManager, this,
-                            mSensorManager.getDefaultSensor(sensortype),
-                            SensorManager.SENSOR_DELAY_GAME);
-        } else {
-            SDLSensorManager.unregisterListener(mSensorManager, this,
-                            mSensorManager.getDefaultSensor(sensortype));
-        }
-    }
-
-    @Override
-    public void onAccuracyChanged(Sensor sensor, int accuracy) {
-        // TODO
-    }
-
-    @Override
-    public void onSensorChanged(SensorEvent event) {
-        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
-
-            // Since we may have an orientation set, we won't receive onConfigurationChanged events.
-            // We thus should check here.
-            int newRotation;
-
-            float x, y;
-            switch (mDisplay.getRotation()) {
-                case Surface.ROTATION_0:
-                default:
-                    x = event.values[0];
-                    y = event.values[1];
-                    newRotation = 0;
-                    break;
-                case Surface.ROTATION_90:
-                    x = -event.values[1];
-                    y = event.values[0];
-                    newRotation = 90;
-                    break;
-                case Surface.ROTATION_180:
-                    x = -event.values[0];
-                    y = -event.values[1];
-                    newRotation = 180;
-                    break;
-                case Surface.ROTATION_270:
-                    x = event.values[1];
-                    y = -event.values[0];
-                    newRotation = 270;
-                    break;
-            }
-
-            if (newRotation != SDLActivity.mCurrentRotation) {
-                SDLActivity.mCurrentRotation = newRotation;
-                SDLActivity.onNativeRotationChanged(newRotation);
-            }
-
-            SDLActivity.onNativeAccel(-x / SensorManager.GRAVITY_EARTH,
-                                      y / SensorManager.GRAVITY_EARTH,
-                                      event.values[2] / SensorManager.GRAVITY_EARTH);
-
-
-        }
-    }
-
-    // Prevent android internal NullPointerException (https://github.com/libsdl-org/SDL/issues/13306)
-    @Override
-    public PointerIcon onResolvePointerIcon(MotionEvent event, int pointerIndex) {
-        try {
-            return super.onResolvePointerIcon(event, pointerIndex);
-        } catch (NullPointerException e) {
-            return null;
-        }
-    }
-
-    // Captured pointer events for API 26.
-    @Override
-    public boolean onCapturedPointerEvent(MotionEvent event)
-    {
-        int action = event.getActionMasked();
-        int pointerCount = event.getPointerCount();
-
-        for (int i = 0; i < pointerCount; i++) {
-            float x, y;
-            switch (action) {
-                case MotionEvent.ACTION_SCROLL:
-                    x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, i);
-                    y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, i);
-                    SDLActivity.onNativeMouse(0, action, x, y, false);
-                    return true;
-
-                case MotionEvent.ACTION_HOVER_MOVE:
-                case MotionEvent.ACTION_MOVE:
-                    x = event.getX(i);
-                    y = event.getY(i);
-                    SDLActivity.onNativeMouse(0, action, x, y, true);
-                    return true;
-
-                case MotionEvent.ACTION_BUTTON_PRESS:
-                case MotionEvent.ACTION_BUTTON_RELEASE:
-
-                    // Change our action value to what SDL's code expects.
-                    if (action == MotionEvent.ACTION_BUTTON_PRESS) {
-                        action = MotionEvent.ACTION_DOWN;
-                    } else { /* MotionEvent.ACTION_BUTTON_RELEASE */
-                        action = MotionEvent.ACTION_UP;
-                    }
-
-                    x = event.getX(i);
-                    y = event.getY(i);
-                    int button = event.getButtonState();
-
-                    SDLActivity.onNativeMouse(button, action, x, y, true);
-                    return true;
-            }
-        }
-
-        return false;
-    }
-
-    @Override
-    public boolean onScale(ScaleGestureDetector detector) {
-        float scale = detector.getScaleFactor();
-        SDLActivity.onNativePinchUpdate(scale);
-        return true;
-    }
-
-    @Override
-    public boolean onScaleBegin(ScaleGestureDetector detector) {
-        SDLActivity.onNativePinchStart();
-        return true;
-    }
-
-    @Override
-    public void onScaleEnd(ScaleGestureDetector detector) {
-        SDLActivity.onNativePinchEnd();
-    }
-
-}
diff --git a/platforms/android/app/src/main/res/xml/network_security_config.xml b/platforms/android/app/src/main/res/xml/network_security_config.xml
new file mode 100644
index 0000000000..aa9543fd1f
--- /dev/null
+++ b/platforms/android/app/src/main/res/xml/network_security_config.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config>
+    <base-config cleartextTrafficPermitted="false" />
+    <domain-config cleartextTrafficPermitted="true">
+        <domain includeSubdomains="false">localhost</domain>
+        <domain includeSubdomains="false">127.0.0.1</domain>
+        <domain includeSubdomains="false">::1</domain>
+    </domain-config>
+</network-security-config>
diff --git a/platforms/android/build.gradle b/platforms/android/build.gradle
index eba031aa1b..4b1f3fb3f2 100644
--- a/platforms/android/build.gradle
+++ b/platforms/android/build.gradle
@@ -1,3 +1,3 @@
 plugins {
-    id 'com.android.application' version '8.13.2' apply false
+    id 'com.android.application' version '9.1.1' apply false
 }
diff --git a/platforms/android/gradle/wrapper/gradle-wrapper.jar b/platforms/android/gradle/wrapper/gradle-wrapper.jar
index 2b338a935b..61285a659d 100644
Binary files a/platforms/android/gradle/wrapper/gradle-wrapper.jar and b/platforms/android/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/platforms/android/gradle/wrapper/gradle-wrapper.properties b/platforms/android/gradle/wrapper/gradle-wrapper.properties
index ec50cfcb6e..37f78a6af8 100644
--- a/platforms/android/gradle/wrapper/gradle-wrapper.properties
+++ b/platforms/android/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,7 @@
-#Thu Nov 11 18:20:34 PST 2021
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 distributionPath=wrapper/dists
-zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/platforms/android/gradlew b/platforms/android/gradlew
index 3427607f42..adff685a03 100755
--- a/platforms/android/gradlew
+++ b/platforms/android/gradlew
@@ -1,74 +1,128 @@
-#!/usr/bin/env bash
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
-warn ( ) {
+warn () {
     echo "$*"
-}
+} >&2
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -77,84 +131,118 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|grep -E -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|grep -E -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/platforms/android/gradlew.bat b/platforms/android/gradlew.bat
index 8a0b282aa6..c4bdd3ab8e 100644
--- a/platforms/android/gradlew.bat
+++ b/platforms/android/gradlew.bat
@@ -1,4 +1,22 @@
-@if "%DEBUG%" == "" @echo off
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -8,26 +26,30 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -35,54 +57,35 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windowz variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
-
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
diff --git a/platforms/android/scripts/stage-jni-libs.sh b/platforms/android/scripts/stage-jni-libs.sh
deleted file mode 100755
index 42b08c13e6..0000000000
--- a/platforms/android/scripts/stage-jni-libs.sh
+++ /dev/null
@@ -1,72 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "$0")/../../.." && pwd)"
-APP_DIR="$ROOT_DIR/platforms/android/app/src/main/jniLibs"
-ANDROID_HOME_DIR="${ANDROID_HOME:-$HOME/Android/Sdk}"
-ANDROID_NDK_VER="${ANDROID_NDK_VERSION:-}"
-ANDROID_STAGE_ABIS="${ANDROID_STAGE_ABIS:-arm64-v8a x86_64}"
-ANDROID_STAGE_STRIP="${ANDROID_STAGE_STRIP:-1}"
-STRIP_TOOL=""
-
-if [[ -z "$ANDROID_NDK_VER" ]] && [[ -d "$ANDROID_HOME_DIR/ndk" ]]; then
-  ANDROID_NDK_VER="$(ls -1 "$ANDROID_HOME_DIR/ndk" | sort -V | tail -n 1)"
-fi
-
-if [[ -n "$ANDROID_NDK_VER" ]]; then
-  case "$(uname -s)" in
-    Darwin) HOST_TAG="darwin-x86_64" ;;
-    Linux) HOST_TAG="linux-x86_64" ;;
-    *) HOST_TAG="" ;;
-  esac
-
-  PREBUILT_DIR="$ANDROID_HOME_DIR/ndk/$ANDROID_NDK_VER/toolchains/llvm/prebuilt"
-  if [[ -n "$HOST_TAG" && -x "$PREBUILT_DIR/$HOST_TAG/bin/llvm-strip" ]]; then
-    STRIP_TOOL="$PREBUILT_DIR/$HOST_TAG/bin/llvm-strip"
-  else
-    for candidate in "$PREBUILT_DIR"/*/bin/llvm-strip; do
-      if [[ -x "$candidate" ]]; then
-        STRIP_TOOL="$candidate"
-        break
-      fi
-    done
-  fi
-fi
-
-copy_lib() {
-  local abi="$1"
-  local src="$2"
-  local dst_dir="$APP_DIR/$abi"
-  local dst="$dst_dir/libmain.so"
-  local tmp="$dst_dir/.libmain.so.$$"
-  if [[ ! -f "$src" ]]; then
-    echo "Missing native library for $abi: $src" >&2
-    exit 1
-  fi
-
-  mkdir -p "$dst_dir"
-  cp -f "$src" "$tmp"
-  if [[ "$ANDROID_STAGE_STRIP" != "0" ]] && [[ -n "$STRIP_TOOL" ]]; then
-    "$STRIP_TOOL" --strip-unneeded "$tmp"
-    mv -f "$tmp" "$dst"
-    echo "Stripped and staged $src -> $dst"
-  else
-    mv -f "$tmp" "$dst"
-    echo "Staged $src -> $dst (strip disabled or strip tool unavailable)"
-  fi
-}
-
-# Drop any previously staged ABI directories to avoid stale APK contents.
-rm -rf "$APP_DIR/x86" "$APP_DIR/arm64-v8a" "$APP_DIR/x86_64"
-
-for abi in $ANDROID_STAGE_ABIS; do
-  case "$abi" in
-    arm64-v8a) src="$ROOT_DIR/build/android-arm64/libmain.so" ;;
-    x86_64) src="$ROOT_DIR/build/android-x86_64/libmain.so" ;;
-    *)
-      echo "Unsupported ABI '$abi'. Supported ABIs: arm64-v8a x86_64" >&2
-      exit 1
-      ;;
-  esac
-  copy_lib "$abi" "$src"
-done
diff --git a/platforms/android/scripts/sync-sdl-java.sh b/platforms/android/scripts/sync-sdl-java.sh
deleted file mode 100644
index c157f63f46..0000000000
--- a/platforms/android/scripts/sync-sdl-java.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT_DIR="$(cd "$(dirname "$0")/../../.." && pwd)"
-SRC_DEFAULT="$ROOT_DIR/build/android-arm64/_deps/sdl-src/android-project/app/src/main/java/org/libsdl/app"
-SRC_DIR="${1:-$SRC_DEFAULT}"
-DST_DIR="$ROOT_DIR/platforms/android/app/src/main/java/org/libsdl/app"
-
-if [[ ! -d "$SRC_DIR" ]]; then
-  echo "SDL Java source directory not found: $SRC_DIR" >&2
-  exit 1
-fi
-
-mkdir -p "$DST_DIR"
-cp -f "$SRC_DIR"/*.java "$DST_DIR"/
-echo "Synced SDL Java sources from $SRC_DIR to $DST_DIR"
diff --git a/platforms/ios/Info.plist.in b/platforms/ios/Info.plist.in
index 395b29b7d7..9a9025b9f7 100644
--- a/platforms/ios/Info.plist.in
+++ b/platforms/ios/Info.plist.in
@@ -85,5 +85,12 @@
     <true/>
     <key>LSSupportsGameMode</key>
     <true/>
+    <key>NSAppTransportSecurity</key>
+    <dict>
+      <key>NSAllowsLocalNetworking</key>
+      <true/>
+    </dict>
+    <key>NSLocalNetworkUsageDescription</key>
+    <string>Dusklight allows network-enabled mods to connect to devices on your local network.</string>
 </dict>
 </plist>
diff --git a/platforms/macos/Info.plist.in b/platforms/macos/Info.plist.in
index 7f29358033..3f564d88f7 100644
--- a/platforms/macos/Info.plist.in
+++ b/platforms/macos/Info.plist.in
@@ -32,5 +32,12 @@
 	<string>public.app-category.adventure-games</string>
 	<key>LSSupportsGameMode</key>
 	<true/>
+	<key>NSAppTransportSecurity</key>
+	<dict>
+		<key>NSAllowsLocalNetworking</key>
+		<true/>
+	</dict>
+	<key>NSLocalNetworkUsageDescription</key>
+	<string>Dusklight allows network-enabled mods to connect to devices on your local network.</string>
 </dict>
 </plist>
diff --git a/platforms/tvos/Info.plist.in b/platforms/tvos/Info.plist.in
index 49ed85edd7..7f32e2d207 100644
--- a/platforms/tvos/Info.plist.in
+++ b/platforms/tvos/Info.plist.in
@@ -47,5 +47,12 @@
     <string>Automatic</string>
     <key>LSSupportsGameMode</key>
     <true />
+    <key>NSAppTransportSecurity</key>
+    <dict>
+      <key>NSAllowsLocalNetworking</key>
+      <true/>
+    </dict>
+    <key>NSLocalNetworkUsageDescription</key>
+    <string>Dusklight allows network-enabled mods to connect to devices on your local network.</string>
 </dict>
 </plist>
diff --git a/platforms/windows/dusklight.rc.in b/platforms/windows/dusklight.rc.in
index a1caac1c40..75493a0ba2 100644
--- a/platforms/windows/dusklight.rc.in
+++ b/platforms/windows/dusklight.rc.in
@@ -23,12 +23,12 @@ BEGIN
         BEGIN
             VALUE "CompanyName", "@DUSK_COMPANY_NAME@\0"
             VALUE "FileDescription", "@DUSK_FILE_DESCRIPTION@\0"
-            VALUE "FileVersion", "@DUSK_VERSION_STRING@\0"
+            VALUE "FileVersion", "@BOREALIS_APP_VERSION@\0"
             VALUE "InternalName", "dusklight\0"
             VALUE "LegalCopyright", "@DUSK_COPYRIGHT@\0"
             VALUE "OriginalFilename", "dusklight.exe\0"
             VALUE "ProductName", "@DUSK_PRODUCT_NAME@\0"
-            VALUE "ProductVersion", "@DUSK_VERSION_STRING@\0"
+            VALUE "ProductVersion", "@BOREALIS_APP_VERSION@\0"
         END
     END
     BLOCK "VarFileInfo"
diff --git a/res/rml/command_console.rcss b/res/rml/command_console.rcss
new file mode 100644
index 0000000000..d19246692a
--- /dev/null
+++ b/res/rml/command_console.rcss
@@ -0,0 +1,93 @@
+body {
+    --console-command-color: #FFD966;
+
+    display: block;
+    width: 100%;
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    overflow: visible;
+    pointer-events: none;
+}
+
+console {
+    position: absolute;
+    bottom: 10dp;
+    left: 10dp;
+    width: 50%;
+    display: flex;
+    flex-direction: column;
+    background-color: rgba(var(--color-black-rgb), 60%);
+    pointer-events: auto;
+    font-family: var(--font-family-monospace);
+    font-size: var(--font-size-sm);
+    color: var(--color-white);
+    transition: background-color 0.8s linear-in-out;
+}
+
+output {
+    display: block;
+    overflow: hidden;
+    max-height: 480dp;
+    padding: var(--space-xs) var(--space-sm);
+    line-height: 1.4em;
+}
+
+output[open] {
+    height: 480dp;
+    max-height: 480dp;
+    overflow-y: auto;
+}
+
+console:not([open]) {
+    pointer-events: none;
+}
+
+console:not([open])[fading] {
+    background-color: rgba(var(--color-black-rgb), 0%);
+}
+
+console[open] {
+    background-color: rgba(var(--color-black-rgb), 60%);
+    transition: none;
+}
+
+line {
+    display: block;
+    white-space: nowrap;
+    opacity: 1;
+    transition: opacity 0.8s linear-in-out;
+}
+
+output:not([open]) line[fading] {
+    opacity: 0;
+}
+
+output:not([open]) line[expired] {
+    display: none;
+}
+
+output[open] line {
+    opacity: 1;
+    transition: none;
+}
+
+line.cmd {
+    color: var(--console-command-color);
+}
+
+console input {
+    display: none;
+    width: 100%;
+    background-color: rgba(var(--color-black-rgb), 40%);
+    border: 0dp;
+    border-top: 1dp rgba(var(--color-white-rgb), 20%);
+    color: var(--color-white);
+    font-family: var(--font-family-monospace);
+    font-size: var(--font-size-sm);
+    padding: var(--space-xs) var(--space-sm);
+}
+
+console[open] input {
+    display: block;
+}
diff --git a/res/rml/logs.rcss b/res/rml/logs.rcss
index 126684f9d2..fd1933ed3a 100644
--- a/res/rml/logs.rcss
+++ b/res/rml/logs.rcss
@@ -2,19 +2,20 @@ window.logs content {
     flex-flow: column;
 }
 
-window.logs .log-toolbar {
+window.logs log-toolbar {
     display: flex;
     flex-flow: row;
-    flex: 0 0 64dp;
-    height: 64dp;
+    flex: 0 0 var(--toolbar-height);
+    height: var(--toolbar-height);
     align-items: center;
-    gap: 8dp;
+    gap: var(--space-sm);
     padding-right: 72dp;
-    background-color: rgba(217, 217, 217, 10%);
-    border-bottom: 2dp #92875B;
-    font-family: "Fira Sans Condensed";
+    background-color: rgba(var(--color-neutral-rgb), 10%);
+    border-bottom-width: 2dp;
+    border-bottom-color: var(--color-border);
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    font-size: 18dp;
+    font-size: var(--font-size-xl);
 }
 
 window.logs > close {
@@ -22,76 +23,77 @@ window.logs > close {
     right: 8dp;
 }
 
-window.logs .log-title {
+window.logs log-title {
     align-self: stretch;
     flex: 0 0 auto;
-    padding: 0 24dp;
-    line-height: 64dp;
+    padding: 0 var(--space-xl);
+    line-height: var(--toolbar-height);
     text-transform: uppercase;
-    border-bottom: 4dp #C2A42D;
+    border-bottom-width: 4dp;
+    border-bottom-color: var(--color-accent);
     font-effect: glow(0dp 4dp 0dp 4dp black);
 }
 
-window.logs .log-title-mod {
+window.logs log-title-mod {
     flex: 0 1 auto;
     min-width: 0;
     white-space: nowrap;
     overflow: hidden;
-    font-family: "Fira Sans";
+    font-family: var(--font-family-body);
     font-weight: normal;
-    font-size: 15dp;
-    color: rgba(224, 219, 200, 55%);
+    font-size: var(--font-size-base);
+    color: rgba(var(--color-text-rgb), 55%);
 }
 
-.log-toolbar-spacer {
+log-toolbar-spacer {
     flex: 1 1 0;
 }
 
-.log-toolbar button {
+log-toolbar button {
     flex: 0 0 auto;
-    font-family: "Fira Sans";
+    font-family: var(--font-family-body);
     font-weight: normal;
-    font-size: 15dp;
-    padding: 5dp 12dp;
+    font-size: var(--font-size-base);
+    padding: 5dp var(--space-md);
 }
 
 window.logs content pane.log-view {
     flex: 1 1 0;
-    padding: 12dp 16dp;
+    padding: var(--space-md) var(--space-lg);
     padding-bottom: 0dp;
     gap: 0dp;
 }
 
-.log-lines {
+log-lines {
     display: block;
 }
 
-.log-line {
+log-line {
     display: block;
-    font-family: "Noto Mono";
-    font-size: 13dp;
+    font-family: var(--font-family-monospace);
+    font-size: var(--font-size-xs);
     line-height: 1.5;
     word-break: break-word;
     white-space: pre-wrap;
 }
 
-.log-line .log-time {
-    color: rgba(224, 219, 200, 45%);
+log-line log-time {
+    color: rgba(var(--color-text-rgb), 45%);
 }
 
-.log-line .log-mod {
-    color: rgba(194, 164, 45, 80%);
+log-line log-mod {
+    color: rgba(var(--color-accent-rgb), 80%);
 }
 
-.log-line.lvl-trace,
-.log-line.lvl-debug {
+log-line.lvl-trace,
+log-line.lvl-debug {
     opacity: 0.55;
 }
 
-.log-line.lvl-warn .log-msg {
-    color: #ffa826;
+log-line.lvl-warn log-msg {
+    color: var(--color-warning);
 }
 
-.log-line.lvl-error .log-msg {
-    color: #cc4444;
+log-line.lvl-error log-msg {
+    color: var(--color-error);
 }
diff --git a/res/rml/mod_browser.rcss b/res/rml/mod_browser.rcss
new file mode 100644
index 0000000000..e88285b019
--- /dev/null
+++ b/res/rml/mod_browser.rcss
@@ -0,0 +1,922 @@
+window.mod-browser,
+window.mod-browser-detail,
+window.screenshot-viewer {
+    background-color: rgba(var(--color-surface-rgb), 96%);
+}
+
+window.mod-browser > content {
+    flex-flow: row;
+}
+
+catalog-filters {
+    display: flex;
+    flex-flow: column;
+    flex: 0 0 264dp;
+    min-width: 0;
+    padding: var(--space-xl) 18dp;
+    gap: var(--space-sm);
+    border-right-width: 1dp;
+    border-right-color: var(--color-border);
+    background-color: rgba(var(--color-control-rgb), 45%);
+}
+
+catalog-filters h1,
+catalog-results header h1 {
+    margin: 0;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-5xl);
+    font-weight: bold;
+}
+
+catalog-filters h1 {
+    padding: 0 var(--space-sm) var(--space-sm) var(--space-sm);
+}
+
+catalog-filters h2 {
+    margin: var(--space-md) var(--space-sm) 0 var(--space-sm);
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-xs);
+    font-weight: bold;
+    text-transform: uppercase;
+    opacity: 0.42;
+}
+
+catalog-filters select-button {
+    padding: var(--space-sm) 10dp;
+    border-radius: var(--radius-panel);
+}
+
+catalog-filters select-button key {
+    font-size: var(--font-size-xs);
+}
+
+catalog-filters select-button value,
+catalog-filters select-button input {
+    font-size: var(--font-size-sm);
+}
+
+.catalog-library-link {
+    padding: var(--space-sm) 10dp;
+    border-radius: var(--radius-panel);
+    text-align: left;
+    font-size: var(--font-size-sm);
+}
+
+catalog-results {
+    display: flex;
+    flex-flow: column;
+    flex: 1 1 auto;
+    min-width: 0;
+    min-height: 0;
+    padding: var(--space-xl);
+    gap: var(--space-lg);
+}
+
+catalog-results header {
+    display: block;
+    flex: 0 0 auto;
+    padding-right: var(--space-2xl);
+}
+
+catalog-results > header small {
+    display: block;
+    margin-top: var(--space-2xs);
+    font-size: var(--font-size-xs);
+    opacity: 0.5;
+}
+
+catalog-viewport {
+    display: block;
+    flex: 1 1 auto;
+    min-width: 0;
+    min-height: 0;
+    overflow: hidden auto;
+}
+
+catalog-grid {
+    display: flex;
+    flex-flow: row wrap;
+    min-width: 0;
+    gap: 14dp;
+    padding: var(--space-2xs);
+}
+
+.catalog-card {
+    display: flex;
+    flex-flow: column;
+    flex: 0 0 48%;
+    min-width: 260dp;
+    height: 310dp;
+    padding: 0;
+    overflow: hidden;
+    text-align: left;
+    border-radius: 12dp;
+}
+
+catalog-card-art {
+    display: block;
+    position: relative;
+    flex: 0 0 118dp;
+    min-height: 118dp;
+}
+
+catalog-card-art-image {
+    display: block;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    pointer-events: none;
+    mask-image: linear-gradient(180deg, #fff 45%, transparent);
+}
+
+catalog-card-body {
+    display: flex;
+    position: relative;
+    flex-flow: column;
+    flex: 1 1 auto;
+    min-height: 0;
+    padding: var(--space-xl) var(--space-lg) var(--space-lg);
+    gap: 7dp;
+}
+
+catalog-official-badge {
+    padding: var(--space-2xs) 5dp;
+    border-radius: var(--radius-small);
+    background-color: rgba(var(--color-accent-rgb), 28%);
+    color: var(--color-info);
+    font-style: normal;
+    font-size: var(--font-size-3xs);
+}
+
+catalog-card-body > section > b {
+    display: block;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-sm);
+    font-weight: bold;
+    text-transform: uppercase;
+    color: var(--color-accent);
+}
+
+catalog-card-body > small {
+    position: absolute;
+    top: var(--space-md);
+    right: var(--space-lg);
+    margin: 0;
+    padding: 0;
+    font-size: var(--font-size-sm);
+    font-weight: normal;
+    text-transform: none;
+    opacity: 0.45;
+}
+
+.catalog-card mod-icon {
+    display: block;
+    position: absolute;
+    left: 14dp;
+    bottom: -18dp;
+    z-index: 1;
+    width: 56dp;
+    height: 56dp;
+    border-radius: var(--radius-panel);
+    overflow: hidden;
+    box-shadow: rgba(var(--color-black-rgb), 60%) 0 6dp 16dp;
+}
+
+mod-icon-image {
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: var(--radius-panel);
+}
+
+catalog-card-body > section {
+    display: block;
+    margin: 0;
+    padding: 0;
+}
+
+catalog-card-body > section h2 {
+    display: block;
+    margin: 0;
+    font-family: var(--font-family-body);
+    font-size: var(--font-size-3xl);
+    font-weight: bold;
+    color: var(--color-neutral);
+    line-height: 1.5;
+}
+
+catalog-card-body > section small {
+    display: block;
+    font-size: var(--font-size-3xs);
+    opacity: 0.55;
+}
+
+catalog-card-body > p {
+    flex: 1 1 auto;
+    min-height: 0;
+    margin: 0;
+    overflow: hidden;
+    font-size: var(--font-size-base);
+    line-height: 1.35;
+    color: rgba(var(--color-text-rgb), 68%);
+}
+
+catalog-card-body > footer {
+    display: flex;
+    align-items: center;
+    gap: 10dp;
+    font-size: var(--font-size-3xs);
+    opacity: 0.52;
+}
+
+catalog-card-body > footer stat {
+    display: flex;
+    flex: 0 0 auto;
+    align-items: center;
+    gap: 3dp;
+    white-space: nowrap;
+}
+
+catalog-card-body > footer icon {
+    flex: 0 0 13dp;
+    font-size: var(--font-size-sm);
+    line-height: 1;
+}
+
+catalog-card-body > footer .size {
+    margin-left: auto;
+    font-size: var(--font-size-sm);
+}
+
+catalog-card-body > footer .size.installed {
+    color: var(--color-success);
+}
+
+catalog-pagination {
+    display: flex;
+    flex-flow: row;
+    align-items: center;
+    flex: 0 0 auto;
+    gap: var(--space-sm);
+}
+
+catalog-pagination-label {
+    flex: 1 1 auto;
+    text-align: center;
+    font-size: var(--font-size-xs);
+    opacity: 0.5;
+}
+
+catalog-pagination button {
+    font-size: var(--font-size-sm);
+    padding: 6dp var(--space-md);
+}
+
+catalog-results-status,
+catalog-detail-status {
+    display: flex;
+    flex-flow: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    gap: var(--space-sm);
+    text-align: center;
+}
+
+catalog-results-status h2,
+catalog-detail-status h2 {
+    display: block;
+    margin: 0;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-4xl);
+    font-weight: bold;
+}
+
+catalog-results-status p,
+catalog-detail-status p {
+    display: block;
+    margin: 0;
+    opacity: 0.58;
+}
+
+catalog-results-status button,
+catalog-detail-status button {
+    margin-top: var(--space-sm);
+    font-size: var(--font-size-base);
+}
+
+window.mod-browser-detail > content {
+    display: block;
+}
+
+detail-scroll {
+    display: flex;
+    flex-flow: column;
+    width: 100%;
+    height: 100%;
+    min-width: 0;
+    overflow: hidden auto;
+    padding-bottom: var(--space-2xl);
+}
+
+catalog-detail-hero {
+    display: flex;
+    position: relative;
+    flex-flow: column;
+    justify-content: space-between;
+    flex: 0 0 220dp;
+    min-height: 220dp;
+    padding: 18dp var(--space-xl) 20dp var(--space-xl);
+}
+
+catalog-detail-hero-image {
+    display: block;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    pointer-events: none;
+    mask-image: linear-gradient(180deg, #fff 40%, transparent);
+}
+
+catalog-detail-actions {
+    display: flex;
+    position: relative;
+    z-index: 1;
+    flex-flow: row;
+    gap: var(--space-sm);
+}
+
+catalog-detail-actions button,
+catalog-source-actions button {
+    font-size: var(--font-size-sm);
+    padding: 7dp var(--space-md);
+    --button-background: rgba(var(--color-control-rgb), 75%);
+    --button-background-hover: rgba(var(--color-control-rgb), 90%);
+    --button-background-selected: rgba(var(--color-control-rgb), 90%);
+    --button-background-active: rgba(var(--color-surface-rgb), 90%);
+}
+
+.catalog-icon-action {
+    display: flex;
+    align-items: center;
+    gap: var(--space-sm);
+}
+
+.catalog-icon-action icon {
+    flex: 0 0 18dp;
+    font-size: var(--font-size-xl);
+    line-height: 1;
+}
+
+.catalog-install-action {
+    display: flex;
+    position: relative;
+    align-items: center;
+    justify-content: center;
+    gap: 10dp;
+    min-width: 132dp;
+    padding: 8dp 22dp;
+    border-radius: var(--radius-window);
+    overflow: hidden;
+    font-size: var(--font-size-2xl);
+    opacity: 1;
+    --button-background: rgba(var(--color-control-rgb), 20%);
+    --button-background-hover: rgba(var(--color-interactive-rgb), 20%);
+    --button-background-selected: rgba(var(--color-interactive-rgb), 20%);
+    --button-background-active: rgba(var(--color-interactive-rgb), 20%);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
+}
+
+.catalog-install-action icon {
+    flex: 0 0 22dp;
+    font-size: var(--font-size-3xl);
+    line-height: 1;
+}
+
+.catalog-install-action > span {
+    white-space: nowrap;
+}
+
+.catalog-install-action.idle {
+    --button-background: rgba(var(--color-interactive-rgb), 18%);
+    --button-background-hover: rgba(var(--color-interactive-rgb), 42%);
+    --button-background-selected: rgba(var(--color-interactive-rgb), 42%);
+    --button-background-active: rgba(var(--color-interactive-rgb), 65%);
+    box-shadow: rgba(var(--color-accent-rgb), 65%) 0 0 0 1dp;
+}
+
+.catalog-install-action.paused {
+    box-shadow: rgba(var(--color-border-rgb), 25%) 0 0 0 1dp;
+}
+
+.catalog-install-action.paused:not(:disabled):hover,
+.catalog-install-action.paused:not(:disabled):focus-visible {
+    box-shadow: var(--color-accent) 0 0 0 2dp;
+}
+
+.catalog-install-action progress {
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    width: 100%;
+    height: 4dp;
+    margin: 0;
+    border-radius: 0;
+    overflow: hidden;
+    background-color: rgba(var(--color-white-rgb), 10%);
+}
+
+.catalog-install-action progress fill {
+    border-radius: 0;
+    background-color: rgba(var(--color-accent-rgb), 80%);
+}
+
+.catalog-install-action.paused progress fill {
+    background-color: rgba(var(--color-text-rgb), 35%);
+}
+
+.catalog-install-action.retrying {
+    color: var(--color-warning);
+    box-shadow: rgba(var(--color-warning-rgb), 60%) 0 0 0 2dp;
+}
+
+.catalog-install-action.retrying progress fill {
+    background-color: rgba(var(--color-warning-rgb), 60%);
+}
+
+.catalog-install-action.failed {
+    color: var(--color-white);
+    --button-background: rgba(var(--color-error-rgb), 20%);
+    --button-background-hover: rgba(var(--color-error-rgb), 35%);
+    --button-background-selected: rgba(var(--color-error-rgb), 35%);
+    --button-background-active: rgba(var(--color-error-rgb), 35%);
+    box-shadow: var(--color-error) 0 0 0 2dp;
+}
+
+.catalog-install-action.failed progress fill {
+    background-color: rgba(var(--color-error-rgb), 70%);
+}
+
+.catalog-install-action.installed {
+    color: var(--color-success);
+    box-shadow: rgba(var(--color-success-rgb), 50%) 0 0 0 2dp;
+}
+
+.catalog-install-action.installing progress fill {
+    background-color: rgba(var(--color-info-rgb), 80%);
+}
+
+catalog-install-control {
+    display: flex;
+    flex-flow: column;
+    align-items: flex-end;
+    flex: 0 0 auto;
+    gap: var(--space-xs);
+}
+
+catalog-install-caption {
+    display: block;
+    max-width: 240dp;
+    overflow: hidden;
+    font-size: var(--font-size-xs);
+    color: rgba(var(--color-text-rgb), 50%);
+    text-align: right;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+catalog-install-caption.failed {
+    color: var(--color-error);
+}
+
+catalog-detail-identity {
+    display: flex;
+    position: relative;
+    z-index: 1;
+    align-items: flex-end;
+    gap: var(--space-lg);
+}
+
+catalog-detail-identity mod-icon {
+    display: block;
+    flex: 0 0 70dp;
+    width: 70dp;
+    height: 70dp;
+    border-radius: var(--radius-panel);
+    overflow: hidden;
+    box-shadow: rgba(var(--color-black-rgb), 65%) 0 8dp 20dp;
+}
+
+catalog-detail-identity > header {
+    display: block;
+    flex: 1 1 auto;
+    min-width: 0;
+}
+
+catalog-detail-identity > header > b {
+    display: block;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-sm);
+    font-weight: bold;
+    text-transform: uppercase;
+    color: var(--color-accent);
+}
+
+catalog-detail-identity h1 {
+    display: block;
+    margin: 1dp 0;
+    font-family: var(--font-family-body);
+    font-size: var(--font-size-5xl);
+    font-weight: bold;
+    color: var(--color-neutral);
+}
+
+catalog-detail-identity h1 small {
+    margin-left: 9dp;
+    font-family: var(--font-family-body);
+    font-size: var(--font-size-xs);
+    font-weight: normal;
+    opacity: 0.55;
+}
+
+catalog-detail-identity p {
+    display: block;
+    margin: 0;
+    font-size: var(--font-size-xs);
+    opacity: 0.72;
+}
+
+catalog-detail-stats {
+    display: flex;
+    flex-flow: row;
+    align-items: center;
+    gap: 28dp;
+    margin: 0 var(--space-xl);
+    font-size: var(--font-size-2xs);
+    color: rgba(var(--color-text-rgb), 58%);
+}
+
+catalog-detail-stats > stat {
+    display: flex;
+    align-items: center;
+    gap: 5dp;
+}
+
+catalog-detail-stats icon {
+    flex: 0 0 17dp;
+    font-size: var(--font-size-lg);
+    line-height: 1;
+}
+
+catalog-detail-body {
+    display: flex;
+    flex-flow: row;
+    align-items: flex-start;
+    gap: 28dp;
+    padding: var(--space-xl);
+}
+
+catalog-detail-body main {
+    display: flex;
+    flex-flow: column;
+    flex: 1 1 auto;
+    min-width: 0;
+    gap: 28dp;
+}
+
+catalog-detail-body section {
+    display: block;
+}
+
+catalog-detail-body section.catalog-scroll-anchor {
+    focus: auto;
+}
+
+catalog-detail-body section.catalog-scroll-anchor:focus-visible {
+    border-radius: var(--radius-control);
+    box-shadow: rgba(var(--color-accent-rgb), 45%) 0 0 0 1dp;
+}
+
+catalog-detail-body h2,
+catalog-detail-body h3 {
+    display: block;
+    margin: 0 0 10dp 0;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-2xl);
+    font-weight: bold;
+}
+
+catalog-detail-body h2 small {
+    margin-left: 7dp;
+    font-family: var(--font-family-body);
+    font-size: var(--font-size-3xs);
+    font-weight: normal;
+    opacity: 0.5;
+}
+
+catalog-fragment {
+    display: block;
+    font-size: var(--font-size-md);
+    line-height: 1.55;
+    color: var(--color-neutral);
+}
+
+catalog-fragment p,
+catalog-fragment ul,
+catalog-fragment ol {
+    display: block;
+    margin: 0 0 10dp 0;
+}
+
+catalog-fragment ul,
+catalog-fragment ol {
+    padding-left: var(--space-xl);
+}
+
+catalog-fragment li {
+    display: block;
+    position: relative;
+    margin: 3dp 0;
+}
+
+catalog-list-marker {
+    display: block;
+    position: absolute;
+    right: 100%;
+    width: var(--space-xl);
+    padding-right: var(--space-sm);
+    text-align: right;
+}
+
+catalog-fragment h1,
+catalog-fragment h2,
+catalog-fragment h3,
+catalog-fragment h4,
+catalog-fragment h5,
+catalog-fragment h6 {
+    display: block;
+    margin: 15dp 0 5dp 0;
+    font-family: var(--font-family-heading);
+    font-weight: bold;
+    font-size: var(--font-size-xl);
+    color: var(--color-neutral);
+}
+
+catalog-fragment h1 {
+    font-size: var(--font-size-5xl);
+}
+
+catalog-fragment h2 {
+    font-size: var(--font-size-4xl);
+}
+
+catalog-fragment h3 {
+    font-size: var(--font-size-2xl);
+}
+
+window.screenshot-viewer > close {
+    display: none;
+}
+
+catalog-gallery {
+    display: flex;
+    flex-flow: row;
+    height: 210dp;
+    gap: var(--space-sm);
+}
+
+.catalog-screenshot {
+    position: relative;
+    overflow: hidden;
+    flex: 1 1 0;
+    height: 100%;
+    min-width: 0;
+    padding: 0;
+    border-radius: var(--radius-panel);
+    --button-background: rgba(var(--color-border-rgb), 14%);
+    font-size: var(--font-size-5xl);
+}
+
+.catalog-screenshot.primary {
+    flex: 2 1 0;
+}
+
+catalog-screenshot-image,
+catalog-screenshot-more {
+    display: block;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    pointer-events: none;
+}
+
+catalog-screenshot-more {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: rgba(var(--color-black-rgb), 60%);
+    color: var(--color-white);
+}
+
+catalog-dependencies {
+    display: flex;
+    flex-flow: column;
+    gap: 7dp;
+    font-size: var(--font-size-xs);
+}
+
+catalog-dependency {
+    display: flex;
+    flex-flow: column;
+    padding: 9dp 11dp;
+    border-radius: var(--radius-control);
+    background-color: rgba(var(--color-border-rgb), 9%);
+}
+
+catalog-dependency-status {
+    display: block;
+    font-size: var(--font-size-3xs);
+    opacity: 0.56;
+}
+
+catalog-dependency.missing {
+    color: var(--color-warning);
+}
+
+catalog-detail-body aside {
+    display: flex;
+    flex-flow: column;
+    flex: 0 0 264dp;
+    min-width: 0;
+    padding: var(--space-lg);
+    gap: var(--space-md);
+    border-radius: 9dp;
+    background-color: rgba(var(--color-control-rgb), 42%);
+    box-shadow: rgba(var(--color-border-rgb), 24%) 0 0 0 1dp;
+}
+
+catalog-detail-body dl {
+    display: flex;
+    flex-flow: row wrap;
+    margin: 0;
+    font-size: var(--font-size-sm);
+}
+
+catalog-detail-body dt {
+    flex: 0 0 42%;
+    padding: 5dp 0;
+    font-weight: bold;
+    opacity: 0.8;
+}
+
+catalog-detail-body dd {
+    flex: 1 1 52%;
+    margin: 0;
+    padding: 5dp 0;
+    text-align: right;
+}
+
+window.screenshot-viewer > content {
+    flex-flow: column;
+    padding: 18dp;
+    gap: var(--space-md);
+}
+
+catalog-screenshot-full {
+    display: block;
+    flex: 1 1 auto;
+    min-width: 0;
+    min-height: 0;
+    background-color: rgba(var(--color-black-rgb), 45%);
+}
+
+catalog-screenshot-actions {
+    display: flex;
+    flex-flow: row;
+    justify-content: center;
+    flex: 0 0 auto;
+    gap: var(--space-sm);
+}
+
+catalog-screenshot-actions button {
+    font-size: var(--font-size-sm);
+    padding: 7dp 13dp;
+}
+
+@media (max-height: 640dp) {
+    catalog-filters {
+        flex-basis: 232dp;
+        padding: 15dp var(--space-md);
+        gap: 5dp;
+    }
+
+    catalog-filters h1,
+    catalog-results header h1 {
+        font-size: var(--font-size-4xl);
+    }
+
+    catalog-filters h2 {
+        margin-top: 6dp;
+    }
+
+    catalog-results {
+        padding: 15dp;
+        gap: 10dp;
+    }
+
+    .catalog-card {
+        min-width: 220dp;
+        height: 254dp;
+    }
+
+    catalog-card-art {
+        flex-basis: 78dp;
+        min-height: 78dp;
+    }
+
+    catalog-card-body {
+        padding: 18dp 10dp var(--space-sm) 10dp;
+    }
+
+    .catalog-card mod-icon {
+        left: 10dp;
+        bottom: -14dp;
+        width: 40dp;
+        height: 40dp;
+    }
+
+    catalog-card-body > section > b,
+    catalog-card-body > small {
+        font-size: var(--font-size-3xs);
+    }
+
+    catalog-card-body > section h2 {
+        font-size: var(--font-size-md);
+    }
+
+    catalog-card-body > p {
+        font-size: var(--font-size-3xs);
+    }
+
+    catalog-detail-hero {
+        flex-basis: 160dp;
+        min-height: 160dp;
+        padding: var(--space-md) 18dp;
+    }
+
+    catalog-detail-identity mod-icon {
+        flex-basis: 56dp;
+        width: 56dp;
+        height: 56dp;
+    }
+
+    catalog-detail-identity {
+        gap: var(--space-md);
+    }
+
+    catalog-detail-identity > header > b {
+        font-size: var(--font-size-2xs);
+    }
+
+    .catalog-install-action {
+        gap: var(--space-sm);
+        min-width: 112dp;
+        padding: 7dp 18dp;
+        border-radius: 12dp;
+        font-size: var(--font-size-md);
+    }
+
+    .catalog-install-action icon {
+        flex-basis: 18dp;
+        font-size: var(--font-size-xl);
+    }
+
+    catalog-install-control {
+        gap: 3dp;
+    }
+
+    catalog-install-caption {
+        max-width: 190dp;
+        font-size: var(--font-size-3xs);
+    }
+
+    catalog-detail-identity h1 {
+        font-size: var(--font-size-3xl);
+    }
+
+    catalog-detail-body {
+        padding: 18dp;
+        gap: 18dp;
+    }
+
+    catalog-gallery {
+        height: 160dp;
+    }
+}
diff --git a/res/rml/mods.rcss b/res/rml/mods.rcss
index 99aa33d236..acd6d923a3 100644
--- a/res/rml/mods.rcss
+++ b/res/rml/mods.rcss
@@ -1,8 +1,8 @@
 window.mods content pane.mod-list {
     flex: 0 0 360dp;
-    padding: 16dp;
+    padding: var(--space-lg);
     padding-bottom: 0dp;
-    gap: 4dp;
+    gap: var(--space-xs);
 }
 
 @media (max-height: 640dp) {
@@ -12,29 +12,66 @@ window.mods content pane.mod-list {
 }
 
 window.mods content pane.mod-detail {
-    gap: 12dp;
+    gap: var(--space-md);
 }
 
-.mod-info-row {
+mod-entry.browser,
+mod-entry.installs {
+    min-height: 76dp;
+}
+
+mod-entry.browser mod-icon {
+    color: var(--color-accent);
+    decorator: text("&#xe2c0;" center center);
+}
+
+mod-entry.installs mod-icon {
+    color: var(--color-accent);
+    decorator: text("&#xe2c4;" center center);
+}
+
+mod-entry.installs {
+    background-color: rgba(var(--color-control-rgb), 20%);
+    box-shadow: rgba(var(--color-border-rgb), 25%) 0 0 0 1dp;
+}
+
+mod-entry.installs:hover,
+mod-entry.installs:focus-visible {
+    background-color: rgba(var(--color-interactive-rgb), 12%);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
+}
+
+mod-entry.installs progress {
+    height: 6dp;
+    margin: var(--space-xs) 0 0 0;
+}
+
+mod-list-separator {
+    display: block;
+    height: 1dp;
+    margin: var(--space-sm) 10dp;
+    background-color: rgba(var(--color-border-rgb), 30%);
+}
+
+mod-info-row {
     display: flex;
     align-items: center;
-    gap: 12dp;
-    padding: 4dp 0;
+    gap: var(--space-md);
+    padding: var(--space-xs) 0;
 }
 
-.mod-info-label {
-    font-family: "Fira Sans Condensed";
-    font-weight: bold;
+mod-info-row > b {
+    font-family: var(--font-family-heading);
     opacity: 0.55;
     flex: 0 0 auto;
 }
 
-.mod-info-value {
+mod-info-row > span {
     flex: 1 1 0;
 }
 
 .mod-path {
-    font-size: 14dp;
+    font-size: var(--font-size-sm);
     word-break: break-all;
     opacity: 0.7;
 }
@@ -42,97 +79,113 @@ window.mods content pane.mod-detail {
 mod-entry {
     display: flex;
     flex-flow: row;
-    gap: 12dp;
+    gap: var(--space-md);
     padding: 10dp;
     border-radius: 10dp;
-    decorator: vertical-gradient(#c2a42d00 #c2a42d00);
+    decorator: vertical-gradient(rgba(var(--color-accent-rgb), 0%) rgba(var(--color-accent-rgb), 0%));
     transition: decorator 0.1s linear-in-out;
     cursor: pointer;
     focus: auto;
 }
 
 mod-entry.current {
-    box-shadow: rgba(146, 135, 91, 40%) 0 0 0 1dp;
+    box-shadow: rgba(var(--color-border-rgb), 40%) 0 0 0 1dp;
 }
 
 mod-entry:hover,
 mod-entry:focus-visible {
-    decorator: vertical-gradient(#c2a42d00 #c2a42d26);
+    decorator: vertical-gradient(rgba(var(--color-accent-rgb), 0) rgba(var(--color-accent-rgb), 38));
 }
 
 mod-entry:selected {
-    decorator: vertical-gradient(#c2a42d10 #c2a42d40);
+    decorator: vertical-gradient(rgba(var(--color-accent-rgb), 16) rgba(var(--color-accent-rgb), 64));
 }
 
-mod-entry .mod-icon {
+mod-icon {
+    display: block;
     flex: 0 0 auto;
     width: 56dp;
     height: 56dp;
-    border-radius: 8dp;
-}
-
-mod-entry icon.mod-icon {
+    border-radius: var(--radius-panel);
+    font-family: var(--font-family-icons);
     font-size: 36dp;
-    background-color: rgba(17, 16, 10, 20%);
-    color: rgba(224, 219, 200, 45%);
+    background-color: rgba(var(--color-control-rgb), 20%);
+    color: rgba(var(--color-text-rgb), 45%);
     decorator: text("&#xe87b;" center center);
+    overflow: hidden;
 }
 
-mod-entry .mod-entry-info {
+mod-icon img {
+    display: block;
+    width: 100%;
+    height: 100%;
+    border-radius: var(--radius-panel);
+}
+
+mod-info {
     display: flex;
     flex-flow: column;
     flex: 1 1 0;
     min-width: 0;
-    gap: 2dp;
+    gap: var(--space-2xs);
 }
 
-mod-entry .mod-entry-name {
+mod-info header {
     display: flex;
     flex-flow: row;
     align-items: baseline;
     gap: 6dp;
 }
 
-mod-entry .mod-entry-name-text {
+mod-info header b {
     flex: 0 1 auto;
     min-width: 0;
-    font-weight: bold;
     white-space: nowrap;
     overflow: hidden;
 }
 
-mod-entry .mod-entry-version {
+mod-info header small {
     flex: 0 0 auto;
-    font-size: 13dp;
-    color: rgba(224, 219, 200, 50%);
+    font-size: var(--font-size-xs);
+    color: rgba(var(--color-text-rgb), 50%);
 }
 
-mod-entry .mod-entry-status.active {
-    color: #44cc55;
+mod-status.active {
+    color: var(--color-success);
 }
 
-mod-entry .mod-entry-status.failed {
-    color: #cc4444;
+mod-status.failed {
+    color: var(--color-error);
 }
 
-mod-entry .mod-entry-desc {
-    font-size: 14dp;
+mod-network {
+    margin-left: 6dp;
+    padding: 1dp 5dp;
+    border-radius: 5dp;
+    background-color: rgba(var(--color-info-rgb), 20%);
+    color: var(--color-info);
+}
+
+mod-info > p {
+    margin: 0;
+    font-size: var(--font-size-sm);
     line-height: 1.3;
-    color: rgba(224, 219, 200, 65%);
+    color: rgba(var(--color-text-rgb), 65%);
     max-height: 2.6em;
     overflow: hidden;
+    white-space: pre-wrap;
 }
 
-mod-entry .mod-entry-sub {
-    font-size: 13dp;
-    color: rgba(224, 219, 200, 50%);
+mod-info > small {
+    font-size: var(--font-size-xs);
+    color: rgba(var(--color-text-rgb), 50%);
 }
 
-mod-entry.inactive .mod-icon {
+mod-entry.inactive mod-icon {
     filter: grayscale(1);
 }
 
-mod-entry.inactive .mod-entry-info {
+mod-entry.inactive mod-info {
     opacity: 0.5;
 }
 
@@ -146,20 +199,37 @@ mod-header.has-banner {
     margin: -24dp -24dp 0dp -24dp;
 }
 
-mod-header .mod-actions {
+mod-header-image {
+    display: block;
+    position: absolute;
+    top: 0;
+    right: 0;
+    bottom: 0;
+    left: 0;
+    pointer-events: none;
+    mask-image: linear-gradient(180deg, #fff 40%, transparent);
+    filter: grayscale(0);
+}
+
+mod-header.inactive mod-header-image {
+    filter: grayscale(1);
+}
+
+mod-actions {
     position: absolute;
     top: 24dp;
     left: 24dp;
     display: flex;
     flex-flow: row;
-    gap: 8dp;
+    gap: var(--space-sm);
 }
 
-mod-header .mod-actions button {
-    font-size: 16dp;
-    padding: 6dp 14dp;
-    background-color: rgba(21, 22, 16, 80%);
-    box-shadow: rgba(146, 135, 91, 60%) 0 0 0 1dp;
+mod-actions button {
+    --button-background: rgba(var(--color-surface-rgb), 80%);
+    --button-background-hover: rgba(var(--color-control-rgb), 90%);
+    --button-background-selected: rgba(var(--color-control-rgb), 90%);
+    --button-background-active: rgba(var(--color-surface-rgb), 90%);
+    box-shadow: rgba(var(--color-border-rgb), 60%) 0 0 0 1dp;
 }
 
 mod-header.no-banner {
@@ -168,51 +238,55 @@ mod-header.no-banner {
     align-items: center;
 }
 
-mod-header.no-banner .mod-actions {
+mod-header.no-banner mod-actions {
     position: static;
 }
 
-window.mods .mod-title {
+mod-title {
     display: block;
-    font-size: 28dp;
+    font-size: var(--font-size-5xl);
     font-weight: bold;
 }
 
-window.mods .mod-title .mod-title-version {
+mod-title small {
     font-weight: normal;
-    font-size: 16dp;
-    color: rgba(224, 219, 200, 55%);
+    font-size: var(--font-size-md);
+    color: rgba(var(--color-text-rgb), 55%);
 }
 
-window.mods .mod-author {
+mod-author {
     display: block;
-    font-size: 15dp;
-    color: rgba(224, 219, 200, 55%);
+    font-size: var(--font-size-base);
+    color: rgba(var(--color-text-rgb), 55%);
 }
 
-window.mods .mod-restart-note {
-    font-size: 15dp;
-    color: #ffa826;
+mod-restart-note {
+    font-size: var(--font-size-base);
+    color: var(--color-warning);
     opacity: 0.85;
 }
 
-window.mods .mod-description {
+mod-description {
     line-height: 1.5;
 }
 
-.status-badge {
-    font-size: 14dp;
+status-badge {
+    font-size: var(--font-size-sm);
     opacity: 0.7;
 }
 
-.status-badge.active,
-.mod-info-label.active {
-    color: #44cc55;
+status-badge.active,
+mod-info-row > b.active {
+    color: var(--color-success);
     opacity: 1;
 }
 
-.status-badge.failed,
-.mod-info-label.failed {
-    color: #cc4444;
+status-badge.failed,
+mod-info-row > b.failed {
+    color: var(--color-error);
     opacity: 1;
-}
\ No newline at end of file
+}
+status-badge.network {
+    color: var(--color-info);
+    opacity: 1;
+}
diff --git a/res/rml/overlay.rcss b/res/rml/overlay.rcss
index 98f8bfa27a..a200005ca1 100644
--- a/res/rml/overlay.rcss
+++ b/res/rml/overlay.rcss
@@ -8,10 +8,10 @@ body {
     height: 100%;
     margin: 0;
     padding: 0;
-    font-family: "Fira Sans";
+    font-family: var(--font-family-body);
     font-weight: normal;
-    font-size: 20dp;
-    color: #E0DBC8;
+    font-size: var(--font-size-2xl);
+    color: var(--color-text);
     display: flex;
     flex-direction: column;
     justify-content: flex-end;
@@ -24,16 +24,22 @@ fps,
 pipeline-progress,
 toast {
     position: absolute;
-    border: 1dp #92875B;
-    background-color: rgba(21, 22, 16, 80%);
+    border-width: 1dp;
+    background-color: rgba(var(--color-surface-rgb), 80%);
+}
+
+fps,
+pipeline-progress {
+    border-color: var(--color-border);
 }
 
 toast {
+    border-color: var(--toast-border-color);
     top: 40dp;
     right: 40dp;
     display: flex;
     flex-flow: column;
-    border-radius: 14dp;
+    border-radius: var(--radius-window);
     overflow: hidden;
     backdrop-filter: blur(5dp);
     box-shadow: 0 0 15dp 3dp;
@@ -41,8 +47,8 @@ toast {
     transform: scale(0.9);
     transform-origin: center;
     transition: filter transform 0.2s cubic-in-out;
-    padding: 18dp 24dp;
-    gap: 8dp;
+    padding: 18dp var(--space-xl);
+    gap: var(--space-sm);
 }
 
 toast[open] {
@@ -50,15 +56,6 @@ toast[open] {
     transform: scale(1);
 }
 
-/*toast:hover {
-    cursor: pointer;
-    background-color: rgba(61, 59, 36, 80%);
-}
-
-toast:active {
-    background-color: rgba(45, 43, 26, 80%);
-}*/
-
 b {
     font-weight: bold;
 }
@@ -67,14 +64,14 @@ toast heading {
     display: flex;
     gap: 18dp;
     align-items: center;
-    font-family: "Fira Sans Condensed";
-    font-size: 18dp;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-xl);
     font-weight: bold;
     text-transform: uppercase;
-    color: #92875B;
+    color: var(--toast-heading-color);
 }
 
-toast heading > span {
+toast heading > toast-title {
     flex: 1 0 auto;
 }
 
@@ -82,13 +79,13 @@ toast heading > row {
     flex: 1 0 auto;
     display: flex;
     align-items: center;
-    gap: 4dp;
+    gap: var(--space-xs);
 }
 
 toast message {
     display: flex;
     flex-flow: column;
-    gap: 8dp;
+    gap: var(--space-sm);
 }
 
 toast message row {
@@ -99,6 +96,50 @@ toast message row.muted {
     opacity: 0.5;
 }
 
+toast.mod-installed row {
+    align-items: center;
+    gap: var(--space-md);
+}
+
+mod-icon {
+    flex: 0 0 42dp;
+    width: 42dp;
+    height: 42dp;
+    overflow: hidden;
+    border-radius: var(--radius-panel);
+    background-color: rgba(var(--color-control-rgb), 45%);
+    color: rgba(var(--color-text-rgb), 45%);
+    font-family: var(--font-family-icons);
+    font-size: var(--font-size-4xl);
+    decorator: text("&#xe87b;" center center);
+}
+
+mod-icon img {
+    width: 100%;
+    height: 100%;
+    border-radius: var(--radius-panel);
+}
+
+mod-info {
+    display: flex;
+    flex-flow: column;
+    min-width: 0;
+    gap: var(--space-xs);
+}
+
+mod-name {
+    color: var(--color-white);
+}
+
+toast.mod-installed small {
+    font-size: var(--font-size-sm);
+    color: rgba(var(--color-text-rgb), 55%);
+}
+
+toast.mod-installed small.version {
+    margin-left: var(--space-sm);
+}
+
 progress {
     height: 4dp;
     position: absolute;
@@ -108,7 +149,7 @@ progress {
 }
 
 progress fill {
-    background-color: rgba(194, 164, 45, 80%);
+    background-color: rgba(var(--color-accent-rgb), 80%);
 }
 
 pipeline-progress {
@@ -119,8 +160,8 @@ pipeline-progress {
     z-index: 100;
     min-width: 260dp;
     max-width: 90%;
-    padding: 10dp 16dp 12dp;
-    border-radius: 7dp;
+    padding: 10dp var(--space-lg) var(--space-md);
+    border-radius: var(--radius-control);
     overflow: hidden;
     filter: opacity(0);
     transition: filter 0.2s linear-in-out;
@@ -134,8 +175,8 @@ pipeline-progress[open] {
 pipeline-status {
     display: flex;
     align-items: center;
-    gap: 8dp;
-    font-size: 18dp;
+    gap: var(--space-sm);
+    font-size: var(--font-size-xl);
     font-weight: normal;
     white-space: nowrap;
 }
@@ -145,26 +186,16 @@ icon.pipeline-spinner {
     height: 1.2em;
     line-height: 1.2em;
     font-size: 1.2em;
-    color: #C2A42D;
+    color: var(--color-accent);
     text-align: center;
     transform-origin: center;
     animation: 1s linear infinite pipeline-spinner-spin;
 }
 
-toast.achievement {
-    border: 1dp #C2A42D;
-}
-
-toast.achievement heading {
-    color: #C2A42D;
-}
-
+toast.achievement,
 toast.warning {
-    border: 1dp #C2A42D;
-}
-
-toast.warning heading {
-    color: #C2A42D;
+    --toast-border-color: var(--color-accent);
+    --toast-heading-color: var(--color-accent);
 }
 
 toast.controller-warning {
@@ -181,8 +212,8 @@ toast.controller-warning[open] {
     transform: translateX(-50%) scale(1);
 }
 
-toast.controller-warning heading {
-    color: #C2A42D;
+toast.controller-warning {
+    --toast-heading-color: var(--color-accent);
 }
 
 toast.menu-notification {
@@ -209,7 +240,7 @@ toast.menu-notification message row {
 }
 
 icon {
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
     display: inline-block;
     vertical-align: middle;
@@ -243,13 +274,20 @@ icon.warning {
     decorator: text("&#xe002;" center center);
 }
 
+icon.download-done {
+    width: 1.2em;
+    height: 1.2em;
+    font-size: 1.2em;
+    decorator: text("&#xf091;" center center);
+}
+
 fps {
     display: none;
     z-index: 99;
-    font-size: 18dp;
+    font-size: var(--font-size-xl);
     font-weight: bold;
-    padding: 9dp 12dp;
-    border-radius: 7dp;
+    padding: 9dp var(--space-md);
+    border-radius: var(--radius-control);
     pointer-events: none;
     white-space: nowrap;
 }
@@ -260,12 +298,12 @@ speedrun-timer {
     bottom: 0;
     right: 0;
     z-index: 99;
-    background-color: rgba(0, 0, 0, 65%);
-    padding: 2dp 4dp;
+    background-color: rgba(var(--color-black-rgb), 65%);
+    padding: var(--space-2xs) var(--space-xs);
     pointer-events: none;
-    font-family: "Noto Mono";
-    font-size: 16dp;
-    color: #ffffff;
+    font-family: var(--font-family-monospace);
+    font-size: var(--font-size-md);
+    color: var(--color-white);
     white-space: nowrap;
 }
 
@@ -329,7 +367,7 @@ logo img {
     left: 0;
     width: 100%;
     height: 100%;
-    filter: drop-shadow(#0008 0 0 14dp);
+    filter: drop-shadow(rgba(var(--color-black-rgb), 53.333333%) 0 0 14dp);
     transform-origin: center;
 }
 
diff --git a/res/rml/popover.rcss b/res/rml/popover.rcss
new file mode 100644
index 0000000000..2084b132f0
--- /dev/null
+++ b/res/rml/popover.rcss
@@ -0,0 +1,250 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    --button-background: rgba(var(--color-control-rgb), 35%);
+
+    width: 100%;
+    height: 100%;
+    z-index: 10;
+}
+
+popover {
+    position: absolute;
+    display: flex;
+    flex-flow: column;
+    font-family: var(--font-family-body);
+    font-size: var(--font-size-sm);
+    color: var(--color-text);
+    border-radius: var(--radius-window);
+    border-width: 2dp;
+    border-color: var(--color-border);
+    background-color: rgba(var(--color-surface-rgb), 96%);
+    backdrop-filter: blur(5dp);
+    box-shadow: 0 6dp 24dp 2dp rgba(var(--color-black-rgb), 55%);
+    filter: opacity(0);
+    transform: scale(0.95);
+    transform-origin: center;
+    transition: filter transform 0.15s cubic-in-out;
+    focus: auto;
+}
+
+popover[open] {
+    filter: opacity(1);
+    transform: scale(1);
+}
+
+popover.color-picker {
+    width: 280dp;
+    padding: 18dp;
+    gap: 10dp;
+}
+
+color-sv {
+    display: block;
+    position: relative;
+    width: 240dp;
+    height: 150dp;
+    border-radius: var(--radius-panel);
+    box-shadow: rgba(var(--color-border-rgb), 50%) 0 0 0 1dp;
+    drag: drag;
+    focus: auto;
+}
+
+color-hue,
+color-alpha {
+    display: block;
+    position: relative;
+    width: 240dp;
+    height: 14dp;
+    border-radius: var(--radius-control);
+    box-shadow: rgba(var(--color-border-rgb), 50%) 0 0 0 1dp;
+    drag: drag;
+    focus: auto;
+}
+
+color-sv:focus-visible,
+color-hue:focus-visible,
+color-alpha:focus-visible {
+    box-shadow: var(--color-accent) 0 0 0 2dp;
+}
+
+color-sv.adjusting,
+color-hue.adjusting,
+color-alpha.adjusting {
+    box-shadow: var(--color-white) 0 0 0 3dp;
+}
+
+color-hue {
+    decorator: linear-gradient(90deg, #ff0000, #ffff00, #00ff00, #00ffff, #0000ff, #ff00ff, #ff0000);
+}
+
+color-cursor {
+    display: block;
+    position: absolute;
+    width: 14dp;
+    height: 14dp;
+    border-radius: var(--radius-control);
+    border-width: 2dp;
+    border-color: var(--color-white);
+    box-shadow: 0 0 4dp 1dp rgba(var(--color-black-rgb), 70%);
+    pointer-events: none;
+}
+
+color-heading {
+    display: block;
+    margin-top: var(--space-2xs);
+    font-family: var(--font-family-heading);
+    font-weight: bold;
+    font-size: var(--font-size-xs);
+    text-transform: uppercase;
+    color: rgba(var(--color-text-rgb), 55%);
+}
+
+color-presets {
+    display: flex;
+    flex-flow: row wrap;
+    gap: 5dp;
+}
+
+color-history {
+    display: flex;
+    flex-flow: row wrap;
+    gap: 5dp;
+}
+
+button.color-swatch-button {
+    width: 25dp;
+    height: 25dp;
+    padding: 0;
+    border-radius: var(--radius-control);
+}
+
+color-chip {
+    display: block;
+    flex: 0 0 20dp;
+    width: 20dp;
+    height: 20dp;
+    border-radius: 5dp;
+    box-shadow: rgba(var(--color-white-rgb), 45%) 0 0 0 1dp;
+}
+
+button.color-swatch-button color-chip {
+    width: 25dp;
+    height: 25dp;
+    border-radius: var(--radius-control);
+}
+
+color-chip.empty,
+color-swatch.empty {
+    background-color: rgba(var(--color-text-rgb), 12%);
+    decorator: linear-gradient(135deg, rgba(var(--color-text-rgb), 0) 45%,
+        rgba(var(--color-accent-rgb), 70%) 48%, rgba(var(--color-accent-rgb), 70%) 52%,
+        rgba(var(--color-text-rgb), 0) 55%);
+}
+
+color-footer {
+    display: flex;
+    align-items: center;
+    gap: 6dp;
+    padding-top: var(--space-2xs);
+}
+
+button {
+    background-color: var(--button-background);
+    padding: var(--space-xs) var(--space-sm);
+    border-radius: var(--radius-panel);
+    box-shadow: rgba(var(--color-border-rgb), 30%) 0 0 0 1dp;
+    color: var(--button-color);
+    cursor: pointer;
+    focus: auto;
+}
+
+button:hover,
+button:focus-visible {
+    background-color: var(--button-background-hover);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
+}
+
+button:active {
+    background-color: var(--button-background-active);
+}
+
+color-value {
+    display: block;
+    flex: 1 1 auto;
+    text-align: right;
+    font-family: var(--font-family-monospace);
+    font-size: var(--font-size-2xs);
+    color: var(--color-white);
+    cursor: pointer;
+    focus: auto;
+}
+
+color-value:hover,
+color-value:focus-visible {
+    color: var(--color-accent);
+}
+
+popover.context-menu {
+    min-width: 200dp;
+    max-width: 90%;
+    max-height: 90%;
+    overflow-y: auto;
+    padding: 6dp;
+    gap: 2dp;
+    transform-origin: left top;
+}
+
+.context-menu button {
+    display: flex;
+    align-items: center;
+    gap: 10dp;
+    padding: 8dp 12dp;
+    flex: 0 0 auto;
+    white-space: nowrap;
+    --button-background: transparent;
+    background-color: var(--button-background);
+    box-shadow: none;
+    transition: background-color 0.1s linear-in-out;
+}
+
+.context-menu button:not(:disabled):hover,
+.context-menu button:not(:disabled):focus-visible {
+    background-color: var(--button-background-hover);
+    box-shadow: none;
+}
+
+.context-menu button:not(:disabled):active {
+    background-color: var(--button-background-active);
+}
+
+.context-menu button:disabled {
+    background-color: transparent;
+    box-shadow: none;
+    opacity: 0.4;
+    cursor: unavailable;
+}
+
+.context-menu button.destructive {
+    color: var(--color-error);
+}
+
+.context-menu icon {
+    display: block;
+    flex: 0 0 1em;
+    width: 1em;
+    height: 1em;
+    font-family: var(--font-family-icons);
+    font-weight: normal;
+    line-height: 1;
+}
+
+menu-separator {
+    display: block;
+    flex: 0 0 1dp;
+    height: 1dp;
+    margin: 4dp 6dp;
+    background-color: var(--color-border);
+}
diff --git a/res/rml/popup.rcss b/res/rml/popup.rcss
index effc80344d..1ed1652ecd 100644
--- a/res/rml/popup.rcss
+++ b/res/rml/popup.rcss
@@ -8,10 +8,10 @@ body {
     height: 100%;
     margin: 0;
     padding: 0;
-    font-family: "Fira Sans Condensed";
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    font-size: 18dp;
-    color: #E0DBC8;
+    font-size: var(--font-size-xl);
+    color: var(--color-text);
 }
 
 button {
@@ -23,11 +23,12 @@ popup {
     width: 100%;
     display: flex;
     align-items: stretch;
-    height: 64dp;
-    background-color: rgba(21, 22, 16, 80%);
-    border-bottom: 2dp #92875B;
+    height: var(--toolbar-height);
+    background-color: rgba(var(--color-surface-rgb), 80%);
+    border-bottom-width: 2dp;
+    border-bottom-color: var(--color-border);
     backdrop-filter: blur(5dp);
-    transform: translateY(-64dp);
+    transform: translateY(var(--toolbar-hidden-offset));
     transition: transform 0.2s cubic-in-out;
 }
 
@@ -41,5 +42,5 @@ popup tab-bar {
 
 popup tab-bar tab {
     opacity: 0.35;
-    color: #E0DBC8;
+    color: var(--color-text);
 }
diff --git a/res/rml/prelaunch.rcss b/res/rml/prelaunch.rcss
index 054b6e0183..8d98577ad5 100644
--- a/res/rml/prelaunch.rcss
+++ b/res/rml/prelaunch.rcss
@@ -1,32 +1,40 @@
-*, *:before, *:after {
-    box-sizing: border-box;
-}
-
 body {
+    --color-prelaunch-accent: #FEE685;
+    --color-prelaunch-muted: #A6A09B;
+    --color-disc-error: #FFC9C9;
+    --color-disc-mismatch: #FFD6A7;
+    --color-ready: #D8F999;
+    --menu-button-decorator: horizontal-gradient(rgba(var(--color-black-rgb), 0%) rgba(var(--color-black-rgb), 0%));
+    --menu-button-decorator-hover: horizontal-gradient(#FEE685FF #FEE68500);
+
     width: 100%;
     height: 100%;
-    font-family: "Fira Sans";
+    font-family: var(--font-family-body);
     font-weight: normal;
-    font-size: 20dp;
-    color: #FFFFFF;
+    font-size: var(--font-size-2xl);
+    color: var(--color-white);
     filter: opacity(0);
     transition: filter 1s 0.2s linear-in-out;
     z-index: -1;
 }
 
-.gradient {
+body.mirrored {
+    --menu-button-decorator-hover: horizontal-gradient(#FEE68500 #FEE685FF);
+}
+
+prelaunch-gradient {
     position: absolute;
     width: 100%;
     height: 100%;
     /* The color gradient from the Figma bands really badly. A fully black gradient does as well, but not as badly. */
-    decorator: horizontal-gradient(#000000FF #00000000);
+    decorator: horizontal-gradient(rgba(var(--color-black-rgb), 100%) rgba(var(--color-black-rgb), 0%));
 }
 
-body.mirrored .gradient {
-    decorator: horizontal-gradient(#00000000 #000000FF);
+body.mirrored prelaunch-gradient {
+    decorator: horizontal-gradient(rgba(var(--color-black-rgb), 0%) rgba(var(--color-black-rgb), 100%));
 }
 
-.background {
+prelaunch-background {
     position: absolute;
     width: 100%;
     height: 100%;
@@ -39,11 +47,11 @@ body[open] {
     filter: opacity(1);
 }
 
-body[open] .background {
+body[open] prelaunch-background {
     opacity: 1;
 }
 
-body.disc-ready .background {
+body.disc-ready prelaunch-background {
     opacity: 0;
 }
 
@@ -84,7 +92,7 @@ hero {
     display: flex;
     flex-direction: column;
     align-items: flex-start;
-    gap: 4dp;
+    gap: var(--space-xs);
 }
 
 body.mirrored hero {
@@ -96,8 +104,8 @@ hero img {
 }
 
 eyebrow {
-    font-family: "Alegreya SC";
-    font-size: 32dp;
+    font-family: var(--font-family-display);
+    font-size: var(--font-size-6xl);
 }
 
 @media (min-width: 1216dp) {
@@ -107,46 +115,114 @@ eyebrow {
     }
 }
 
-eyebrow span {
+eyebrow studio-name {
     font-weight: bold;
 }
 
-#menu-list {
+menu-list {
     display: flex;
     flex-direction: column;
-    gap: 12dp;
+    gap: var(--space-md);
     align-items: flex-start;
 }
 
 #menu-list button {
     width: 428dp;
     height: 54dp;
-    padding: 8dp 16dp;
-    border-radius: 8dp;
+    padding: var(--space-sm) var(--space-lg);
+    border-radius: var(--radius-panel);
     text-align: left;
     text-transform: uppercase;
-    font-family: "Fira Sans Condensed";
-    font-size: 32dp;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-6xl);
     font-weight: normal;
     cursor: pointer;
     /* Define a fully transparent gradient as the default state, otherwise a white flash occurs */
-    decorator: horizontal-gradient(#00000000 #00000000);
+    decorator: var(--menu-button-decorator);
 }
 
 #menu-list button:disabled {
     opacity: 0.75;
     cursor: default;
-    decorator: horizontal-gradient(#00000000 #00000000);
+    decorator: var(--menu-button-decorator);
 }
 
 #menu-list button.anim-done {
     transition: decorator color opacity 0.1s linear-in-out;
 }
 
+#menu-list button.game-mode-button {
+    position: relative;
+    padding: 0;
+    overflow: visible;
+}
+
+#menu-list game-mode-label-viewport {
+    display: block;
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    border-radius: var(--radius-panel);
+    pointer-events: none;
+    z-index: 0;
+}
+
+#menu-list game-mode-label {
+    display: block;
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    padding: var(--space-sm) var(--space-lg);
+    opacity: 0;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    transition: opacity 0.24s cubic-in-out;
+}
+
+#menu-list game-mode-label.active {
+    opacity: 1;
+}
+
+#menu-list game-mode-previous,
+#menu-list game-mode-next {
+    display: none;
+    position: absolute;
+    top: 0;
+    width: 48dp;
+    height: 54dp;
+    align-items: center;
+    justify-content: center;
+    color: var(--color-white);
+    font-family: var(--font-family-icons);
+    font-weight: normal;
+    font-size: 30dp;
+    z-index: 1;
+}
+
+#menu-list game-mode-previous {
+    left: -48dp;
+    decorator: text("&#xe5cb;" center center);
+}
+
+#menu-list game-mode-next {
+    right: -48dp;
+    decorator: text("&#xe5cc;" center center);
+}
+
+#menu-list button.game-mode-button.can-cycle game-mode-previous,
+#menu-list button.game-mode-button.can-cycle game-mode-next {
+    display: flex;
+}
+
 #menu-list button:hover,
 #menu-list button:focus-visible {
-    color: black;
-    decorator: horizontal-gradient(#FEE685FF #FEE68500);
+    color: var(--color-black);
+    decorator: var(--menu-button-decorator-hover);
 }
 
 body.mirrored #menu-list {
@@ -157,11 +233,6 @@ body.mirrored #menu-list button {
     text-align: right;
 }
 
-body.mirrored #menu-list button:hover,
-body.mirrored #menu-list button:focus-visible {
-    decorator: horizontal-gradient(#FEE68500 #FEE685FF);
-}
-
 disc-info {
     position: absolute;
     left: 96dp;
@@ -169,8 +240,8 @@ disc-info {
     bottom: 72dp;
     display: flex;
     flex-direction: column;
-    gap: 12dp;
-    font-size: 24dp;
+    gap: var(--space-md);
+    font-size: var(--font-size-4xl);
     font-effect: glow(0dp 4dp 0dp 4dp black);
     text-align: left;
 }
@@ -188,9 +259,9 @@ version-info {
     bottom: 72dp;
     display: flex;
     flex-direction: column;
-    gap: 12dp;
+    gap: var(--space-md);
     text-align: right;
-    font-size: 24dp;
+    font-size: var(--font-size-4xl);
     font-effect: glow(0dp 4dp 0dp 4dp black);
     text-align: right;
 }
@@ -204,40 +275,40 @@ body.mirrored version-info {
 #disc-status {
     display: flex;
     align-items: center;
-    gap: 8dp;
+    gap: var(--space-sm);
 }
 
 #disc-status[status=good] {
-    color: #D8F999;
+    color: var(--color-ready);
 }
 
 #disc-status[status=bad] {
-    color: #FFC9C9;
+    color: var(--color-disc-error);
 }
 
 #disc-status[status=verifying] {
-    color: #FFFFFF;
+    color: var(--color-white);
 }
 
 #disc-status[status=mismatch] {
-    color: #FFD6A7;
+    color: var(--color-disc-mismatch);
 }
 
 #disc-status[status=unknown] {
-    color: rgba(224, 219, 200, 65%);
+    color: rgba(var(--color-text-rgb), 65%);
 }
 
 #disc-status[status=pending] {
-    color: #FEE685;
+    color: var(--color-prelaunch-accent);
 }
 
 #disc-status icon {
     display: none;
     width: 24dp;
     height: 24dp;
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
-    font-size: 24dp;
+    font-size: var(--font-size-4xl);
 }
 
 #disc-status[status] icon {
@@ -269,24 +340,24 @@ body.mirrored version-info {
 }
 
 #disc-version {
-    font-size: 20dp;
+    font-size: var(--font-size-2xl);
 }
 
-.update {
+update-status {
     display: none;
-    color: #A6A09B;
+    color: var(--color-prelaunch-muted);
     align-items: center;
     justify-content: flex-end;
-    gap: 8dp;
-    font-size: 20dp;
+    gap: var(--space-sm);
+    font-size: var(--font-size-2xl);
 }
 
-.update[state=checking],
-.update[state=failed] {
+update-status[state=checking],
+update-status[state=failed] {
     display: block;
 }
 
-.update[state=available] {
+update-status[state=available] {
     display: flex;
 }
 
@@ -296,33 +367,33 @@ body.mirrored version-info {
     padding: 0dp;
     border-width: 0dp;
     background-color: transparent;
-    color: #D8F999;
+    color: var(--color-ready);
     cursor: pointer;
     text-transform: uppercase;
     font-weight: bold;
-    decorator: horizontal-gradient(#00000000 #00000000);
+    decorator: var(--menu-button-decorator);
 }
 
-.update[state=available] #update-download {
+update-status[state=available] #update-download {
     display: flex;
     align-items: center;
-    gap: 2dp;
+    gap: var(--space-2xs);
 }
 
 #update-download icon {
     display: block;
     width: 18dp;
     height: 18dp;
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
     decorator: text("&#xe5c8;" center center);
 }
 
-.detail {
-    color: #A6A09B;
+disc-version {
+    color: var(--color-prelaunch-muted);
 }
 
-body.mirrored .update {
+body.mirrored update-status {
     justify-content: flex-start;
 }
 
@@ -368,12 +439,20 @@ body.animate-in .intro-item {
 
 /* Mobile layout */
 @media (max-height: 640dp) {
-    .gradient {
-        decorator: horizontal-gradient(#00000000 #000000FF);
+    body {
+        --menu-button-decorator-hover: horizontal-gradient(#FEE68500 #FEE685FF);
     }
 
-    body.mirrored .gradient {
-        decorator: horizontal-gradient(#000000FF #00000000);
+    body.mirrored {
+        --menu-button-decorator-hover: horizontal-gradient(#FEE685FF #FEE68500);
+    }
+
+    prelaunch-gradient {
+        decorator: horizontal-gradient(rgba(var(--color-black-rgb), 0%) rgba(var(--color-black-rgb), 100%));
+    }
+
+    body.mirrored prelaunch-gradient {
+        decorator: horizontal-gradient(rgba(var(--color-black-rgb), 100%) rgba(var(--color-black-rgb), 0%));
     }
 
     menu {
@@ -385,7 +464,7 @@ body.animate-in .intro-item {
         flex-direction: row;
         align-items: center;
         justify-content: space-between;
-        gap: 16dp;
+        gap: var(--space-lg);
     }
 
     body.mirrored menu {
@@ -398,7 +477,7 @@ body.animate-in .intro-item {
         flex: 1 1 0;
         min-width: 0;
         max-width: 48%;
-        margin-left: 32dp;
+        margin-left: var(--space-2xl);
     }
 
     body.mirrored hero {
@@ -422,11 +501,6 @@ body.animate-in .intro-item {
         text-align: right;
     }
 
-    #menu-list button:hover,
-    #menu-list button:focus-visible {
-        decorator: horizontal-gradient(#FEE68500 #FEE685FF);
-    }
-
     body.mirrored #menu-list {
         align-items: flex-start;
     }
@@ -435,11 +509,6 @@ body.animate-in .intro-item {
         text-align: left;
     }
 
-    body.mirrored #menu-list button:hover,
-    body.mirrored #menu-list button:focus-visible {
-        decorator: horizontal-gradient(#FEE685FF #FEE68500);
-    }
-
     eyebrow {
         display: none;
     }
@@ -450,8 +519,8 @@ body.animate-in .intro-item {
         bottom: 32dp;
         top: auto;
         text-align: right;
-        font-size: 16dp;
-        gap: 8dp;
+        font-size: var(--font-size-md);
+        gap: var(--space-sm);
     }
 
     #disc-status {
@@ -459,11 +528,11 @@ body.animate-in .intro-item {
     }
 
     #disc-status icon {
-        font-size: 20dp;
+        font-size: var(--font-size-2xl);
     }
 
     #disc-version {
-        font-size: 16dp;
+        font-size: var(--font-size-md);
     }
 
     version-info {
@@ -472,12 +541,12 @@ body.animate-in .intro-item {
         bottom: auto;
         top: 32dp;
         text-align: right;
-        font-size: 16dp;
-        gap: 8dp;
+        font-size: var(--font-size-md);
+        gap: var(--space-sm);
     }
 
-    .update {
-        font-size: 16dp;
+    update-status {
+        font-size: var(--font-size-md);
     }
 
     body.mirrored disc-info {
diff --git a/res/rml/tabbing.rcss b/res/rml/tabbing.rcss
index 8f42dd84d5..862d79a5df 100644
--- a/res/rml/tabbing.rcss
+++ b/res/rml/tabbing.rcss
@@ -18,17 +18,18 @@ tab-bar scrollbarhorizontal sliderbar {
 
 tab-bar tab {
     flex: 0 0 auto;
-    padding: 0 24dp;
-    line-height: 64dp;
+    padding: 0 var(--space-xl);
+    line-height: var(--toolbar-height);
     white-space: nowrap;
-    decorator: vertical-gradient(#c2a42d00 #c2a42d00);
+    decorator: vertical-gradient(rgba(var(--color-accent-rgb), 0%) rgba(var(--color-accent-rgb), 0%));
     transition: decorator 0.1s linear-in-out, opacity 0.1s linear-in-out;
     cursor: pointer;
 }
 
 tab-bar tab:selected {
     opacity: 1;
-    border-bottom: 4dp #C2A42D;
+    border-bottom-width: 4dp;
+    border-bottom-color: var(--color-accent);
     font-effect: glow(0dp 4dp 0dp 4dp black);
 }
 
@@ -36,17 +37,17 @@ tab-bar tab:focus-visible,
 tab-bar tab:hover {
     opacity: 1;
     font-effect: glow(0dp 4dp 0dp 4dp black);
-    decorator: vertical-gradient(#c2a42d00 #c2a42d26);
+    decorator: vertical-gradient(rgba(var(--color-accent-rgb), 0) rgba(var(--color-accent-rgb), 38));
 }
 
 tab-bar tab:active {
-    decorator: vertical-gradient(#c2a42d10 #c2a42d40);
+    decorator: vertical-gradient(rgba(var(--color-accent-rgb), 16) rgba(var(--color-accent-rgb), 64));
 }
 
 tab-bar[closable] tab-end-spacer {
     display: block;
-    flex: 0 0 64dp;
-    width: 64dp;
+    flex: 0 0 var(--toolbar-height);
+    width: var(--toolbar-height);
     pointer-events: none;
 }
 
@@ -56,13 +57,13 @@ window > close {
     position: fixed;
     top: 8dp;
     right: 8dp;
-    z-index: 1;
+    z-index: 2;
     width: 48dp;
     height: 48dp;
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
-    font-size: 24dp;
-    color: rgba(224, 219, 200, 70%);
+    font-size: var(--font-size-4xl);
+    color: rgba(var(--color-text-rgb), 70%);
     backdrop-filter: blur(2dp);
     border-radius: 6dp;
     decorator: text("&#xe5cd;" center center);
@@ -74,8 +75,8 @@ tab-bar[closable] close:hover,
 tab-bar[closable] close:focus-visible,
 window > close:hover,
 window > close:focus-visible {
-    color: #fff;
-    background-color: rgba(194, 164, 45, 24%);
+    color: var(--color-white);
+    background-color: rgba(var(--color-accent-rgb), 24%);
 }
 
 window > close {
@@ -85,6 +86,6 @@ window > close {
 
 tab-bar[closable] close:active,
 window > close:active {
-    color: #fff;
-    background-color: rgba(194, 164, 45, 40%);
+    color: var(--color-white);
+    background-color: rgba(var(--color-accent-rgb), 40%);
 }
diff --git a/res/rml/theme.rcss b/res/rml/theme.rcss
new file mode 100644
index 0000000000..8d49f32a9c
--- /dev/null
+++ b/res/rml/theme.rcss
@@ -0,0 +1,80 @@
+*, *:before, *:after {
+    box-sizing: border-box;
+}
+
+body {
+    --font-family-body: Fira Sans;
+    --font-family-heading: Fira Sans Condensed;
+    --font-family-monospace: Noto Mono;
+    --font-family-icons: Material Symbols Rounded;
+    --font-family-display: Alegreya SC;
+
+    --font-size-3xs: 11dp;
+    --font-size-2xs: 12dp;
+    --font-size-xs: 13dp;
+    --font-size-sm: 14dp;
+    --font-size-base: 15dp;
+    --font-size-md: 16dp;
+    --font-size-lg: 17dp;
+    --font-size-xl: 18dp;
+    --font-size-2xl: 20dp;
+    --font-size-3xl: 22dp;
+    --font-size-4xl: 24dp;
+    --font-size-5xl: 28dp;
+    --font-size-6xl: 32dp;
+
+    --space-2xs: 2dp;
+    --space-xs: 4dp;
+    --space-sm: 8dp;
+    --space-md: 12dp;
+    --space-lg: 16dp;
+    --space-xl: 24dp;
+    --space-2xl: 32dp;
+
+    --radius-small: 4dp;
+    --radius-control: 7dp;
+    --radius-panel: 8dp;
+    --radius-window: 14dp;
+
+    --toolbar-height: 64dp;
+    --toolbar-hidden-offset: -64dp;
+
+    --color-text-rgb: 224, 219, 200;
+    --color-text: rgb(var(--color-text-rgb));
+    --color-accent-rgb: 194, 164, 45;
+    --color-accent: rgb(var(--color-accent-rgb));
+    --color-border-rgb: 146, 135, 91;
+    --color-border: rgb(var(--color-border-rgb));
+    --color-surface-rgb: 21, 22, 16;
+    --color-interactive-rgb: 204, 184, 119;
+    --color-control-rgb: 17, 16, 10;
+    --color-neutral-rgb: 217, 217, 217;
+    --color-neutral: rgb(var(--color-neutral-rgb));
+    --color-white-rgb: 255, 255, 255;
+    --color-white: rgb(var(--color-white-rgb));
+    --color-black-rgb: 0, 0, 0;
+    --color-black: rgb(var(--color-black-rgb));
+
+    --color-success-rgb: 68, 204, 85;
+    --color-success: rgb(var(--color-success-rgb));
+    --color-info-rgb: 111, 183, 239;
+    --color-info: rgb(var(--color-info-rgb));
+    --color-warning-rgb: 255, 168, 38;
+    --color-warning: rgb(var(--color-warning-rgb));
+    --color-error-rgb: 204, 68, 68;
+    --color-error: rgb(var(--color-error-rgb));
+
+    --color-progress-done: #44AA22;
+    --color-progress-ongoing: #2255BB;
+    --color-danger-border: #852221;
+    --color-danger-heading: #B3261E;
+
+    --button-color: var(--color-text);
+    --button-background: rgba(var(--color-control-rgb), 20%);
+    --button-background-hover: rgba(var(--color-interactive-rgb), 20%);
+    --button-background-selected: rgba(var(--color-interactive-rgb), 40%);
+    --button-background-active: rgba(var(--color-interactive-rgb), 40%);
+
+    --toast-border-color: var(--color-border);
+    --toast-heading-color: var(--color-border);
+}
diff --git a/res/rml/touch_controls.rcss b/res/rml/touch_controls.rcss
index 4c8057d6c0..85320315bf 100644
--- a/res/rml/touch_controls.rcss
+++ b/res/rml/touch_controls.rcss
@@ -1,16 +1,28 @@
-*, *:before, *:after {
-    box-sizing: border-box;
-}
-
 body {
+    --color-oil-border: rgba(42, 32, 18, 82%);
+    --color-oil-background: rgba(18, 14, 10, 70%);
+    --color-oil-fill: rgb(255, 232, 74);
+    --color-button-a: rgba(34, 112, 123, 62%);
+    --color-button-b: rgba(161, 61, 66, 58%);
+    --color-button-x: rgba(83, 115, 151, 56%);
+    --color-button-y: rgba(113, 91, 150, 54%);
+    --color-stick-background: rgba(18, 20, 24, 35%);
+    --color-stick-knob: rgba(238, 236, 226, 55%);
+
+    --button-color: rgba(248, 244, 232, 90%);
+    --button-background: rgba(22, 24, 28, 48%);
+    --button-background-active: rgba(63, 78, 90, 68%);
+    --button-border-color: rgba(var(--color-white-rgb), 22%);
+    --button-border-color-active: rgba(var(--color-white-rgb), 48%);
+
     width: 100%;
     height: 100%;
     margin: 0;
     padding: 0;
     overflow: hidden;
-    font-family: "Fira Sans Condensed";
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    color: rgba(248, 244, 232, 90%);
+    color: var(--button-color);
     z-index: 1;
     filter: opacity(0);
     transition: filter 0.2s linear-in-out;
@@ -30,12 +42,11 @@ button {
     justify-content: center;
     decorator: none;
     padding: 0;
-    border: 1dp rgba(255, 255, 255, 22%);
-    background-color: rgba(22, 24, 28, 48%);
-    color: rgba(248, 244, 232, 90%);
+    border-width: 1dp;
+    border-color: var(--button-border-color);
+    background-color: var(--button-background);
+    color: var(--button-color);
     text-align: center;
-    /* backdrop-filter: blur(7dp); */
-    /* box-shadow: 0 6dp 18dp rgba(0, 0, 0, 28%); */
     transform-origin: center;
     transition: background-color border-color filter transform 0.08s linear-in-out,
                 opacity 0.2s linear-in-out;
@@ -43,8 +54,8 @@ button {
 
 button.pressed,
 button.active {
-    background-color: rgba(63, 78, 90, 68%);
-    border-color: rgba(255, 255, 255, 48%);
+    background-color: var(--button-background-active);
+    border-color: var(--button-border-color-active);
     filter: brightness(1.18);
 }
 
@@ -68,9 +79,9 @@ button icon {
 
 button icon glyph {
     display: block;
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
-    font-size: 24dp;
+    font-size: var(--font-size-4xl);
     line-height: 1;
 }
 
@@ -92,9 +103,9 @@ button icon glyph {
     position: absolute;
 }
 
-.trigger-l.active {
-    background-color: rgba(57, 116, 133, 74%);
-    border-color: rgba(128, 222, 234, 72%);
+.trigger-l {
+    --button-background-active: rgba(57, 116, 133, 74%);
+    --button-border-color-active: rgba(128, 222, 234, 72%);
 }
 
 .trigger,
@@ -103,12 +114,14 @@ button icon glyph {
 }
 
 .trigger {
-    font-size: 22dp;
+    font-size: var(--font-size-3xl);
 }
 
 .button-z {
-    background-color: rgba(118, 79, 158, 58%);
-    border-color: rgba(203, 170, 255, 36%);
+    --button-background: rgba(118, 79, 158, 58%);
+    --button-background-active: rgba(139, 91, 187, 82%);
+    --button-border-color: rgba(203, 170, 255, 36%);
+    --button-border-color-active: rgba(220, 194, 255, 70%);
 }
 
 .midna-icon {
@@ -121,7 +134,7 @@ button icon glyph {
 .button-z.has-icon span,
 .face.has-item span {
     position: absolute;
-    font-size: 13dp;
+    font-size: var(--font-size-xs);
     line-height: 1;
 }
 
@@ -130,20 +143,14 @@ button icon glyph {
     bottom: 7dp;
 }
 
-.button-z.pressed {
-    background-color: rgba(139, 91, 187, 82%);
-    border-color: rgba(220, 194, 255, 70%);
-}
-
 action-bar {
     position: absolute;
     display: flex;
     align-items: center;
-    border: 1dp rgba(255, 255, 255, 22%);
+    border-width: 1dp;
+    border-color: var(--button-border-color);
     border-radius: 23dp;
-    background-color: rgba(22, 24, 28, 48%);
-    /* backdrop-filter: blur(7dp); */
-    /* box-shadow: 0 -6dp 18dp rgba(0, 0, 0, 28%); */
+    background-color: var(--button-background);
     overflow: hidden;
     opacity: 1;
     transform-origin: center;
@@ -175,7 +182,7 @@ action-bar:hidden separator {
 }
 
 .utility.pressed {
-    background-color: rgba(63, 78, 90, 68%);
+    background-color: var(--button-background-active);
 }
 
 .utility.pressed,
@@ -185,7 +192,7 @@ action-bar:hidden separator {
 
 .skip {
     z-index: 1;
-    border-color: rgba(255, 255, 255, 36%);
+    border-color: rgba(var(--color-white-rgb), 36%);
 }
 
 separator {
@@ -193,7 +200,7 @@ separator {
     flex: 0 0 1dp;
     width: 1dp;
     height: 24dp;
-    background-color: rgba(255, 255, 255, 18%);
+    background-color: rgba(var(--color-white-rgb), 18%);
     opacity: 1;
     transition: opacity 0.2s linear-in-out;
 }
@@ -201,7 +208,7 @@ separator {
 .face {
     position: absolute;
     border-radius: 29dp;
-    font-size: 24dp;
+    font-size: var(--font-size-4xl);
     overflow: visible;
 }
 
@@ -219,10 +226,10 @@ separator {
     min-width: 17dp;
     height: 15dp;
     padding: 1dp 3dp;
-    border-radius: 7dp;
-    background-color: rgba(0, 0, 0, 52%);
-    color: rgba(255, 255, 255, 92%);
-    font-size: 12dp;
+    border-radius: var(--radius-control);
+    background-color: rgba(var(--color-black-rgb), 52%);
+    color: rgba(var(--color-white-rgb), 92%);
+    font-size: var(--font-size-2xs);
     line-height: 13dp;
     text-align: center;
 }
@@ -233,11 +240,10 @@ separator {
     bottom: -5dp;
     width: 34dp;
     height: 8dp;
-    padding: 2dp;
-    border: 1dp rgba(42, 32, 18, 82%);
-    border-radius: 4dp;
-    background-color: rgba(18, 14, 10, 70%);
-    /* box-shadow: 0 2dp 6dp rgba(0, 0, 0, 35%); */
+    padding: var(--space-2xs);
+    border: 1dp var(--color-oil-border);
+    border-radius: var(--radius-small);
+    background-color: var(--color-oil-background);
 }
 
 oil-fill {
@@ -245,31 +251,31 @@ oil-fill {
     width: 0%;
     height: 100%;
     border-radius: 2dp;
-    background-color: rgb(255, 232, 74);
+    background-color: var(--color-oil-fill);
 }
 
 .face.has-item span {
     right: 6dp;
     bottom: 6dp;
-    color: rgba(255, 255, 255, 88%);
+    color: rgba(var(--color-white-rgb), 88%);
 }
 
 .face.a {
     border-radius: 37dp;
     font-size: 31dp;
-    background-color: rgba(34, 112, 123, 62%);
+    background-color: var(--color-button-a);
 }
 
 .face.b {
-    background-color: rgba(161, 61, 66, 58%);
+    background-color: var(--color-button-b);
 }
 
 .face.x {
-    background-color: rgba(83, 115, 151, 56%);
+    background-color: var(--color-button-x);
 }
 
 .face.y {
-    background-color: rgba(113, 91, 150, 54%);
+    background-color: var(--color-button-y);
 }
 
 button.control.docked-top,
@@ -306,10 +312,9 @@ touch-stick {
     width: 124dp;
     height: 124dp;
     border-radius: 62dp;
-    background-color: rgba(18, 20, 24, 35%);
-    border: 1dp rgba(255, 255, 255, 20%);
-    /* backdrop-filter: blur(7dp); */
-    /* box-shadow: 0 8dp 24dp rgba(0, 0, 0, 24%); */
+    background-color: var(--color-stick-background);
+    border-width: 1dp;
+    border-color: rgba(var(--color-white-rgb), 20%);
     opacity: 0;
     pointer-events: none;
     transition: opacity 0.18s linear-in-out;
@@ -326,7 +331,8 @@ stick-ring {
     width: 88dp;
     height: 88dp;
     border-radius: 44dp;
-    border: 1dp rgba(255, 255, 255, 18%);
+    border-width: 1dp;
+    border-color: rgba(var(--color-white-rgb), 18%);
 }
 
 stick-knob {
@@ -334,6 +340,7 @@ stick-knob {
     width: 48dp;
     height: 48dp;
     border-radius: 24dp;
-    background-color: rgba(238, 236, 226, 55%);
-    border: 1dp rgba(255, 255, 255, 45%);
+    background-color: var(--color-stick-knob);
+    border-width: 1dp;
+    border-color: rgba(var(--color-white-rgb), 45%);
 }
diff --git a/res/rml/touch_controls_editor.rcss b/res/rml/touch_controls_editor.rcss
index 2ca99d935a..dbf0ae74e4 100644
--- a/res/rml/touch_controls_editor.rcss
+++ b/res/rml/touch_controls_editor.rcss
@@ -1,5 +1,10 @@
 body.touch-editor {
-    background-color: rgba(4, 6, 8, 34%);
+    --color-editor-backdrop: rgba(4, 6, 8, 34%);
+    --color-editor-handle: rgba(34, 37, 42, 86%);
+    --color-editor-accent-rgb: 255, 232, 128;
+    --color-editor-highlight-rgb: 255, 244, 190;
+
+    background-color: var(--color-editor-backdrop);
     z-index: 8;
 }
 
@@ -14,7 +19,7 @@ body.touch-editor .control:hover,
 body.touch-editor action-bar:hover,
 body.touch-editor .control.editor-selected,
 body.touch-editor action-bar.editor-selected {
-    border-color: rgba(255, 232, 128, 80%);
+    border-color: rgba(var(--color-editor-accent-rgb), 80%);
     filter: brightness(1.15);
 }
 
@@ -27,8 +32,9 @@ selection-frame {
     display: none;
     position: absolute;
     z-index: 20;
-    border: 2dp rgba(255, 232, 128, 88%);
-    background-color: rgba(255, 232, 128, 7%);
+    border-width: 2dp;
+    border-color: rgba(var(--color-editor-accent-rgb), 88%);
+    background-color: rgba(var(--color-editor-accent-rgb), 7%);
     pointer-events: none;
 }
 
@@ -41,9 +47,10 @@ resize-handle {
     position: absolute;
     width: 22dp;
     height: 22dp;
-    border: 2dp rgba(255, 244, 190, 96%);
+    border-width: 2dp;
+    border-color: rgba(var(--color-editor-highlight-rgb), 96%);
     border-radius: 11dp;
-    background-color: rgba(34, 37, 42, 86%);
+    background-color: var(--color-editor-handle);
     pointer-events: auto;
 }
 
@@ -90,6 +97,12 @@ resize-handle.corner.bottom {
 }
 
 editor-toolbar {
+    --button-background: rgba(17, 19, 24, 88%);
+    --button-background-hover: rgba(78, 85, 96, 92%);
+    --button-border-color: rgba(var(--color-white-rgb), 26%);
+    --button-border-color-hover: rgba(var(--color-editor-highlight-rgb), 92%);
+    --button-color: rgba(255, 250, 232, 94%);
+
     display: flex;
     position: absolute;
     left: 24dp;
@@ -98,7 +111,7 @@ editor-toolbar {
     z-index: 30;
     height: 48dp;
     margin-top: -24dp;
-    gap: 8dp;
+    gap: var(--space-sm);
     justify-content: center;
     pointer-events: auto;
 }
@@ -108,12 +121,13 @@ editor-toolbar button.editor-command {
     min-width: 96dp;
     height: 48dp;
     padding: 0 14dp;
-    border-radius: 8dp;
-    border: 1dp rgba(255, 255, 255, 26%);
-    background-color: rgba(17, 19, 24, 88%);
-    color: rgba(255, 250, 232, 94%);
-    font-family: "Fira Sans";
-    font-size: 18dp;
+    border-radius: var(--radius-panel);
+    border-width: 1dp;
+    border-color: var(--button-border-color);
+    background-color: var(--button-background);
+    color: var(--button-color);
+    font-family: var(--font-family-body);
+    font-size: var(--font-size-xl);
     line-height: 48dp;
     opacity: 1;
     cursor: pointer;
@@ -127,12 +141,12 @@ editor-toolbar button.editor-command span {
 }
 
 editor-toolbar button.editor-command.primary {
-    border-color: rgba(255, 232, 128, 70%);
-    background-color: rgba(96, 82, 38, 90%);
+    --button-border-color: rgba(var(--color-editor-accent-rgb), 70%);
+    --button-background: rgba(96, 82, 38, 90%);
 }
 
 editor-toolbar button.editor-command:hover,
 editor-toolbar button.editor-command:focus-visible {
-    border-color: rgba(255, 244, 190, 92%);
-    background-color: rgba(78, 85, 96, 92%);
+    border-color: var(--button-border-color-hover);
+    background-color: var(--button-background-hover);
 }
diff --git a/res/rml/tuner.rcss b/res/rml/tuner.rcss
index 86dd2043f6..5e0d96e855 100644
--- a/res/rml/tuner.rcss
+++ b/res/rml/tuner.rcss
@@ -1,90 +1,87 @@
-*, *:before, *:after {
-    box-sizing: border-box;
-}
-
 body {
     overflow: visible;
     width: 100%;
     height: 100%;
     margin: 0;
     padding: 0;
-    font-family: "Fira Sans Condensed";
-    font-size: 24dp;
-    color: #FFFFFF;
+    font-family: var(--font-family-heading);
+    font-size: var(--font-size-4xl);
+    color: var(--color-white);
     display: flex;
     flex-direction: column;
     justify-content: flex-end;
     align-items: stretch;
 }
 
-.tuner-root {
+tuner-root {
     width: 100%;
     min-height: 45%;
     display: flex;
     flex-direction: column;
     justify-content: flex-end;
     align-items: stretch;
-    decorator: vertical-gradient(#00000000 #151610F2);
+    decorator: vertical-gradient(rgba(var(--color-black-rgb), 0%) rgba(var(--color-surface-rgb), 242));
     filter: opacity(0);
     transition: filter 0.2s linear-in-out;
 }
 
-.tuner-root[open] {
+tuner-root[open] {
     filter: opacity(1);
 }
 
-.tuner {
+graphics-tuner {
     width: 100%;
     max-width: 1216dp;
     margin-left: auto;
     margin-right: auto;
     display: flex;
     flex-direction: column;
-    gap: 24dp;
+    gap: var(--space-xl);
     padding: 48dp 64dp;
 }
 
 @media (max-height: 800dp) {
-    .tuner-root {
+    tuner-root {
         min-height: 38%;
     }
 
-    .tuner {
-        gap: 16dp;
-        padding: 32dp 48dp;
+    graphics-tuner {
+        gap: var(--space-lg);
+        padding: var(--space-2xl) 48dp;
     }
 }
 
-.header {
+tuner-header {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    gap: 24dp;
+    gap: var(--space-xl);
 }
 
-.carousel-container {
+carousel-container {
     flex: 1 1 auto;
     display: flex;
     justify-content: flex-end;
     min-width: 0;
 }
 
-.description {
-    font-size: 18dp;
+tuner-description {
+    font-size: var(--font-size-xl);
     line-height: 22dp;
-    color: rgba(255, 255, 255, 50%);
+    color: rgba(var(--color-white-rgb), 50%);
 }
 
-.divider {
+tuner-divider {
     margin: 1dp 0;
-    border-top: 1dp rgba(217, 217, 217, 50%);
+    border-top-width: 1dp;
+    border-top-color: rgba(var(--color-neutral-rgb), 50%);
 }
 
-.footer {
+tuner-footer {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    gap: 24dp;
+    gap: var(--space-xl);
 }
 
 footer-button {
@@ -94,12 +91,12 @@ footer-button {
     border: 0;
     padding: 0;
     background-color: transparent;
-    font-family: "Fira Sans Condensed";
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    font-size: 20dp;
+    font-size: var(--font-size-2xl);
     line-height: 24dp;
     text-transform: uppercase;
-    color: #FFFFFF;
+    color: var(--color-white);
     opacity: 1;
     cursor: pointer;
 }
@@ -112,20 +109,20 @@ footer-button.reset {
     text-align: right;
 }
 
-.stepped-carousel {
+stepped-carousel {
     display: flex;
     align-items: center;
     justify-content: center;
-    gap: 16dp;
+    gap: var(--space-lg);
     width: auto;
     min-width: 246dp;
     padding: 0;
     background-color: transparent;
-    font-family: "Fira Sans Condensed";
+    font-family: var(--font-family-heading);
     font-weight: bold;
 }
 
-.stepped-carousel-value {
+stepped-carousel-value {
     line-height: 29dp;
     min-width: 166dp;
     text-align: center;
@@ -142,6 +139,6 @@ footer-button.reset {
     background-color: transparent;
     opacity: 1;
     cursor: pointer;
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
 }
diff --git a/res/rml/window.rcss b/res/rml/window.rcss
index ab338e97c7..f2f2574750 100644
--- a/res/rml/window.rcss
+++ b/res/rml/window.rcss
@@ -1,17 +1,13 @@
-*, *:before, *:after {
-    box-sizing: border-box;
-}
-
 body {
     display: flex;
     width: 100%;
     height: 100%;
     padding: 64dp;
-    font-family: "Fira Sans";
+    font-family: var(--font-family-body);
     font-weight: normal;
     font-style: normal;
-    font-size: 15dp;
-    color: #E0DBC8;
+    font-size: var(--font-size-base);
+    color: var(--color-text);
 }
 
 b {
@@ -27,12 +23,13 @@ window {
     max-width: 1088dp;
     max-height: 768dp;
     margin: auto;
-    border-radius: 14dp;
+    border-radius: var(--radius-window);
     overflow: hidden;
-    border: 2dp #92875B;
+    border-width: 2dp;
+    border-color: var(--color-border);
     backdrop-filter: blur(5dp);
     box-shadow: 0 0 25dp 5dp;
-    background-color: rgba(21, 22, 16, 90%);
+    background-color: rgba(var(--color-surface-rgb), 90%);
     filter: opacity(0);
     transform: scale(0.9);
     transform-origin: center;
@@ -48,6 +45,12 @@ window.modal {
     max-width: 640dp;
 }
 
+@media (max-height: 896dp) {
+    window.modal {
+        max-height: 100%;
+    }
+}
+
 window[open] {
     filter: opacity(1);
     transform: scale(1);
@@ -55,21 +58,32 @@ window[open] {
 
 @media (max-height: 640dp) {
     body {
-        padding: 16dp;
+        padding: var(--space-lg);
     }
     window {
         box-shadow: none;
     }
 }
 
+@media (max-width: 768dp) {
+    body {
+        padding: var(--space-lg);
+    }
+    window.modal {
+        width: 100%;
+        max-width: 100%;
+    }
+}
+
 window tab-bar {
-    flex: 0 0 64dp;
-    height: 64dp;
-    background-color: rgba(217, 217, 217, 10%);
-    font-family: "Fira Sans Condensed";
+    flex: 0 0 var(--toolbar-height);
+    height: var(--toolbar-height);
+    background-color: rgba(var(--color-neutral-rgb), 10%);
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    font-size: 18dp;
-    border-bottom: 2dp #92875B;
+    font-size: var(--font-size-xl);
+    border-bottom-width: 2dp;
+    border-bottom-color: var(--color-border);
 }
 
 window tab-bar tab {
@@ -90,42 +104,104 @@ window content pane {
     flex: 1 1 0;
     min-width: 0;
     min-height: 0;
-    padding: 24dp;
-    padding-bottom: 0dp;
-    gap: 8dp;
+    padding: var(--space-xl);
+    gap: var(--space-sm);
     overflow: hidden auto;
-    font-size: 20dp;
+    font-size: var(--font-size-2xl);
 }
 
 window content pane:not(:last-of-type) {
-    border-right: 1dp #92875B;
+    border-right-width: 1dp;
+    border-right-color: var(--color-border);
 }
 
 window content pane > * {
     flex: 0 0 auto;
 }
 
+ui-list {
+    display: flex;
+    flex-flow: column;
+    flex: 1 1 0;
+    min-width: 0;
+    min-height: 0;
+}
+
+window content pane > ui-list,
+modal-content pane > ui-list {
+    flex: 1 1 0;
+    min-width: 0;
+    min-height: 0;
+}
+
+ui-list-viewport {
+    display: block;
+    flex: 1 1 0;
+    min-width: 0;
+    min-height: 0;
+    overflow: hidden auto;
+}
+
+ui-list-content {
+    display: flex;
+    flex-flow: column;
+    gap: var(--space-sm);
+    min-width: 0;
+}
+
+ui-list-content > button.ui-list-row {
+    flex: 0 0 auto;
+}
+
+ui-list-empty {
+    display: block;
+    padding: var(--space-lg);
+    text-align: center;
+    opacity: 0.45;
+}
+
+window content pane > ui-list {
+    margin-left: -24dp;
+    margin-right: -24dp;
+}
+
+window content pane > ui-list:first-child {
+    margin-top: -24dp;
+}
+
+window content pane > ui-list:last-child {
+    margin-bottom: -24dp;
+}
+
+window content pane > ui-list ui-list-content,
+window content pane > ui-list ui-list-empty {
+    padding-left: var(--space-xl);
+    padding-right: var(--space-xl);
+}
+
+window content pane > ui-list:first-child ui-list-content,
+window content pane > ui-list:first-child ui-list-empty {
+    padding-top: var(--space-xl);
+}
+
+window content pane > ui-list:last-child ui-list-content,
+window content pane > ui-list:last-child ui-list-empty {
+    padding-bottom: var(--space-xl);
+}
+
 window content pane:last-of-type > div {
     line-height: 1.625;
 }
 
-.data-folder-current {
+data-folder-current {
     display: block;
-    font-size: 16dp;
-    color: rgba(224, 219, 200, 65%);
-}
-
-window content pane > spacer {
-    display: block;
-    /* Completes the 24dp bottom inset after the pane's 8dp gap. */
-    flex: 0 0 16dp;
-    height: 16dp;
-    pointer-events: none;
+    font-size: var(--font-size-md);
+    color: rgba(var(--color-text-rgb), 65%);
 }
 
 scrollbarvertical {
     width: 8dp;
-    margin: 4dp 4dp 4dp 0;
+    margin: var(--space-xs) var(--space-xs) var(--space-xs) 0;
 }
 
 scrollbarvertical sliderarrowdec,
@@ -141,14 +217,14 @@ scrollbarvertical slidertrack {
 scrollbarvertical sliderbar {
     width: 8dp;
     min-height: 24dp;
-    background-color: rgba(224, 219, 200, 45%);
+    background-color: rgba(var(--color-text-rgb), 45%);
     border-radius: 2dp;
     transition: background-color 0.2s cubic-in-out;
 }
 
 scrollbarvertical sliderbar:hover,
 scrollbarvertical sliderbar:active {
-    background-color: rgba(194, 164, 45, 80%);
+    background-color: rgba(var(--color-accent-rgb), 80%);
 }
 
 scrollbarhorizontal {
@@ -167,26 +243,27 @@ scrollbarhorizontal sliderbar {
     height: 0;
 }
 
-.section-heading {
-    font-family: "Fira Sans Condensed";
+section-heading {
+    font-family: var(--font-family-heading);
     font-weight: bold;
     text-transform: uppercase;
-    font-size: 22dp;
+    font-size: var(--font-size-3xl);
     opacity: 0.25;
 }
 
-.section-heading:not(:first-of-type) {
-    padding-top: 12dp;
+section-heading:not(:first-of-type) {
+    padding-top: var(--space-md);
 }
 
 button {
     text-align: center;
-    background-color: rgba(17, 16, 10, 20%);
+    color: var(--button-color);
+    background-color: var(--button-background);
     opacity: 0.9;
-    padding: 8dp 16dp;
-    border-radius: 14dp;
-    box-shadow: rgba(146, 135, 91, 25%) 0 0 0 1dp;
-    font-size: 20dp;
+    padding: var(--space-sm) var(--space-lg);
+    border-radius: var(--radius-window);
+    box-shadow: rgba(var(--color-border-rgb), 25%) 0 0 0 1dp;
+    font-size: var(--font-size-2xl);
     transition: background-color 0.1s linear-in-out, opacity 0.1s linear-in-out;
     cursor: pointer;
     focus: auto;
@@ -194,19 +271,19 @@ button {
 
 button:not(:disabled):hover,
 button:not(:disabled):focus-visible {
-    background-color: rgba(204, 184, 119, 20%);
-    box-shadow: #C2A42D 0 0 0 2dp;
+    background-color: var(--button-background-hover);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
 }
 
 button:not(:disabled):selected {
     opacity: 1;
-    background-color: rgba(204, 184, 119, 40%);
+    background-color: var(--button-background-selected);
 }
 
 button:not(:disabled):active {
     opacity: 1;
-    background-color: rgba(204, 184, 119, 40%);
-    box-shadow: #C2A42D 0 0 0 2dp;
+    background-color: var(--button-background-active);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
 }
 
 button:disabled {
@@ -222,12 +299,13 @@ button.modal-btn {
 select-button {
     display: flex;
     align-items: center;
-    gap: 8dp;
-    background-color: rgba(17, 16, 10, 20%);
+    gap: var(--space-sm);
+    color: var(--button-color);
+    background-color: var(--button-background);
     opacity: 0.9;
-    padding: 8dp 16dp;
-    border-radius: 14dp;
-    box-shadow: rgba(146, 135, 91, 25%) 0 0 0 1dp;
+    padding: var(--space-sm) var(--space-lg);
+    border-radius: var(--radius-window);
+    box-shadow: rgba(var(--color-border-rgb), 25%) 0 0 0 1dp;
     transition: background-color 0.1s linear-in-out, opacity 0.1s linear-in-out;
     cursor: pointer;
     focus: auto;
@@ -235,19 +313,19 @@ select-button {
 
 select-button:not(:disabled):hover,
 select-button:not(:disabled):focus-visible {
-    background-color: rgba(204, 184, 119, 20%);
-    box-shadow: #C2A42D 0 0 0 2dp;
+    background-color: var(--button-background-hover);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
 }
 
 select-button:not(:disabled):selected {
     opacity: 1;
-    background-color: rgba(204, 184, 119, 40%);
+    background-color: var(--button-background-selected);
 }
 
 select-button:not(:disabled):active {
     opacity: 1;
-    background-color: rgba(204, 184, 119, 40%);
-    box-shadow: #C2A42D 0 0 0 2dp;
+    background-color: var(--button-background-active);
+    box-shadow: var(--color-accent) 0 0 0 2dp;
 }
 
 select-button:disabled {
@@ -256,9 +334,9 @@ select-button:disabled {
 }
 
 select-button key {
-    font-family: "Fira Sans Condensed";
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    font-size: 18dp;
+    font-size: var(--font-size-xl);
     text-transform: uppercase;
     flex: 0 1 auto;
 }
@@ -266,7 +344,7 @@ select-button key {
 select-button value {
     flex: 1 1 auto;
     text-align: right;
-    font-size: 20dp;
+    font-size: var(--font-size-2xl);
 }
 
 select-button value.modified {
@@ -275,13 +353,47 @@ select-button value.modified {
 
 select-button input {
     text-align: right;
-    font-size: 20dp;
+    font-size: var(--font-size-2xl);
+}
+
+select-button.group-button icon {
+    flex: 0 0 24dp;
+    margin-left: auto;
+    width: 24dp;
+    height: 24dp;
+    font-size: var(--font-size-4xl);
+    color: var(--button-color);
+    decorator: text("&#xe5cc;" center center);
+}
+
+select-button.group-button value {
+    display: none;
+}
+
+select-button.color-input value {
+    min-width: 0;
+    font-family: var(--font-family-monospace);
+    font-size: var(--font-size-base);
+}
+
+select-button.color-input color-swatch {
+    display: block;
+    flex: 0 0 48dp;
+    width: 48dp;
+    height: 24dp;
+    border-radius: var(--radius-control);
+    box-shadow: rgba(var(--color-white-rgb), 45%) 0 0 0 1dp;
+}
+
+select-button.color-input color-swatch.empty {
+    background-color: rgba(var(--color-text-rgb), 12%);
+    decorator: linear-gradient(135deg, rgba(var(--color-text-rgb), 0) 45%, rgba(var(--color-accent-rgb), 70%) 48%, rgba(var(--color-accent-rgb), 70%) 52%, rgba(var(--color-text-rgb), 0) 55%);
 }
 
 icon {
     width: 1em;
     height: 1em;
-    font-family: "Material Symbols Rounded";
+    font-family: var(--font-family-icons);
     font-weight: normal;
     display: inline-block;
     vertical-align: middle;
@@ -299,6 +411,10 @@ icon.verifying {
     decorator: text("&#xe8b5;" center center);
 }
 
+icon.download {
+    decorator: text("&#xe2c4;" center center);
+}
+
 icon.celebration {
     decorator: text("&#xea65;" center center);
 }
@@ -307,73 +423,74 @@ icon.question-mark {
     decorator: text("&#xeb8b;" center center);
 }
 
-.achievement-total {
+achievement-total {
     position: absolute;
     top: 0;
-    right: 64dp;
-    height: 64dp;
-    line-height: 64dp;
-    font-family: "Fira Sans Condensed";
+    right: var(--toolbar-height);
+    height: var(--toolbar-height);
+    line-height: var(--toolbar-height);
+    font-family: var(--font-family-heading);
     font-weight: bold;
-    font-size: 16dp;
-    color: rgba(224, 219, 200, 55%);
+    font-size: var(--font-size-md);
+    color: rgba(var(--color-text-rgb), 55%);
     pointer-events: none;
 }
 
-.achievement-row {
+achievement-row {
     display: flex;
     align-items: flex-start;
     gap: 10dp;
-    padding: 12dp 0;
-    border-bottom: 1dp rgba(146, 135, 91, 30%);
+    padding: var(--space-md) 0;
+    border-bottom-width: 1dp;
+    border-bottom-color: rgba(var(--color-border-rgb), 30%);
 }
 
-.achievement-info {
+achievement-info {
     display: block;
     flex: 1 1 0;
     min-width: 0;
 }
 
-.achievement-header {
+achievement-header {
     display: flex;
     align-items: center;
 }
 
-.achievement-name {
+achievement-name {
     flex: 1;
     font-weight: bold;
 }
 
-.achievement-name.unlocked {
-    color: #ffa826;
+achievement-name.unlocked {
+    color: var(--color-warning);
 }
 
-.achievement-badge {
-    font-size: 14dp;
+achievement-badge {
+    font-size: var(--font-size-sm);
     opacity: 0.7;
 }
 
-.achievement-badge.unlocked {
-    color: #44cc55;
+achievement-badge.unlocked {
+    color: var(--color-success);
     opacity: 1;
 }
 
-.achievement-badge.locked {
-    color: #cc4444;
+achievement-badge.locked {
+    color: var(--color-error);
     opacity: 1;
 }
 
 .achievement-desc {
     display: block;
-    color: rgba(224, 219, 200, 55%);
-    font-size: 16dp;
-    margin: 4dp 0 0 0;
+    color: rgba(var(--color-text-rgb), 55%);
+    font-size: var(--font-size-md);
+    margin: var(--space-xs) 0 0 0;
 }
 
-.achievement-progress {
+achievement-progress {
     display: block;
-    font-size: 13dp;
-    color: rgba(224, 219, 200, 45%);
+    font-size: var(--font-size-xs);
+    color: rgba(var(--color-text-rgb), 45%);
 }
 
 progress {
@@ -381,29 +498,32 @@ progress {
     width: 100%;
     height: 6dp;
     border-radius: 3dp;
-    background-color: rgba(255, 255, 255, 10%);
-    margin: 6dp 0 2dp 0;
+    background-color: rgba(var(--color-white-rgb), 10%);
+    margin: 6dp 0 var(--space-2xs) 0;
+}
+
+progress fill {
+    background-color: rgba(var(--color-accent-rgb), 80%);
+    border-radius: 3dp;
 }
 
 progress.progress-done fill {
-    background-color: #44aa22;
-    border-radius: 3dp;
+    background-color: var(--color-progress-done);
 }
 
 progress.progress-ongoing fill {
-    background-color: #2255bb;
-    border-radius: 3dp;
+    background-color: var(--color-progress-ongoing);
 }
 
 button.achievement-clear {
     flex: 0 0 auto;
     align-self: center;
-    font-size: 14dp;
-    padding: 2dp 8dp;
+    font-size: var(--font-size-sm);
+    padding: var(--space-2xs) var(--space-sm);
     opacity: 0.45;
 }
 
-.preset-grid {
+preset-grid {
     display: flex;
     flex-direction: row;
     gap: 20dp;
@@ -412,110 +532,450 @@ button.achievement-clear {
     width: 100%;
 }
 
-.preset-col {
+preset-option {
     display: flex;
     flex-flow: column;
-    gap: 12dp;
+    gap: var(--space-md);
     flex: 1 1 0;
 }
 
-.preset-desc {
+preset-description {
     display: block;
-    font-size: 16dp;
+    font-size: var(--font-size-md);
     text-align: center;
 }
 
-.modal-dialog {
+modal-dialog {
     display: flex;
     flex-direction: column;
     align-items: flex-start;
-    padding: 24dp;
+    padding: var(--space-xl);
     gap: 20dp;
     flex: 0 1 auto;
+    min-height: 0;
     width: 100%;
+    overflow: hidden;
     text-align: left;
 }
 
 window.modal.danger {
-    border: 2dp #852221;
+    border: 2dp var(--color-danger-border);
 }
 
-.modal-header {
+modal-header {
     display: flex;
     flex-direction: row;
     align-items: center;
     justify-content: space-between;
     width: 100%;
     flex: 0 0 auto;
-    gap: 16dp;
+    gap: var(--space-lg);
 }
 
-.modal-header icon {
-    font-size: 24dp;
-    color: #92875B;
+modal-header icon {
+    font-size: var(--font-size-4xl);
+    color: var(--color-border);
 }
 
-.modal-title {
+modal-title {
     display: block;
-    font-family: "Fira Sans Condensed";
+    font-family: var(--font-family-heading);
     font-weight: bold;
     text-transform: uppercase;
-    font-size: 18dp;
-    color: #92875B;
+    font-size: var(--font-size-xl);
+    color: var(--color-border);
     flex: 1 1 auto;
 }
 
-window.modal.danger .modal-title,
-window.modal.danger .modal-header icon {
-    color: #B3261E;
+window.modal.danger modal-title,
+window.modal.danger modal-header icon {
+    color: var(--color-danger-heading);
 }
 
-.modal-body {
+modal-body {
     display: block;
     width: 100%;
-    flex: 0 1 auto;
+    flex: 0 0 auto;
     min-width: 0;
-    font-size: 20dp;
-    color: #FFFFFF;
+    font-size: var(--font-size-2xl);
+    color: var(--color-white);
     font-weight: normal;
 }
 
-.modal-body span.tip {
-    font-size: 14dp;
-    color: #92875B;
+modal-body modal-tip {
+    font-size: var(--font-size-sm);
+    color: var(--color-border);
 }
 
-.verification-progress {
+modal-content {
+    display: none;
+    width: 100%;
+    flex: 1 1 auto;
+    min-height: 0;
+    overflow: hidden;
+}
+
+modal-content.active {
+    display: flex;
+    flex-direction: column;
+}
+
+modal-content pane {
+    display: flex;
+    flex: 1 1 auto;
+    flex-direction: column;
+    min-height: 0;
+    width: 100%;
+    gap: var(--space-sm);
+    overflow: hidden auto;
+}
+
+modal-content pane > * {
+    flex: 0 0 auto;
+}
+
+window.modal.install-queue {
+    max-height: 768dp;
+}
+
+window.modal.drop-install {
+    max-height: 720dp;
+}
+
+window.modal.drop-install package-row {
+    padding-right: 0;
+}
+
+window.modal.install-queue modal-body {
+    display: none;
+}
+
+window.modal.install-queue modal-content pane {
+    gap: 0;
+    padding-right: 14dp;
+    padding-bottom: 6dp;
+}
+
+package-row {
+    display: flex;
+    flex-direction: row;
+    align-items: flex-start;
+    position: relative;
+    width: 100%;
+    gap: 10dp;
+    padding: var(--space-md) 0;
+    border-bottom-width: 1dp;
+    border-bottom-color: rgba(var(--color-border-rgb), 30%);
+}
+
+package-row:last-child {
+    border-bottom-width: 0;
+}
+
+package-row > mod-icon {
+    display: none;
+    flex: 0 0 36dp;
+    width: 36dp;
+    height: 36dp;
+    margin-top: var(--space-2xs);
+    overflow: hidden;
+    border-radius: var(--radius-panel);
+    background-color: rgba(var(--color-control-rgb), 45%);
+    color: rgba(var(--color-text-rgb), 45%);
+    font-family: var(--font-family-icons);
+    font-size: var(--font-size-4xl);
+    decorator: text("&#xe87b;" center center);
+}
+
+package-row > mod-icon.visible {
+    display: block;
+}
+
+package-row > mod-icon.has-image {
+    background-color: transparent;
+}
+
+package-row.paused > mod-icon,
+package-row.retrying > mod-icon,
+package-row.failed > mod-icon {
+    filter: grayscale(1);
+    opacity: 0.55;
+}
+
+package-row > section {
+    display: flex;
+    flex-direction: column;
+    flex: 1 1 0;
+    min-width: 0;
+    margin: 0;
+    padding: 0;
+}
+
+package-row > section > header {
+    display: flex;
+    width: 100%;
+    gap: var(--space-sm);
+    align-items: center;
+    margin: 0;
+    padding: 0 0 6dp 0;
+}
+
+package-row h3 {
+    display: flex;
+    align-items: baseline;
+    flex: 1 1 auto;
+    min-width: 0;
+    gap: var(--space-xs);
+    margin: 0;
+    padding: 0;
+    overflow: hidden;
+}
+
+package-row h3 > span {
+    display: block;
+    flex: 0 1 auto;
+    min-width: 0;
+    font-weight: bold;
+    color: var(--color-white);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+package-row h3 > small {
+    display: block;
+    flex: 0 0 auto;
+    font-size: var(--font-size-xs);
+    font-weight: normal;
+    color: rgba(var(--color-text-rgb), 50%);
+}
+
+package-row header > small {
+    display: block;
+    flex: 0 0 auto;
+    font-size: var(--font-size-sm);
+    color: rgba(var(--color-text-rgb), 60%);
+}
+
+package-row.downloading header > small {
+    color: var(--color-accent);
+}
+
+package-row.retrying header > small {
+    color: var(--color-warning);
+}
+
+package-row.failed header > small,
+package-row.failed footer > small {
+    color: var(--color-error);
+}
+
+package-row.installed header > small,
+package-row.installed footer > small {
+    color: var(--color-success);
+}
+
+package-row progress {
+    width: 100%;
+    height: 6dp;
+    margin: 0 0 var(--space-sm) 0;
+    border-radius: 3dp;
+}
+
+package-row.failed progress fill {
+    background-color: var(--color-error);
+}
+
+package-row.paused progress fill {
+    background-color: rgba(var(--color-text-rgb), 35%);
+}
+
+package-row.retrying progress fill {
+    background-color: rgba(var(--color-warning-rgb), 55%);
+}
+
+package-row.installed progress fill {
+    background-color: var(--color-success);
+}
+
+package-row footer {
+    display: flex;
+    align-items: flex-start;
+    width: 100%;
+    min-width: 0;
+    gap: var(--space-sm);
+    margin: 0;
+    padding: 0;
+}
+
+package-row footer > small {
+    display: block;
+    flex: 1 1 0;
+    min-width: 0;
+    font-size: var(--font-size-xs);
+    line-height: 1;
+    color: rgba(var(--color-text-rgb), 45%);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+package-row nav {
+    display: flex;
+    flex: 0 0 auto;
+    gap: 6dp;
+    margin: 0;
+    padding: 0;
+}
+
+package-row nav > button.icon-action {
+    align-items: center;
+    justify-content: center;
+    flex: 0 0 30dp;
+    width: 30dp;
+    min-width: 30dp;
+    height: 26dp;
+    padding: 0;
+    border-radius: 14dp;
+    font-size: var(--font-size-md);
+}
+
+package-row nav > button.icon-action icon {
+    flex: 0 0 var(--font-size-md);
+    width: var(--font-size-md);
+    height: var(--font-size-md);
+    font-size: var(--font-size-md);
+    line-height: 1;
+}
+
+package-row.installed {
+    align-items: center;
+}
+
+package-row.installed > mod-icon {
+    margin-top: 0;
+}
+
+package-row.installed > section {
+    padding-right: 38dp;
+}
+
+package-row.installed header > small {
+    display: none;
+}
+
+package-row.installed nav {
+    position: absolute;
+    top: 17dp;
+    right: 0;
+}
+
+package-row.installed nav > button.icon-action {
+    opacity: 0.45;
+}
+
+verification-progress {
     display: flex;
     flex-direction: column;
     gap: 10dp;
     width: 100%;
 }
 
-.verification-file {
+verification-file {
     display: block;
-    font-size: 17dp;
-    color: #FFFFFF;
+    font-size: var(--font-size-lg);
+    color: var(--color-white);
 }
 
 progress.verification-progress-bar {
     height: 8dp;
-    margin: 2dp 0 0 0;
+    margin: var(--space-2xs) 0 0 0;
 }
 
-.verification-detail {
+verification-detail {
     display: block;
-    font-size: 14dp;
-    color: rgba(224, 219, 200, 65%);
+    font-size: var(--font-size-sm);
+    color: rgba(var(--color-text-rgb), 65%);
 }
 
-.modal-actions {
+modal-actions {
     display: flex;
     flex-direction: row;
     flex-wrap: nowrap;
     align-items: stretch;
-    gap: 12dp;
+    gap: var(--space-md);
     width: 100%;
     flex: 0 0 auto;
-    padding-top: 4dp;
+    padding-top: var(--space-xs);
+}
+
+modal-actions.vertical {
+    flex-direction: column;
+    align-items: stretch;
+}
+
+modal-actions.vertical button.modal-btn {
+    flex: 0 0 auto;
+    width: 100%;
+}
+
+@media (max-height: 640dp) {
+    modal-dialog {
+        padding: var(--space-lg);
+        gap: var(--space-md);
+    }
+
+    modal-body {
+        font-size: var(--font-size-lg);
+    }
+}
+
+@media (max-width: 640dp) {
+    modal-actions {
+        flex-direction: column;
+    }
+
+    modal-actions button.modal-btn {
+        flex: 0 0 auto;
+        width: 100%;
+    }
+}
+
+button.icon-button {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 44dp;
+    height: 44dp;
+    padding: var(--space-sm);
+    box-sizing: border-box;
+    flex-shrink: 0;
+    font-size: var(--font-size-5xl);
+}
+
+button.icon-button icon {
+    display: block;
+    flex-shrink: 0;
+    line-height: 1;
+    pointer-events: none;
+}
+
+ui-tooltip {
+    display: none;
+    position: absolute;
+    z-index: 1000;
+    max-width: 240dp;
+    padding: 6dp 10dp;
+    border: 1dp var(--color-border);
+    border-radius: var(--radius-panel);
+    background-color: rgba(var(--color-surface-rgb), 96%);
+    color: var(--color-text);
+    font-size: var(--font-size-md);
+    word-break: break-word;
+    pointer-events: none;
+    focus: none;
+}
+
+ui-tooltip.visible {
+    display: block;
 }
diff --git a/sdk/CMakeLists.txt b/sdk/CMakeLists.txt
index 533bcc22c1..e97d063897 100644
--- a/sdk/CMakeLists.txt
+++ b/sdk/CMakeLists.txt
@@ -1,18 +1,18 @@
 # Dusklight Mod SDK entry point
 #
-# Provides game/service headers, compile definitions and version.h without
-# configuring the full game tree.
+# Provides selectable mod service, game ABI, and WebGPU header surfaces without configuring the
+# full game tree.
 #
 # Usage (from a mod project):
 #   add_subdirectory(<dusk>/sdk dusk-sdk EXCLUDE_FROM_ALL)
-#   add_mod(my_mod SOURCES ... MOD_JSON mod.json)
+#   add_mod(my_mod FEATURES fmt game webgpu SOURCES ... MOD_JSON mod.json)
 #
-# On Windows, pass -DDUSK_GAME_IMPLIB=<path to sdk/dusklight.lib> from the
-# matching game release. TODO: auto-download from tag
+# On platforms where mods link against the game binary (Windows/Apple/Android), a
+# version-independent link stub is downloaded automatically unless DUSK_GAME_EXE is set.
 
 cmake_minimum_required(VERSION 3.25)
 
-if (TARGET dusklight_game_headers)
+if (TARGET dusklight_mod_api)
     message(FATAL_ERROR "Mod SDK already configured")
 endif ()
 
@@ -25,18 +25,13 @@ endif ()
 
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
-# Version detection & version.h
-include("${CMAKE_CURRENT_SOURCE_DIR}/../cmake/DetectVersion.cmake")
-detect_version()
-configure_version_header()
-
-# Game ABI headers & compile definitions
+# Mod API and optional feature header surfaces
 include("${CMAKE_CURRENT_SOURCE_DIR}/../cmake/GameABIConfig.cmake")
 
-if (WIN32)
-    set(DUSK_GAME_IMPLIB "" CACHE FILEPATH "Path to the dusklight import library (sdk/dusklight.lib)")
-    if (DUSK_GAME_IMPLIB AND NOT EXISTS "${DUSK_GAME_IMPLIB}")
-        message(FATAL_ERROR "Mod SDK: DUSK_GAME_IMPLIB does not exist: ${DUSK_GAME_IMPLIB}")
+if (WIN32 OR APPLE OR ANDROID)
+    set(DUSK_GAME_EXE "" CACHE FILEPATH "Game binary or link stub mods link against")
+    if (DUSK_GAME_EXE AND NOT EXISTS "${DUSK_GAME_EXE}")
+        message(FATAL_ERROR "Mod SDK: DUSK_GAME_EXE does not exist: ${DUSK_GAME_EXE}")
     endif ()
 endif ()
 
diff --git a/sdk/include/mods/api.h b/sdk/include/mods/api.h
new file mode 100644
index 0000000000..3015130ae3
--- /dev/null
+++ b/sdk/include/mods/api.h
@@ -0,0 +1,287 @@
+#pragma once
+
+#ifdef __cplusplus
+#include <cstddef>
+#include <cstdint>
+extern "C" {
+#else
+#include <assert.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#endif
+
+#if defined(_WIN32)
+#define MOD_EXPORT __declspec(dllexport)
+#else
+#define MOD_EXPORT __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+#define MOD_EXTERN_C extern "C"
+#else
+#define MOD_EXTERN_C extern
+#endif
+
+#ifdef __cplusplus
+#define MOD_DECLARE_SERVICE(                                                                      \
+    service_type, variable, service_id_value, major_value, minor_value)                           \
+    MOD_EXTERN_C const service_type* variable;                                                    \
+    template <>                                                                                   \
+    struct mods::ServiceTraits<service_type> {                                                    \
+        static constexpr const char* id = service_id_value;                                       \
+        static constexpr uint16_t major_version = major_value;                                    \
+        static constexpr uint16_t minor_version = minor_value;                                    \
+    }
+#else
+#define MOD_DECLARE_SERVICE(                                                                      \
+    service_type, variable, service_id_value, major_value, minor_value)                           \
+    MOD_EXTERN_C const service_type* variable
+#endif
+
+#define MOD_ABI_VERSION 1u
+#define MOD_ERROR_MESSAGE_SIZE 512u
+
+#define DUSKLIGHT_SERVICE_ID_PREFIX "dev.twilitrealm.dusklight."
+
+typedef struct ModContext ModContext;
+
+typedef enum ModResult {
+    MOD_OK = 0,
+    MOD_ERROR = 1,
+    MOD_UNAVAILABLE = 2,
+    MOD_UNSUPPORTED = 3,
+    MOD_CONFLICT = 4,
+    MOD_INVALID_ARGUMENT = 5,
+} ModResult;
+
+static_assert(sizeof(ModResult) == 4,
+    "mod SDK enums must be int-sized; do not build mods with -fshort-enums");
+
+typedef struct ModError {
+    uint32_t struct_size;
+    ModResult code;
+    char message[MOD_ERROR_MESSAGE_SIZE];
+} ModError;
+
+#define MOD_ERROR_INIT {sizeof(ModError), MOD_OK, {0}}
+
+/*
+ * Opaque per-mod context, populated by the host before mod_initialize is called.
+ * Pass it as the first argument to every service call; it identifies the calling
+ * mod for attribution (logging, resource lookup, hook ownership, etc.).
+ */
+MOD_EXPORT extern ModContext* mod_ctx;
+
+/*
+ * Service versioning contract:
+ *
+ * A service is a struct of function pointers, beginning with a ServiceHeader.
+ * Compatibility is tracked with a major/minor version pair:
+ *
+ * - A major version bump is a breaking change. Different majors are distinct
+ *   services; the registry never matches an import against a different major.
+ * - A minor version bump may only append fields to the end of the struct.
+ *   Existing fields must keep their offsets and semantics.
+ *
+ * Providers: exporting minor N means every function pointer introduced at or
+ * below N is populated (non-NULL). struct_size reflects the compiled struct.
+ *
+ * Importers: importing with min_minor_version N guarantees (enforced at load
+ * time) that the resolved service is at least minor N, so any field introduced
+ * at or below N may be used unconditionally, with no availability checks.
+ * Fields newer than the declared min_minor_version must be gated behind
+ * SERVICE_HAS plus a NULL check on the pointer itself.
+ *
+ * Load ordering: a manifest import of another mod's service (required or
+ * optional) guarantees that the provider's mod_initialize completed before the
+ * importer's runs, and deferred services published during the provider's
+ * initialization resolve into import slots just like static exports. If a
+ * provider fails to load, mods that required its services fail in turn. Mods
+ * whose required imports form a cycle all fail to load; a cycle involving an
+ * optional import is broken by dropping the ordering guarantee (not the
+ * resolution) of that optional import. Dynamic lookups via
+ * HostService::get_service carry no ordering guarantee: they see whatever has
+ * been published at call time.
+ */
+typedef struct ServiceHeader {
+    uint32_t struct_size;
+    uint16_t major_version;
+    uint16_t minor_version;
+} ServiceHeader;
+
+#define SERVICE_HEADER(service_type, major, minor) {sizeof(service_type), (major), (minor)}
+
+#define SERVICE_HAS(service, service_type, field)                                                  \
+    ((service) != NULL &&                                                                          \
+        (service)->header.struct_size >=                                                           \
+            (uint32_t)(offsetof(service_type, field) + sizeof(((service_type*)0)->field)))
+
+typedef enum ServiceImportFlags {
+    SERVICE_IMPORT_REQUIRED = 0u,
+    SERVICE_IMPORT_OPTIONAL = 1u << 0u,
+} ServiceImportFlags;
+
+typedef enum ServiceExportFlags {
+    SERVICE_EXPORT_STATIC = 0u,
+    SERVICE_EXPORT_DEFERRED = 1u << 0u,
+} ServiceExportFlags;
+
+/*
+ * Mod metadata records.
+ *
+ * A mod's manifest is a sequence of records in a dedicated section of the native library ("modmeta"
+ * on ELF, "__DATA,__modmeta" on Mach-O, "modmeta$a/$d/$z" on PE).
+ *
+ * The records are pure data. Every string is inline and NUL-terminated. Fields documented as
+ * runtime-only hold relocated pointers that are meaningless on disk; static parsers recover their
+ * targets from the file's relocation/bind entries instead.
+ *
+ * Layout rules:
+ * - Little-endian, 8-byte aligned; every record size is a multiple of 8.
+ * - Parsers must skip all-zero 8-byte units (linker padding) and records of unknown kind.
+ * - Exactly one MOD_META_HEADER record per library.
+ *
+ * The IMPORT_SERVICE/EXPORT_SERVICE/DEFINE_HOOK macros emit these records; mods do not construct
+ * them by hand.
+ */
+
+#define MOD_META_SERVICE_ID_SIZE 64u
+
+/* Records are 8-byte aligned so the linker packs them without padding; most are naturally
+ * aligned by their pointer fields, the alignment below covers the rest. */
+#if defined(__cplusplus)
+#define MOD_META_ALIGN alignas(8)
+#elif defined(_MSC_VER)
+#define MOD_META_ALIGN __declspec(align(8))
+#else
+#define MOD_META_ALIGN __attribute__((aligned(8)))
+#endif
+
+typedef enum ModMetaKind {
+    MOD_META_PAD = 0,
+    MOD_META_HEADER = 1,
+    MOD_META_IMPORT = 2,
+    MOD_META_EXPORT = 3,
+    MOD_META_HOOK_FN = 4,
+    MOD_META_HOOK_MEM = 5,
+    MOD_META_HOOK_NAME = 6,
+    MOD_META_HOOK_MEM_EXT = 7,
+} ModMetaKind;
+
+typedef struct ModMetaRecord {
+    uint16_t size; /* total record size in bytes, a multiple of 8 */
+    uint8_t kind;  /* ModMetaKind */
+    uint8_t flags; /* ServiceImportFlags / ServiceExportFlags for imports/exports */
+} ModMetaRecord;
+
+typedef struct ModMetaServiceId {
+    char chars[MOD_META_SERVICE_ID_SIZE]; /* NUL-terminated */
+} ModMetaServiceId;
+
+typedef struct MOD_META_ALIGN ModMetaHeader {
+    ModMetaRecord rec;
+    uint32_t abi_version;
+} ModMetaHeader;
+
+static_assert(sizeof(ModMetaHeader) == 8);
+
+typedef struct MOD_META_ALIGN ModMetaImport {
+    ModMetaRecord rec;
+    uint16_t major_version;
+    uint16_t min_minor_version;
+    void* slot; /* runtime only */
+    ModMetaServiceId service_id;
+} ModMetaImport;
+
+static_assert(sizeof(ModMetaImport) == 16 + MOD_META_SERVICE_ID_SIZE);
+
+typedef struct MOD_META_ALIGN ModMetaExport {
+    ModMetaRecord rec;
+    uint16_t major_version;
+    uint16_t minor_version;
+    const void* service; /* runtime only */
+    ModMetaServiceId service_id;
+} ModMetaExport;
+
+static_assert(sizeof(ModMetaExport) == 16 + MOD_META_SERVICE_ID_SIZE);
+
+/* Hook on a function named at link time: `target` carries the &fn relocation. */
+typedef struct MOD_META_ALIGN ModMetaHookFn {
+    ModMetaRecord rec;
+    uint32_t reserved;
+    void* target;   /* runtime only */
+    void* resolved; /* runtime only */
+} ModMetaHookFn;
+
+static_assert(sizeof(ModMetaHookFn) == 24);
+
+/*
+ * Hook on a member function: `pmf` holds the compiler's pointer-to-member representation
+ * (non-virtual: a function address relocation; virtual Itanium/AAPCS: literal slot words). Two
+ * NUL-terminated strings follow `resolved`: the class vtable symbol (empty if the class name is not
+ * representable), then the stringified target for tooling display.
+ */
+#define MOD_META_HOOK_MEM_CAPACITY 16u
+typedef struct MOD_META_ALIGN ModMetaHookMem {
+    ModMetaRecord rec;
+    uint32_t reserved;
+    unsigned char pmf[MOD_META_HOOK_MEM_CAPACITY];
+    void* resolved; /* runtime only */
+} ModMetaHookMem;
+
+static_assert(sizeof(ModMetaHookMem) == 32);
+
+/*
+ * Extended member-function hook record. The Microsoft x64 ABI uses a 24-byte member pointer for
+ * classes whose inheritance model was fixed while the class was incomplete. Keep this a distinct
+ * record kind so loaders can continue to consume MOD_META_HOOK_MEM's original 16-byte layout.
+ *
+ * MSVC cannot constant-initialize that member pointer, so materialize points to a compiler-
+ * generated helper that writes its native representation to a caller-provided buffer. The record
+ * itself, including its trailing names and the helper relocation, remains constant-initialized and
+ * available to static tooling. pmf_size is the number of bytes the helper writes.
+ */
+#define MOD_META_HOOK_MEM_EXT_CAPACITY 24u
+typedef void (*ModMetaHookMemMaterializeFn)(unsigned char* out_pmf);
+typedef struct MOD_META_ALIGN ModMetaHookMemExt {
+    ModMetaRecord rec;
+    uint32_t pmf_size;
+    ModMetaHookMemMaterializeFn materialize;
+    void* resolved; /* runtime only */
+} ModMetaHookMemExt;
+
+static_assert(sizeof(ModMetaHookMemExt) == 24);
+
+/*
+ * Hook on a function by symbol name, for targets that cannot be named in C++ (file-local statics,
+ * private members). One NUL-terminated string follows `resolved`; it may be either the platform
+ * mangled name or the demangled qualified display name.
+ */
+typedef struct MOD_META_ALIGN ModMetaHookName {
+    ModMetaRecord rec;
+    uint32_t reserved;
+    void* resolved; /* runtime only */
+} ModMetaHookName;
+
+static_assert(sizeof(ModMetaHookName) == 16);
+
+typedef struct ModMeta {
+    uint32_t struct_size;
+    const void* records_begin;
+    const void* records_end;
+} ModMeta;
+
+MOD_EXPORT extern const ModMeta mod_meta;
+
+typedef ModResult (*ModInitializeFn)(ModError* out_error);
+typedef ModResult (*ModUpdateFn)(ModError* out_error);
+typedef ModResult (*ModShutdownFn)(ModError* out_error);
+
+MOD_EXPORT ModResult mod_initialize(ModError* out_error);
+MOD_EXPORT ModResult mod_update(ModError* out_error);
+MOD_EXPORT ModResult mod_shutdown(ModError* out_error);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/sdk/include/mods/bits.hpp b/sdk/include/mods/bits.hpp
new file mode 100644
index 0000000000..b8da8ad93e
--- /dev/null
+++ b/sdk/include/mods/bits.hpp
@@ -0,0 +1,6 @@
+#pragma once
+
+// Really lazy way to avoid duplicating these helpers
+#define dusk mods
+#include "../../../include/helpers/bits.hpp"
+#undef dusk
diff --git a/sdk/include/mods/hook.hpp b/sdk/include/mods/hook.hpp
new file mode 100644
index 0000000000..d0e793204c
--- /dev/null
+++ b/sdk/include/mods/hook.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+#if defined(_MSC_VER)
+#pragma message("warning: <mods/hook.hpp> is deprecated; include <mods/svc/hook.hpp> instead")
+#else
+#warning "<mods/hook.hpp> is deprecated; include <mods/svc/hook.hpp> instead"
+#endif
+
+#include <mods/svc/hook.hpp>
+
+namespace mods {
+
+template <class Entry>
+ModResult hook_install(const HookService* hooks) {
+    return hook::install<Entry>(hooks);
+}
+
+template <class Entry>
+ModResult hook_install() {
+    return hook::install<Entry>();
+}
+
+template <class Entry>
+ModResult hook_add_pre(
+    const HookService* hooks, HookPreFn callback, const HookOptions* options = nullptr) {
+    return hook::add_pre<Entry>(hooks, callback, options);
+}
+
+template <class Entry>
+ModResult hook_add_pre(HookPreFn callback, const HookOptions* options = nullptr) {
+    return hook::add_pre<Entry>(callback, options);
+}
+
+template <class Entry>
+ModResult hook_add_post(
+    const HookService* hooks, HookPostFn callback, const HookOptions* options = nullptr) {
+    return hook::add_post<Entry>(hooks, callback, options);
+}
+
+template <class Entry>
+ModResult hook_add_post(HookPostFn callback, const HookOptions* options = nullptr) {
+    return hook::add_post<Entry>(callback, options);
+}
+
+template <class Entry>
+ModResult hook_replace(
+    const HookService* hooks, HookReplaceFn callback, const HookOptions* options = nullptr) {
+    return hook::replace<Entry>(hooks, callback, options);
+}
+
+template <class Entry>
+ModResult hook_replace(HookReplaceFn callback, const HookOptions* options = nullptr) {
+    return hook::replace<Entry>(callback, options);
+}
+
+template <class Entry>
+ModResult hook_uninstall(const HookService* hooks) {
+    return hook::uninstall<Entry>(hooks);
+}
+
+template <class Entry>
+ModResult hook_uninstall() {
+    return hook::uninstall<Entry>();
+}
+
+}  // namespace mods
diff --git a/sdk/include/mods/items.h b/sdk/include/mods/items.h
new file mode 100644
index 0000000000..ceee2a0efc
--- /dev/null
+++ b/sdk/include/mods/items.h
@@ -0,0 +1,67 @@
+#pragma once
+
+/*
+ * ItemService check names.
+ */
+
+#define ITEM_CHECK_BOSS_PREFIX "boss:"                     /* <stage> */
+#define ITEM_CHECK_BUG_PREFIX "bug:"                       /* <insect_item> */
+#define ITEM_CHECK_CHEST_PREFIX "chest:"                   /* <stage>:<box> */
+#define ITEM_CHECK_FREESTANDING_PREFIX "freestanding:"     /* <stage>:<bit> */
+#define ITEM_CHECK_GOLDEN_WOLF_PREFIX "golden_wolf:"       /* <event_flag> */
+#define ITEM_CHECK_POE_PREFIX "poe:"                       /* <stage>:<switch> */
+#define ITEM_CHECK_SHOP_PREFIX "shop:"                     /* <stage>:<room>:<item> */
+#define ITEM_CHECK_SKY_PREFIX "sky:"                       /* <stage>:<room> */
+#define ITEM_CHECK_DUNGEON_REWARD_PREFIX "dungeon_reward:" /* <stage> */
+
+#define ITEM_CHECK_ARCHERY_REWARD "archery_reward:F_SP109"
+#define ITEM_CHECK_ASHEI_SKETCH "ashei_sketch"
+#define ITEM_CHECK_AURU_MEMO "auru_memo"
+#define ITEM_CHECK_BALL_AND_CHAIN "ball_and_chain:D_MN11"
+#define ITEM_CHECK_BULBLIN_KEY "bulblin_key:D_MN09"
+#define ITEM_CHECK_CORAL_EARRING "coral_earring"
+#define ITEM_CHECK_CORO_BOTTLE "coro_bottle"
+#define ITEM_CHECK_CORO_GATE_KEY "coro_gate_key"
+#define ITEM_CHECK_CORO_LANTERN "coro_lantern"
+#define ITEM_CHECK_DUNGEON_MAP_SNOWPEAK "dungeon_map:D_MN11"
+#define ITEM_CHECK_FAIRY_REWARD "fairy_reward:D_SB01"
+#define ITEM_CHECK_FISHING_BOTTLE "fishing_bottle"
+#define ITEM_CHECK_FISHING_HEART_PIECE "fishing_heart_piece"
+#define ITEM_CHECK_GOATS_REWARD "goats_reward"
+#define ITEM_CHECK_GORON_REWARD "goron_reward:F_SP113"
+#define ITEM_CHECK_GORON_SPRINGWATER_RUSH "goron_springwater_rush"
+#define ITEM_CHECK_ILIA_CHARM "ilia_charm"
+#define ITEM_CHECK_ILIA_MEMORY "ilia_memory"
+#define ITEM_CHECK_IZA_REWARD_1 "iza_reward_1"
+#define ITEM_CHECK_IZA_REWARD_2 "iza_reward_2"
+#define ITEM_CHECK_JOVANI_REWARD_1 "jovani_reward_1"
+#define ITEM_CHECK_JOVANI_REWARD_2 "jovani_reward_2"
+#define ITEM_CHECK_KEY_SHARD_1 "key_shard_1:D_MN04"
+#define ITEM_CHECK_KEY_SHARD_2 "key_shard_2:D_MN04"
+#define ITEM_CHECK_KEY_SHARD_3 "key_shard_3:D_MN04"
+#define ITEM_CHECK_ORDON_SHIELD "ordon_shield"
+#define ITEM_CHECK_ORDON_SWORD "ordon_sword"
+#define ITEM_CHECK_PLUMM_REWARD "plumm_minigame_reward"
+#define ITEM_CHECK_PRAYER_REWARD "prayer_reward"
+#define ITEM_CHECK_RENADO_LETTER "renado_letter"
+#define ITEM_CHECK_SERA_REWARD "sera_reward"
+#define ITEM_CHECK_SHAD_DOMINION_ROD "shad_dominion_rod"
+#define ITEM_CHECK_SKYBOOK "skybook"
+#define ITEM_CHECK_SNOWBOARD_REWARD "snowboard_race_reward"
+#define ITEM_CHECK_STAR_REWARD_1 "star_reward_1"
+#define ITEM_CHECK_STAR_REWARD_2 "star_reward_2"
+#define ITEM_CHECK_TELMA_INVOICE "telma_invoice"
+#define ITEM_CHECK_ULI_CRADLE_REWARD "uli_cradle_reward"
+#define ITEM_CHECK_WOOD_STATUE "wood_statue"
+#define ITEM_CHECK_ZORA_ARMOR "zora_armor"
+
+#define ITEM_CHECK_DUNGEON_REWARD_FOREST "dungeon_reward:D_MN05"
+#define ITEM_CHECK_DUNGEON_REWARD_GORON "dungeon_reward:D_MN04"
+#define ITEM_CHECK_DUNGEON_REWARD_LAKEBED "dungeon_reward:D_MN01"
+#define ITEM_CHECK_DUNGEON_REWARD_ARBITERS "dungeon_reward:D_MN10"
+#define ITEM_CHECK_DUNGEON_REWARD_SNOWPEAK "dungeon_reward:D_MN11"
+#define ITEM_CHECK_DUNGEON_REWARD_TIME "dungeon_reward:D_MN06"
+#define ITEM_CHECK_DUNGEON_REWARD_CITY "dungeon_reward:D_MN07"
+
+#define ITEM_CHECK_MASTER_SWORD "master_sword"
+#define ITEM_CHECK_SHADOW_CRYSTAL "shadow_crystal"
diff --git a/sdk/include/mods/meta.hpp b/sdk/include/mods/meta.hpp
new file mode 100644
index 0000000000..6028a3df9c
--- /dev/null
+++ b/sdk/include/mods/meta.hpp
@@ -0,0 +1,371 @@
+#pragma once
+
+#include <mods/api.h>
+
+#include <array>
+#include <cstddef>
+#include <cstring>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+/*
+ * modmeta records. Each IMPORT_SERVICE/EXPORT_SERVICE/DEFINE_HOOK use places one
+ * constant-initialized record object in the metadata section.
+ */
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define MOD_META_NO_ASAN
+#else
+#if defined(__has_attribute) && __has_attribute(no_sanitize)
+#define MOD_META_NO_ASAN __attribute__((no_sanitize("address")))
+#else
+#define MOD_META_NO_ASAN
+#endif
+#endif
+
+#if defined(_WIN32)
+#pragma section("modmeta$a", read, write)
+#pragma section("modmeta$d", read, write)
+#pragma section("modmeta$z", read, write)
+#if defined(__clang__)
+#define MOD_META_RECORD __declspec(allocate("modmeta$d")) __attribute__((used)) MOD_META_NO_ASAN
+#else
+#define MOD_META_RECORD __declspec(allocate("modmeta$d"))
+#endif
+#elif defined(__APPLE__)
+#define MOD_META_RECORD __attribute__((section("__DATA,__modmeta"), used)) MOD_META_NO_ASAN
+#elif defined(__has_attribute) && __has_attribute(retain)
+#define MOD_META_RECORD __attribute__((section("modmeta"), used, retain)) MOD_META_NO_ASAN
+#else
+#define MOD_META_RECORD __attribute__((section("modmeta"), used)) MOD_META_NO_ASAN
+#endif
+
+/* Section bounds for the mod_meta descriptor */
+#if defined(_WIN32)
+#define MOD_META_BOUNDS_DEFN                                                                       \
+    extern "C" {                                                                                   \
+    __declspec(allocate("modmeta$a")) constinit unsigned long long mod_meta_bounds_begin = 0;      \
+    __declspec(allocate("modmeta$z")) constinit unsigned long long mod_meta_bounds_end = 0;        \
+    }
+#define MOD_META_BOUNDS_BEGIN (&mod_meta_bounds_begin)
+#define MOD_META_BOUNDS_END (&mod_meta_bounds_end)
+#elif defined(__APPLE__)
+extern "C" const unsigned char mod_meta_bounds_begin[] __asm("section$start$__DATA$__modmeta");
+extern "C" const unsigned char mod_meta_bounds_end[] __asm("section$end$__DATA$__modmeta");
+#define MOD_META_BOUNDS_DEFN
+#define MOD_META_BOUNDS_BEGIN (mod_meta_bounds_begin)
+#define MOD_META_BOUNDS_END (mod_meta_bounds_end)
+#else
+extern "C" __attribute__((visibility("hidden"))) const unsigned char __start_modmeta[];
+extern "C" __attribute__((visibility("hidden"))) const unsigned char __stop_modmeta[];
+#define MOD_META_BOUNDS_DEFN
+#define MOD_META_BOUNDS_BEGIN (__start_modmeta)
+#define MOD_META_BOUNDS_END (__stop_modmeta)
+#endif
+
+namespace mods {
+
+/* A string usable as a template argument: carries a symbol/target name into record builders
+ * and makes each hook declaration's static state unique. */
+template <size_t N>
+struct FixedString {
+    char chars[N]{};
+    constexpr FixedString(const char (&s)[N]) noexcept {
+        for (size_t i = 0; i < N; ++i) {
+            chars[i] = s[i];
+        }
+    }
+};
+
+namespace detail {
+
+template <class T>
+constexpr std::string_view class_name() {
+#if defined(__clang__) || defined(__GNUC__)
+    // "... class_name() [T = daAlink_c]" / "... [with T = daAlink_c; ...]"
+    constexpr std::string_view fn = __PRETTY_FUNCTION__;
+    constexpr size_t start = fn.find("T = ") + 4;
+    return fn.substr(start, fn.find_first_of(";]", start) - start);
+#elif defined(_MSC_VER)
+    // "... class_name<class daAlink_c>(void)"
+    constexpr std::string_view fn = __FUNCSIG__;
+    constexpr size_t start = fn.find("class_name<") + 11;
+    constexpr std::string_view name = fn.substr(start, fn.rfind(">(") - start);
+    if constexpr (name.starts_with("class ")) {
+        return name.substr(6);
+    } else if constexpr (name.starts_with("struct ")) {
+        return name.substr(7);
+    } else {
+        return name;
+    }
+#else
+#error "unsupported compiler"
+#endif
+}
+
+/* The symbol name of C's vtable. Only unscoped, non-template class names are supported (an
+ * empty result makes hooks on virtual members of C fail resolution, which is reported). */
+template <class C>
+constexpr auto vtable_symbol() {
+    constexpr std::string_view name = class_name<C>();
+    constexpr bool simple = name.find_first_of(":<> ") == std::string_view::npos;
+    // "_ZTV" + decimal length + name / "??_7" + name + "@@6B@", NUL-terminated
+    std::array<char, name.size() + 12> out{};
+    if constexpr (!simple) {
+        return out;
+    }
+    size_t n = 0;
+#if defined(_WIN32)
+    for (char c : {'?', '?', '_', '7'}) {
+        out[n++] = c;
+    }
+    for (char c : name) {
+        out[n++] = c;
+    }
+    for (char c : {'@', '@', '6', 'B', '@'}) {
+        out[n++] = c;
+    }
+#else
+    for (char c : {'_', 'Z', 'T', 'V'}) {
+        out[n++] = c;
+    }
+    size_t len = name.size();
+    char digits[8]{};
+    size_t d = 0;
+    while (len != 0) {
+        digits[d++] = static_cast<char>('0' + len % 10);
+        len /= 10;
+    }
+    while (d != 0) {
+        out[n++] = digits[--d];
+    }
+    for (char c : name) {
+        out[n++] = c;
+    }
+#endif
+    return out;
+}
+
+template <class F>
+struct member_traits;
+template <class C, class R, class... A>
+struct member_traits<R (C::*)(A...)> {
+    using Class = C;
+};
+template <class C, class R, class... A>
+struct member_traits<R (C::*)(A...) const> {
+    using Class = C;
+};
+
+consteval ModMetaServiceId make_service_id(const char* id) {
+    ModMetaServiceId out{};
+    size_t n = 0;
+    for (; id[n] != '\0'; ++n) {
+        if (n + 1 >= MOD_META_SERVICE_ID_SIZE) {
+            throw "service id exceeds MOD_META_SERVICE_ID_SIZE";
+        }
+        out.chars[n] = id[n];
+    }
+    return out;
+}
+
+consteval ModMetaHeader make_header() {
+    ModMetaHeader r{};
+    r.rec = {sizeof(ModMetaHeader), MOD_META_HEADER, 0};
+    r.abi_version = MOD_ABI_VERSION;
+    return r;
+}
+
+/*
+ * Typed record variants: embedding the target as its native type makes the compiler emit the
+ * on-disk representation (relocations, PMF slot words) that static parsers read; the layouts
+ * match the byte-view structs in api.h.
+ */
+
+template <class F>
+struct HookFnRecord {
+    ModMetaRecord rec;
+    uint32_t reserved;
+    F target;
+    void* resolved;
+};
+
+template <class F, size_t N>
+struct HookMemRecord {
+    ModMetaRecord rec;
+    uint32_t reserved;
+    union {
+        F fn;
+        unsigned char raw[MOD_META_HOOK_MEM_CAPACITY];
+    } pmf;
+    void* resolved;
+    char names[N];
+};
+
+template <size_t N>
+struct HookMemExtRecord {
+    ModMetaRecord rec;
+    uint32_t pmfSize;
+    ModMetaHookMemMaterializeFn materialize;
+    void* resolved;
+    char names[N];
+};
+
+template <size_t N>
+struct HookNameRecord {
+    ModMetaRecord rec;
+    uint32_t reserved;
+    void* resolved;
+    char name[N];
+};
+
+template <size_t N>
+constexpr size_t align_up(size_t n) {
+    return (n + (N - 1)) & ~(N - 1);
+}
+
+template <size_t N>
+struct HookMemNames {
+    char chars[N]{};
+    size_t len{};
+};
+
+template <auto Target, FixedString Disp>
+consteval auto make_hook_mem_names() {
+    using C = member_traits<decltype(Target)>::Class;
+    // Strip the leading '&' of the stringified target expression for display.
+    constexpr size_t dispFrom = Disp.chars[0] == '&' ? 1 : 0;
+    constexpr size_t dispLen = sizeof(Disp.chars) - 1 - dispFrom;
+    constexpr auto vtbl = vtable_symbol<C>();
+    constexpr size_t vtblLen = std::string_view{vtbl.data()}.size();
+    HookMemNames<align_up<8>(vtblLen + 1 + dispLen + 1)> r{};
+    size_t at = 0;
+    for (size_t i = 0; i < vtblLen; ++i) {
+        r.chars[at++] = vtbl[i];
+    }
+    r.chars[at++] = '\0';
+    for (size_t i = 0; i < dispLen; ++i) {
+        r.chars[at++] = Disp.chars[dispFrom + i];
+    }
+    r.len = sizeof(r.chars);
+    return r;
+}
+
+#if defined(__GNUC__) && !defined(__clang__) && defined(__ELF__)
+/* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=41091 prevents inline static template members from
+ * sharing an explicit ELF section with ordinary variables. GCC can instead constant-evaluate a
+ * file-local record at each DEFINE_HOOK. */
+template <auto Target>
+void materialize_hook_mem(unsigned char* outPmf) {
+    const auto target = Target;
+    std::memcpy(outPmf, &target, sizeof(target));
+}
+
+template <auto Target, FixedString Disp>
+consteval auto make_local_hook_record() {
+    using F = decltype(Target);
+    if constexpr (std::is_member_function_pointer_v<F>) {
+        constexpr auto names = make_hook_mem_names<Target, Disp>();
+        static_assert(sizeof(F) <= MOD_META_HOOK_MEM_EXT_CAPACITY,
+            "unsupported pointer-to-member representation");
+        if constexpr (sizeof(F) > MOD_META_HOOK_MEM_CAPACITY) {
+            HookMemExtRecord<names.len> record = {
+                {sizeof(HookMemExtRecord<names.len>), MOD_META_HOOK_MEM_EXT, 0}, sizeof(F),
+                materialize_hook_mem<Target>, nullptr, {}};
+            for (size_t i = 0; i < names.len; ++i) {
+                record.names[i] = names.chars[i];
+            }
+            return record;
+        } else {
+            HookMemRecord<F, names.len> record = {
+                {sizeof(HookMemRecord<F, names.len>), MOD_META_HOOK_MEM, 0}, 0, {Target}, nullptr,
+                {}};
+            for (size_t i = 0; i < names.len; ++i) {
+                record.names[i] = names.chars[i];
+            }
+            return record;
+        }
+    } else {
+        static_assert(std::is_pointer_v<F> && std::is_function_v<std::remove_pointer_t<F>>,
+            "hook target must be a function or member function");
+        return HookFnRecord<F>{{sizeof(HookFnRecord<F>), MOD_META_HOOK_FN, 0}, 0, Target, nullptr};
+    }
+}
+#endif
+
+/*
+ * MSVC constant-evaluates a compact pointer-to-member only when every other operand in the
+ * initializer is a literal: no consteval calls, constexpr-object copies, or default member
+ * initializers. It cannot constant-initialize the 24-byte general representation at all, so the
+ * extended record points at a compiler-generated materializer while keeping the metadata itself
+ * constant-initialized for static tooling.
+ */
+template <auto Target, bool Extended, char... Cs>
+struct HookMemHolderImpl;
+
+template <auto Target, char... Cs>
+struct HookMemHolderImpl<Target, false, Cs...> {
+    using F = decltype(Target);
+    MOD_META_RECORD static constinit inline HookMemRecord<F, sizeof...(Cs)> record = {
+        {sizeof(HookMemRecord<F, sizeof...(Cs)>), MOD_META_HOOK_MEM, 0}, 0, {Target}, nullptr,
+        {Cs...}};
+};
+
+template <auto Target, char... Cs>
+struct HookMemHolderImpl<Target, true, Cs...> {
+    using F = decltype(Target);
+    static void materialize(unsigned char* outPmf) {
+        const F target = Target;
+        std::memcpy(outPmf, &target, sizeof(target));
+    }
+    MOD_META_RECORD static constinit inline HookMemExtRecord<sizeof...(Cs)> record = {
+        {sizeof(HookMemExtRecord<sizeof...(Cs)>), MOD_META_HOOK_MEM_EXT, 0}, sizeof(F), materialize,
+        nullptr, {Cs...}};
+};
+
+template <auto Target, char... Cs>
+struct HookMemHolder
+    : HookMemHolderImpl<Target, (sizeof(decltype(Target)) > MOD_META_HOOK_MEM_CAPACITY), Cs...> {
+    using F = decltype(Target);
+    static_assert(sizeof(F) <= MOD_META_HOOK_MEM_EXT_CAPACITY,
+        "unsupported pointer-to-member representation");
+};
+
+template <auto Target>
+struct HookFnHolder {
+    using F = decltype(Target);
+    static_assert(std::is_pointer_v<F> && std::is_function_v<std::remove_pointer_t<F>>,
+        "hook target must be a function or member function");
+    MOD_META_RECORD static constinit inline HookFnRecord<F> record = {
+        {sizeof(HookFnRecord<F>), MOD_META_HOOK_FN, 0}, 0, Target, nullptr};
+};
+
+template <auto Target, FixedString Disp, bool = std::is_member_function_pointer_v<decltype(Target)>>
+struct HookRecordFor {
+    using Holder = HookFnHolder<Target>;
+};
+
+template <auto Target, FixedString Disp>
+struct HookRecordFor<Target, Disp, true> {
+    template <class Seq>
+    struct Bind;
+    template <size_t... Is>
+    struct Bind<std::index_sequence<Is...>> {
+        using Type = HookMemHolder<Target, make_hook_mem_names<Target, Disp>().chars[Is]...>;
+    };
+    using Holder = Bind<std::make_index_sequence<make_hook_mem_names<Target, Disp>().len>>::Type;
+};
+
+template <FixedString Name>
+consteval auto make_hook_name_record() {
+    constexpr size_t len = sizeof(Name.chars) - 1;
+    HookNameRecord<align_up<8>(len + 1)> r{};
+    r.rec = {sizeof(r), MOD_META_HOOK_NAME, 0};
+    for (size_t i = 0; i < len; ++i) {
+        r.name[i] = Name.chars[i];
+    }
+    return r;
+}
+
+}  // namespace detail
+}  // namespace mods
diff --git a/sdk/include/mods/runtime.h b/sdk/include/mods/runtime.h
new file mode 100644
index 0000000000..25719e2eb9
--- /dev/null
+++ b/sdk/include/mods/runtime.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <mods/api.h>
+
+/*
+ * Lifecycle service for mods delegated to a runtime named by mod.json. The host passes the
+ * runtime's context as ctx and the delegated mod's context as subject.
+ */
+typedef struct ModRuntimeService {
+    ServiceHeader header;
+
+    ModResult (*activate)(ModContext* ctx, ModContext* subject, ModError* out_error);
+    ModResult (*update)(ModContext* ctx, ModContext* subject, ModError* out_error);
+    ModResult (*deactivate)(ModContext* ctx, ModContext* subject, ModError* out_error);
+} ModRuntimeService;
diff --git a/sdk/include/mods/service.hpp b/sdk/include/mods/service.hpp
new file mode 100644
index 0000000000..ed734ffc15
--- /dev/null
+++ b/sdk/include/mods/service.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <mods/api.h>
+#include <mods/meta.hpp>
+
+#include <cstdint>
+#include <cstdio>
+#include <type_traits>
+
+namespace mods {
+
+template <class Service>
+struct ServiceTraits;
+
+inline ModResult set_error(ModError* outError, ModResult code, const char* message) {
+    if (outError != nullptr && outError->struct_size >= sizeof(ModError)) {
+        outError->code = code;
+        outError->message[0] = '\0';
+        if (message != nullptr) {
+            std::snprintf(outError->message, sizeof(outError->message), "%s", message);
+        }
+    }
+    return code;
+}
+
+}  // namespace mods
+
+#define DEFINE_MOD()                                                                               \
+    extern "C" {                                                                                   \
+    MOD_EXPORT ModContext* mod_ctx = nullptr;                                                      \
+    }                                                                                              \
+    MOD_META_RECORD static constinit ModMetaHeader mod_meta_header_record =                        \
+        ::mods::detail::make_header();                                                             \
+    MOD_META_BOUNDS_DEFN                                                                           \
+    extern "C" {                                                                                   \
+    MOD_EXPORT constinit const ModMeta mod_meta = {                                                \
+        sizeof(ModMeta),                                                                           \
+        MOD_META_BOUNDS_BEGIN,                                                                     \
+        MOD_META_BOUNDS_END,                                                                       \
+    };                                                                                             \
+    }
+
+// Defines `const service_type* variable`, filled in by the host before mod_initialize.
+// Required imports are guaranteed non-null (the mod fails to load otherwise); optional imports
+// must be checked against nullptr before use. The unversioned macros use the latest minor version;
+// set an explicit version to target an older minor version for backwards compatibility.
+#define IMPORT_SERVICE_EX(                                                                         \
+    service_type, variable, service_id_value, major_value, min_minor_value, flags_value)           \
+    const service_type* variable = nullptr;                                                        \
+    MOD_META_RECORD static constinit ModMetaImport mod_meta_import_##variable = {                  \
+        {sizeof(ModMetaImport), MOD_META_IMPORT, static_cast<uint8_t>(flags_value)},               \
+        static_cast<uint16_t>(major_value),                                                        \
+        static_cast<uint16_t>(min_minor_value),                                                    \
+        &(variable),                                                                               \
+        ::mods::detail::make_service_id(service_id_value),                                         \
+    }
+
+#define IMPORT_SERVICE_VERSION(service_type, variable, min_minor_value)                            \
+    IMPORT_SERVICE_EX(service_type, variable, ::mods::ServiceTraits<service_type>::id,             \
+        ::mods::ServiceTraits<service_type>::major_version, min_minor_value,                       \
+        SERVICE_IMPORT_REQUIRED)
+
+#define IMPORT_SERVICE(service_type, variable)                                                     \
+    IMPORT_SERVICE_VERSION(                                                                        \
+        service_type, variable, ::mods::ServiceTraits<service_type>::minor_version)
+
+#define IMPORT_OPTIONAL_SERVICE_VERSION(service_type, variable, min_minor_value)                   \
+    IMPORT_SERVICE_EX(service_type, variable, ::mods::ServiceTraits<service_type>::id,             \
+        ::mods::ServiceTraits<service_type>::major_version, min_minor_value,                       \
+        SERVICE_IMPORT_OPTIONAL)
+
+#define IMPORT_OPTIONAL_SERVICE(service_type, variable)                                            \
+    IMPORT_OPTIONAL_SERVICE_VERSION(                                                               \
+        service_type, variable, ::mods::ServiceTraits<service_type>::minor_version)
+
+#define EXPORT_SERVICE_AS(instance, service_id_value)                                              \
+    MOD_META_RECORD static constinit ModMetaExport mod_meta_export_##instance = {                  \
+        {sizeof(ModMetaExport), MOD_META_EXPORT, SERVICE_EXPORT_STATIC},                           \
+        (instance).header.major_version,                                                           \
+        (instance).header.minor_version,                                                           \
+        &(instance),                                                                               \
+        ::mods::detail::make_service_id(service_id_value),                                         \
+    }
+
+#define EXPORT_SERVICE(instance)                                                                   \
+    EXPORT_SERVICE_AS(instance, ::mods::ServiceTraits<std::remove_cv_t<decltype(instance)>>::id)
+
+#define EXPORT_DEFERRED_SERVICE(token, service_id_value, major_value, minor_value)                 \
+    MOD_META_RECORD static constinit ModMetaExport mod_meta_export_##token = {                     \
+        {sizeof(ModMetaExport), MOD_META_EXPORT, SERVICE_EXPORT_DEFERRED},                         \
+        static_cast<uint16_t>(major_value),                                                        \
+        static_cast<uint16_t>(minor_value),                                                        \
+        nullptr,                                                                                   \
+        ::mods::detail::make_service_id(service_id_value),                                         \
+    }
diff --git a/sdk/include/mods/svc/actor.h b/sdk/include/mods/svc/actor.h
new file mode 100644
index 0000000000..0048b70332
--- /dev/null
+++ b/sdk/include/mods/svc/actor.h
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <mods/api.h>
+#include <mods/svc/config.h>
+
+#define ACTOR_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "actor"
+#define ACTOR_SERVICE_MAJOR 1u
+#define ACTOR_SERVICE_MINOR 0u
+
+typedef int16_t ProfileName;
+typedef uint32_t ActorId;
+typedef uint64_t ActorHandle;
+
+typedef struct {
+    const char name[8];  // Canonical stage name. Must be unique among active mod actors. Matching a
+                         // game actor name intentionally overrides stage lookup for that actor.
+
+    uint16_t priority_group; /* priorityGroup is the priority for when execute will be called on the
+    actor. Here are the main groups:
+    0: The room manager actor
+    1: Game scenes
+    2: Various room change actors
+    3: Most objects to be executed before Link
+    4: Some bosses, canoe, epona, spinner, chests
+    5: Link's actor
+    6: Boomerang, midna
+    7: Most objects, actors, bosses, triggers to be executed after link (most actors go here)
+    8: Various objects and enemies
+    9: Various actors
+    10: Timer, Scene Exit actor
+    11: Grass, Suspend Actors
+    */
+
+    size_t process_size;    // Size of the actor class (use sizeof(my_actor_class))
+    int16_t draw_priority;  // an enum value that is prefixed with fpcDwPi. Select an existing value
+                            // from the fpcDwPi to pick a draw priority matching the actor you wish
+                            // to match priorities with.
+    uint32_t status;    // Flags from fopAc_Status_e enum (all have fopAcStts_UNK_0x40000_e, a lot
+                        // have fopAcStts_UNK_0x4000_e, add fopAcStts_CULL_e to enable culling)
+    uint8_t group;      // The actor type. An enum value from fopAc_Group_e (fopAc_ACTOR_e,
+                        // fopAc_ENEMY_e, fopAc_NPC_e)
+    uint8_t cull_type;  // Enum value from fopAc_Cull_e
+    int (*create_function)(
+        void*);  // Called after the actor is spawned, return type is a enum value of cPhs_Step
+    int (*delete_function)(void*);     // Releases resources; returns 1 when deletion is complete
+    int (*execute_function)(void*);    // Called once per game tick, the actor's priorityGroup
+                                       // determines when it will run relative to other actors
+    int (*is_delete_function)(void*);  // Returns 1 when normal deletion may begin
+    int (*draw_function)(void*);       // Called to draw the actor
+} ActorProfileDesc;
+
+typedef struct {
+    uint32_t parameters;  // The parameters to be passed to the actor
+    int8_t argument;  // The argument to be passed to the actor (acts as an extra byte for a parameter)
+    int8_t room_num;  // The room to spawn the actor in
+    struct {
+        float x;
+        float y;
+        float z;
+    } position;
+    struct {
+        int16_t x;
+        int16_t y;
+        int16_t z;
+    } angle;
+    struct {
+        float x;
+        float y;
+        float z;
+    } scale;
+    int (*create_function)(void*);  // Optional: A custom function to run when the actor is created.
+} ActorSpawnParams;
+
+typedef struct ActorService {
+    ServiceHeader header;
+    ModResult (*register_actor)(ModContext* ctx, const ActorProfileDesc* desc,
+        ProfileName* outProfileName, ActorHandle* outActorHandle);
+    ModResult (*unregister_actor)(ModContext* ctx, ActorHandle handle);
+    ModResult (*create_actor_from_name)(
+        ModContext* ctx, const char* name, const ActorSpawnParams* params, ActorId* outId);
+    ModResult (*create_actor)(
+        ModContext* ctx, ProfileName name, const ActorSpawnParams* params, ActorId* outId);
+    ModResult (*create_child_actor_from_name)(ModContext* ctx, const char* name, ActorId parentID,
+        const ActorSpawnParams* params, ActorId* outId);
+    ModResult (*create_child_actor)(ModContext* ctx, ProfileName name, ActorId parentID,
+        const ActorSpawnParams* params, ActorId* outId);
+    ModResult (*get_actor_id)(ModContext* ctx, ProfileName name, ActorId* outId);
+    ModResult (*get_actor_room_num)(ModContext* ctx, ActorId actorId, int8_t* outRoomNum);
+    /* Returns MOD_UNAVAILABLE if the actor cannot be queued for deletion immediately. */
+    ModResult (*delete_actor)(ModContext* ctx, ActorId actorId);
+} ActorService;
+
+#ifdef __cplusplus
+#include "mods/service.hpp"
+
+template <>
+struct mods::ServiceTraits<ActorService> {
+    static constexpr const char* id = ACTOR_SERVICE_ID;
+    static constexpr uint16_t major_version = ACTOR_SERVICE_MAJOR;
+    static constexpr uint16_t minor_version = ACTOR_SERVICE_MINOR;
+};
+#endif
diff --git a/sdk/include/mods/svc/camera.h b/sdk/include/mods/svc/camera.h
new file mode 100644
index 0000000000..a901c2b739
--- /dev/null
+++ b/sdk/include/mods/svc/camera.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define CAMERA_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "camera"
+#define CAMERA_SERVICE_MAJOR 1u
+#define CAMERA_SERVICE_MINOR 1u
+
+/*
+ * Snapshot of a game camera for the frame currently being recorded.
+ *
+ * Matrix conventions: every matrix is a column-major float[16] using the matrix * column-vector
+ * convention, ready to memcpy into a WGSL mat4x4f uniform. NOTE: this is the TRANSPOSE of the
+ * game's row-major Mtx/Mtx44 layout; mods that want the raw game matrices should read the
+ * view_class directly instead.
+ *
+ * View space is right-handed with -Z forward. Projection matrices are in WebGPU clip convention
+ * and follow the renderer's depth mode: reversed-Z by default (depth 1.0 at the near plane,
+ * 0.0 at far).
+ *
+ * Unprojecting a depth-buffer texel at uv with sampled depth d:
+ *   let ndc = vec3f(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, d); // WebGPU framebuffer y is down
+ *   let world4 = world_from_proj * vec4f(ndc, 1.0);
+ *   let world = world4.xyz / world4.w;
+ */
+typedef struct CameraInfo {
+    uint32_t struct_size;
+
+    float view_from_world[16]; /* the view matrix */
+    float world_from_view[16]; /* its inverse; column 3 is the camera position */
+    float proj_from_view[16];  /* WebGPU-convention projection (+ Aurora reversed-Z) */
+    float view_from_proj[16];  /* its inverse */
+    float proj_from_world[16]; /* proj_from_view * view_from_world */
+    float world_from_proj[16]; /* one-step depth-buffer -> world unproject */
+
+    float eye[3]; /* camera position in world space */
+    float fovy;   /* vertical field of view, degrees */
+    float aspect;
+    float near_plane;
+    float far_plane;
+} CameraInfo;
+
+#define CAMERA_INFO_INIT {sizeof(CameraInfo)}
+
+/* 0 is never a valid handle. */
+typedef uint64_t CameraOperatorHandle;
+
+typedef struct CameraOperatorState {
+    uint32_t struct_size;
+
+    /* Host inputs. */
+    uint64_t frame_counter;
+    uint64_t ticks;
+    float aspect;
+
+    /* Initial camera state and callback output. */
+    float eye[3];
+    float center[3];
+    float fovy;
+    float bank_degrees;
+} CameraOperatorState;
+
+/* Return true to use state for the current frame. Game thread only. */
+typedef bool (*CameraOperateFn)(ModContext* ctx, CameraOperatorState* state, void* user_data);
+
+typedef struct CameraOperatorDesc {
+    uint32_t struct_size;
+    const char* debug_name;
+    int32_t priority;
+    CameraOperateFn operate;
+    void* user_data;
+} CameraOperatorDesc;
+
+#define CAMERA_OPERATOR_DESC_INIT {sizeof(CameraOperatorDesc), NULL, 0, NULL, NULL}
+
+typedef struct CameraService {
+    ServiceHeader header;
+
+    /*
+     * Snapshots a camera. game_view must be a view_class pointer, such as from a render stage
+     * callback's game view. Game thread only. Returns MOD_UNAVAILABLE when the view is not a valid
+     * perspective camera.
+     */
+    ModResult (*get_camera)(ModContext* ctx, const void* game_view, CameraInfo* out_info);
+
+    /* Minor version 1 */
+
+    /*
+     * Register an operator for the main camera. Operators run by descending priority, then
+     * registration order, until one returns true. debug_name and operate must be set; debug_name
+     * is copied. out_handle must not be NULL.
+     */
+    ModResult (*register_camera_operator)(
+        ModContext* ctx, const CameraOperatorDesc* desc, CameraOperatorHandle* out_handle);
+    ModResult (*unregister_camera_operator)(ModContext* ctx, CameraOperatorHandle handle);
+} CameraService;
+
+MOD_DECLARE_SERVICE(
+    CameraService, svc_camera, CAMERA_SERVICE_ID, CAMERA_SERVICE_MAJOR, CAMERA_SERVICE_MINOR);
diff --git a/include/mods/svc/config.h b/sdk/include/mods/svc/config.h
similarity index 93%
rename from include/mods/svc/config.h
rename to sdk/include/mods/svc/config.h
index 2a26210295..55a0bca131 100644
--- a/include/mods/svc/config.h
+++ b/sdk/include/mods/svc/config.h
@@ -1,8 +1,12 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
 
-#define CONFIG_SERVICE_ID "dev.twilitrealm.dusklight.config"
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define CONFIG_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "config"
 #define CONFIG_SERVICE_MAJOR 1u
 #define CONFIG_SERVICE_MINOR 0u
 
@@ -96,12 +100,5 @@ typedef struct ConfigService {
     ModResult (*unsubscribe)(ModContext* ctx, ConfigSubscriptionHandle handle);
 } ConfigService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<ConfigService> {
-    static constexpr const char* id = CONFIG_SERVICE_ID;
-    static constexpr uint16_t major_version = CONFIG_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(
+    ConfigService, svc_config, CONFIG_SERVICE_ID, CONFIG_SERVICE_MAJOR, CONFIG_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/file.h b/sdk/include/mods/svc/file.h
new file mode 100644
index 0000000000..0383c54066
--- /dev/null
+++ b/sdk/include/mods/svc/file.h
@@ -0,0 +1,118 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define FILE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "file"
+#define FILE_SERVICE_MAJOR 1u
+#define FILE_SERVICE_MINOR 0u
+
+typedef uint64_t FileStreamHandle;
+
+typedef enum FileOpenMode {
+    FILE_OPEN_READ = 0,
+    FILE_OPEN_TRUNCATE = 1,
+    FILE_OPEN_APPEND = 2,
+} FileOpenMode;
+
+typedef struct FileFilter {
+    const char* name;
+    /* Semicolon-separated extensions or "*". */
+    const char* pattern;
+} FileFilter;
+
+typedef struct FilePickOptions {
+    uint32_t struct_size;
+    const FileFilter* filters;
+    uint32_t filter_count;
+    /* Optional previously returned location. */
+    const char* default_location;
+} FilePickOptions;
+
+#define FILE_PICK_OPTIONS_INIT {sizeof(FilePickOptions), NULL, 0u, NULL}
+
+/* Locations and error are valid only for the duration of the callback. Canceled picks report
+ * MOD_UNAVAILABLE. The callback runs on the game thread. */
+typedef void (*FilePickFn)(ModContext* ctx, ModResult status, const char* const* locations,
+    uint32_t location_count, const char* error, void* user_data);
+
+typedef struct FileBuffer {
+    uint32_t struct_size;
+    void* data;
+    size_t size;
+} FileBuffer;
+
+#define FILE_BUFFER_INIT {sizeof(FileBuffer), NULL, 0u}
+
+typedef struct FileEntry {
+    const char* name;
+    const char* location;
+    bool is_directory;
+} FileEntry;
+
+/* Called once per entry, then once with entry == NULL. Entries are valid only for the duration of
+ * the callback. */
+typedef void (*FileListFn)(ModContext* ctx, const FileEntry* entry, void* user_data);
+
+/*
+ * Access to user-selected files and folders.
+ *
+ * A location is an opaque UTF-8 string returned by `pick_*`, `export_file`, `join`, `create_child`.
+ * Save it and pass it back to the service. Never parse it or manually append path segments.
+ *
+ * Android: Security grants are restored across launches. Only 512 (or 128 before API 30) grants are
+ * allowed at a time. If a grant cannot be retained or was revoked, `check`/`open` returns
+ * MOD_UNAVAILABLE so the user can select the location again.
+ *
+ * Calls other than picker completion are synchronous and must run on the game thread. Avoid file
+ * reads and folder traversal in per-frame callbacks.
+ */
+typedef struct FileService {
+    ServiceHeader header;
+
+    /* One native dialog is allowed at a time. Returns MOD_CONFLICT while one is outstanding. */
+    ModResult (*pick_file)(
+        ModContext* ctx, const FilePickOptions* options, FilePickFn fn, void* user_data);
+    ModResult (*pick_folder)(
+        ModContext* ctx, const FilePickOptions* options, FilePickFn fn, void* user_data);
+    /* Exports an existing file to a user-chosen destination. fn receives its final location. */
+    ModResult (*export_file)(ModContext* ctx, const char* source_location,
+        const char* suggested_name, FilePickFn fn, void* user_data);
+
+    ModResult (*display_name)(
+        ModContext* ctx, const char* location, char* buffer, uint32_t buffer_size);
+    /* MOD_OK, MOD_UNAVAILABLE when gone or inaccessible, or MOD_UNSUPPORTED. */
+    ModResult (*check)(ModContext* ctx, const char* location);
+
+    /* Write modes require an existing writable location and return MOD_UNSUPPORTED otherwise. */
+    ModResult (*open)(
+        ModContext* ctx, const char* location, FileOpenMode mode, FileStreamHandle* out_handle);
+    ModResult (*size)(ModContext* ctx, FileStreamHandle handle, uint64_t* out_size);
+    ModResult (*read)(ModContext* ctx, FileStreamHandle handle, void* buffer, uint64_t length,
+        uint64_t* out_read);
+    ModResult (*write)(
+        ModContext* ctx, FileStreamHandle handle, const void* buffer, uint64_t length);
+    ModResult (*seek)(ModContext* ctx, FileStreamHandle handle, uint64_t offset);
+    ModResult (*flush)(ModContext* ctx, FileStreamHandle handle);
+    /* Reports flush and close failures; writers must check the result. */
+    ModResult (*close)(ModContext* ctx, FileStreamHandle handle);
+
+    ModResult (*read_all)(ModContext* ctx, const char* location, FileBuffer* out_buffer);
+    /* Truncates and writes an existing location. This operation is not atomic. */
+    ModResult (*write_all)(ModContext* ctx, const char* location, const void* data, size_t size);
+    void (*free)(ModContext* ctx, FileBuffer* buffer);
+
+    ModResult (*list)(ModContext* ctx, const char* folder_location, FileListFn fn, void* user_data);
+    /* out_location remains valid until this mod's next `join` or `create_child` call. */
+    ModResult (*join)(ModContext* ctx, const char* folder_location, const char* relative_path,
+        const char** out_location);
+
+    /* Creates one file without replacing an existing child. */
+    ModResult (*create_child)(
+        ModContext* ctx, const char* folder_location, const char* name, const char** out_location);
+} FileService;
+
+MOD_DECLARE_SERVICE(FileService, svc_file, FILE_SERVICE_ID, FILE_SERVICE_MAJOR, FILE_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/file.hpp b/sdk/include/mods/svc/file.hpp
new file mode 100644
index 0000000000..e297000c2e
--- /dev/null
+++ b/sdk/include/mods/svc/file.hpp
@@ -0,0 +1,321 @@
+#pragma once
+
+#include <mods/svc/file.h>
+
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <span>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace mods::file {
+
+class File {
+public:
+    File() = default;
+    File(FileStreamHandle handle, ModResult result) : mHandle{handle}, mResult{result} {}
+    ~File() { reset(); }
+    File(const File&) = delete;
+    File& operator=(const File&) = delete;
+    File(File&& other) noexcept { *this = std::move(other); }
+    File& operator=(File&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+
+    explicit operator bool() const { return mResult == MOD_OK && mHandle != 0; }
+    ModResult result() const { return mResult; }
+    FileStreamHandle handle() const { return mHandle; }
+
+    uint64_t size() const {
+        uint64_t value = 0;
+        if (mHandle != 0 && svc_file != nullptr) {
+            svc_file->size(mod_ctx, mHandle, &value);
+        }
+        return value;
+    }
+
+    uint64_t read(void* buffer, uint64_t length) {
+        uint64_t value = 0;
+        if (mHandle == 0 || svc_file == nullptr) {
+            mResult = MOD_UNAVAILABLE;
+        } else {
+            mResult = svc_file->read(mod_ctx, mHandle, buffer, length, &value);
+        }
+        return value;
+    }
+
+    bool seek(uint64_t offset) {
+        mResult = mHandle != 0 && svc_file != nullptr ? svc_file->seek(mod_ctx, mHandle, offset) :
+                                                        MOD_UNAVAILABLE;
+        return mResult == MOD_OK;
+    }
+
+    bool write(const void* buffer, uint64_t length) {
+        if (mHandle == 0 || svc_file == nullptr) {
+            mResult = MOD_UNAVAILABLE;
+        } else {
+            mResult = svc_file->write(mod_ctx, mHandle, buffer, length);
+        }
+        return mResult == MOD_OK;
+    }
+
+    bool write(std::span<const uint8_t> bytes) { return write(bytes.data(), bytes.size()); }
+
+    bool flush() {
+        if (mHandle == 0 || svc_file == nullptr) {
+            mResult = MOD_UNAVAILABLE;
+        } else {
+            mResult = svc_file->flush(mod_ctx, mHandle);
+        }
+        return mResult == MOD_OK;
+    }
+
+    bool close() {
+        if (mHandle == 0) {
+            return mResult == MOD_OK;
+        }
+        mResult = svc_file != nullptr ? svc_file->close(mod_ctx, mHandle) : MOD_UNAVAILABLE;
+        mHandle = 0;
+        return mResult == MOD_OK;
+    }
+
+    void reset() { (void)close(); }
+
+private:
+    FileStreamHandle mHandle = 0;
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline File open(const std::string& location, FileOpenMode mode = FILE_OPEN_READ) {
+    if (svc_file == nullptr) {
+        return {0, MOD_UNAVAILABLE};
+    }
+    FileStreamHandle handle = 0;
+    const auto result = svc_file->open(mod_ctx, location.c_str(), mode, &handle);
+    return {handle, result};
+}
+
+class Buffer {
+public:
+    Buffer() = default;
+    Buffer(FileBuffer buffer, ModResult result) : mBuffer{buffer}, mResult{result} {}
+    ~Buffer() { reset(); }
+    Buffer(const Buffer&) = delete;
+    Buffer& operator=(const Buffer&) = delete;
+    Buffer(Buffer&& other) noexcept { *this = std::move(other); }
+    Buffer& operator=(Buffer&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mBuffer = other.mBuffer;
+            mResult = other.mResult;
+            other.mBuffer = FILE_BUFFER_INIT;
+        }
+        return *this;
+    }
+
+    explicit operator bool() const { return mResult == MOD_OK; }
+    ModResult result() const { return mResult; }
+    std::span<const uint8_t> bytes() const {
+        return {static_cast<const uint8_t*>(mBuffer.data), mBuffer.size};
+    }
+    void reset() {
+        if (mBuffer.data != nullptr && svc_file != nullptr) {
+            svc_file->free(mod_ctx, &mBuffer);
+        }
+        mBuffer.data = nullptr;
+        mBuffer.size = 0;
+    }
+
+private:
+    FileBuffer mBuffer = FILE_BUFFER_INIT;
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline Buffer read_all(const std::string& location) {
+    FileBuffer buffer = FILE_BUFFER_INIT;
+    const auto result = svc_file != nullptr ?
+                            svc_file->read_all(mod_ctx, location.c_str(), &buffer) :
+                            MOD_UNAVAILABLE;
+    return {buffer, result};
+}
+
+inline ModResult check(const std::string& location) {
+    return svc_file != nullptr ? svc_file->check(mod_ctx, location.c_str()) : MOD_UNAVAILABLE;
+}
+
+inline std::string display_name(const std::string& location) {
+    if (svc_file == nullptr) {
+        return {};
+    }
+    std::array<char, 1024> buffer{};
+    return svc_file->display_name(mod_ctx, location.c_str(), buffer.data(),
+               static_cast<uint32_t>(buffer.size())) == MOD_OK ?
+               std::string{buffer.data()} :
+               std::string{};
+}
+
+inline ModResult join(
+    const std::string& folder, const std::string& relativePath, std::string& outLocation) {
+    outLocation.clear();
+    if (svc_file == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    const char* location = nullptr;
+    const auto result = svc_file->join(mod_ctx, folder.c_str(), relativePath.c_str(), &location);
+    if (result == MOD_OK && location != nullptr) {
+        outLocation = location;
+    }
+    return result;
+}
+
+inline ModResult create_child(
+    const std::string& folder, const std::string& name, std::string& outLocation) {
+    outLocation.clear();
+    if (svc_file == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    const char* location = nullptr;
+    const auto result = svc_file->create_child(mod_ctx, folder.c_str(), name.c_str(), &location);
+    if (result == MOD_OK && location != nullptr) {
+        outLocation = location;
+    }
+    return result;
+}
+
+inline ModResult write_all(const std::string& location, std::span<const uint8_t> bytes) {
+    if (svc_file == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    return svc_file->write_all(mod_ctx, location.c_str(), bytes.data(), bytes.size());
+}
+
+struct Entry {
+    std::string name;
+    std::string location;
+    bool isDirectory = false;
+};
+
+inline ModResult list(const std::string& folder, std::vector<Entry>& outEntries) {
+    outEntries.clear();
+    if (svc_file == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    return svc_file->list(
+        mod_ctx, folder.c_str(),
+        [](ModContext*, const FileEntry* entry, void* userData) {
+            if (entry == nullptr) {
+                return;
+            }
+            static_cast<std::vector<Entry>*>(userData)->push_back({
+                .name = entry->name != nullptr ? entry->name : "",
+                .location = entry->location != nullptr ? entry->location : "",
+                .isDirectory = entry->is_directory,
+            });
+        },
+        &outEntries);
+}
+
+struct Filter {
+    std::string name;
+    std::string pattern;
+};
+
+struct PickOptions {
+    std::vector<Filter> filters;
+    std::string defaultLocation;
+};
+
+struct PickResult {
+    ModResult status = MOD_ERROR;
+    std::vector<std::string> locations;
+    std::string error;
+};
+
+namespace detail {
+
+inline std::function<void(PickResult)> pickCallback;
+
+inline void pick_trampoline(ModContext*, ModResult status, const char* const* locations,
+    uint32_t locationCount, const char* error, void*) {
+    PickResult result{.status = status, .error = error != nullptr ? error : ""};
+    result.locations.reserve(locationCount);
+    for (uint32_t i = 0; i < locationCount; ++i) {
+        if (locations[i] != nullptr) {
+            result.locations.emplace_back(locations[i]);
+        }
+    }
+    auto callback = std::move(pickCallback);
+    pickCallback = {};
+    if (callback) {
+        callback(std::move(result));
+    }
+}
+
+inline ModResult pick(
+    const PickOptions& options, std::function<void(PickResult)> callback, bool folder) {
+    if (svc_file == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    if (!callback) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (pickCallback) {
+        return MOD_CONFLICT;
+    }
+    std::vector<FileFilter> filters;
+    filters.reserve(options.filters.size());
+    for (const auto& filter : options.filters) {
+        filters.push_back({filter.name.c_str(), filter.pattern.c_str()});
+    }
+    FilePickOptions raw = FILE_PICK_OPTIONS_INIT;
+    raw.filters = filters.empty() ? nullptr : filters.data();
+    raw.filter_count = static_cast<uint32_t>(filters.size());
+    raw.default_location =
+        options.defaultLocation.empty() ? nullptr : options.defaultLocation.c_str();
+    pickCallback = std::move(callback);
+    const auto result = folder ? svc_file->pick_folder(mod_ctx, &raw, pick_trampoline, nullptr) :
+                                 svc_file->pick_file(mod_ctx, &raw, pick_trampoline, nullptr);
+    if (result != MOD_OK) {
+        pickCallback = {};
+    }
+    return result;
+}
+
+}  // namespace detail
+
+inline ModResult pick_file(const PickOptions& options, std::function<void(PickResult)> callback) {
+    return detail::pick(options, std::move(callback), false);
+}
+
+inline ModResult pick_folder(const PickOptions& options, std::function<void(PickResult)> callback) {
+    return detail::pick(options, std::move(callback), true);
+}
+
+inline ModResult export_file(const std::string& sourceLocation, const std::string& suggestedName,
+    std::function<void(PickResult)> callback) {
+    if (svc_file == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    if (!callback) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (detail::pickCallback) {
+        return MOD_CONFLICT;
+    }
+    detail::pickCallback = std::move(callback);
+    const auto result = svc_file->export_file(
+        mod_ctx, sourceLocation.c_str(), suggestedName.c_str(), detail::pick_trampoline, nullptr);
+    if (result != MOD_OK) {
+        detail::pickCallback = {};
+    }
+    return result;
+}
+
+}  // namespace mods::file
diff --git a/sdk/include/mods/svc/flow.h b/sdk/include/mods/svc/flow.h
new file mode 100644
index 0000000000..1099d86fd9
--- /dev/null
+++ b/sdk/include/mods/svc/flow.h
@@ -0,0 +1,182 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define FLOW_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "flow"
+#define FLOW_SERVICE_MAJOR 1u
+#define FLOW_SERVICE_MINOR 0u
+
+typedef uint64_t FlowGraphHandle;
+typedef uint16_t FlowQueryId;
+typedef uint8_t FlowEventId;
+
+/* FLW1 node data */
+typedef struct FlowNodeData {
+    uint8_t bytes[8];
+} FlowNodeData;
+static_assert(sizeof(FlowNodeData) == 8);
+
+/* Built-in branch queries. The result selects the edge slot next_node_index + result;
+ * [param] is the branch node's 16-bit parameter. */
+typedef enum FlowGameQuery {
+    FLOW_QUERY_SELECT_2 = 0,            /* two-way selection result: 0 first, 1 second */
+    FLOW_QUERY_EVENT_FLAG = 1,          /* 0 if event flag [param] is set */
+    FLOW_QUERY_PLAYER_FORM = 2,         /* 0 human, 1 wolf, 2 riding */
+    FLOW_QUERY_RANDOM = 3,              /* random result in [0, param) */
+    FLOW_QUERY_SELECT_3 = 4,            /* three-way selection result: 0/1/2 */
+    FLOW_QUERY_TALK_DISTANCE = 5,       /* player within talk range; param overrides max distance */
+    FLOW_QUERY_RUPEES = 6,              /* 0 if rupees >= param; param 0 checks wallet max */
+    FLOW_QUERY_SWORD_TUTORIAL_STEP = 7, /* 0 if the scarecrow tutorial step matches param */
+    FLOW_QUERY_SWORD_TUTORIAL_RESULT = 8, /* 0 on tutorial success */
+    FLOW_QUERY_SWORD_TUTORIAL_COUNT = 9,  /* 0 if first success */
+    FLOW_QUERY_TEMP_FLAG = 10,            /* 0 if temporary event flag [param] is set */
+    FLOW_QUERY_CHEST_FLAG = 11,           /* 0 if treasure chest flag [param] is set */
+    FLOW_QUERY_SAVE_SWITCH = 12,          /* 0 if save switch [param] is set */
+    FLOW_QUERY_SAVE_ITEM_FLAG = 13,
+    FLOW_QUERY_DUNGEON_SWITCH = 14,
+    FLOW_QUERY_DUNGEON_ITEM_FLAG = 15,
+    FLOW_QUERY_ZONE_SWITCH = 16,
+    FLOW_QUERY_ZONE_ITEM_FLAG = 17,
+    FLOW_QUERY_ONE_ZONE_SWITCH = 18,
+    FLOW_QUERY_ONE_ZONE_ITEM_FLAG = 19,
+    FLOW_QUERY_EQUIPPED = 20,       /* 1 if item [param] is equipped or on an item slot */
+    FLOW_QUERY_ITEM_OWNED = 21,     /* 0 if item [param] is owned */
+    FLOW_QUERY_BOMB_BAG_COUNT = 22, /* number of bomb bags owned: 0-3 */
+    FLOW_QUERY_ARROWS = 23,         /* 0 if arrows >= param */
+    FLOW_QUERY_EMPTY_BOTTLES = 24,  /* 0 if empty bottles >= param */
+    FLOW_QUERY_SHOP_CLERK = 25,     /* shop system conversation flag */
+    FLOW_QUERY_TEARS_OF_LIGHT = 26, /* 0 if tears >= param; param 0 uses the required count */
+    /* 0 if goat-herding time <= param seconds; publishes the time for display */
+    FLOW_QUERY_HERDING_TIME = 27,
+    FLOW_QUERY_LANTERN_OIL = 28,       /* 0 full, 1 partial, 2 empty */
+    FLOW_QUERY_REGISTER = 29,          /* flow scratch register value */
+    FLOW_QUERY_GOATS_CAUGHT = 30,      /* 0 if caught runaway goats >= param */
+    FLOW_QUERY_HEARTS = 31,            /* 0 if life >= param */
+    FLOW_QUERY_HOLDING_LANTERN = 32,   /* 0 if the player has the lantern out */
+    FLOW_QUERY_TIME_OF_DAY = 33,       /* current hour of game time (0-23) */
+    FLOW_QUERY_MAGIC = 34,             /* 0 if magic >= param */
+    FLOW_QUERY_SELECT_2_CANCEL = 35,   /* 0/1 choice, 2 on B cancel */
+    FLOW_QUERY_SELECT_3_CANCEL = 36,   /* 0/1/2 choice, 3 on B cancel */
+    FLOW_QUERY_BOMB_BAG_CONTENTS = 37, /* 0 empty, 1 bombs, 2 water bombs, 3 bomblings */
+    FLOW_QUERY_BOMBS_FIT = 38,         /* 1 if param more bombs fit in the bag, 0 if over max */
+    FLOW_QUERY_BOMB_BAG_FILL = 39,     /* 0 empty, 1 partial, 2 full */
+    FLOW_QUERY_WATER_BOMBS_FIT = 40,
+    /* 0 clear, 1 NPC near, 2 NPC far, 3 environment, 4 Sacred Grove */
+    FLOW_QUERY_TRANSFORM_BLOCKED = 41,
+    FLOW_QUERY_BOMBLINGS_FIT = 42,
+    FLOW_QUERY_WARP_ALLOWED = 43,    /* 0 if a dungeon warp is accepted here */
+    FLOW_QUERY_GOLDEN_BUGS = 44,     /* 0 none, 1 1-11, 2 12-22, 3 23, 4 all 24 */
+    FLOW_QUERY_UNDELIVERED_BUG = 45, /* 1 if carrying a golden bug not yet delivered to Agitha */
+    FLOW_QUERY_UNUSED_46 = 46,       /* asserts; do not use */
+    FLOW_QUERY_NEW_LETTERS = 47,     /* 0 none, 1 one (& stores its name for the tag), 2 more */
+    FLOW_QUERY_POE_SOULS = 48,       /* 0 none, 1 <20, 2 <40, 3 <60, 4 60+ */
+    FLOW_QUERY_DONATION_TOTAL = 49,  /* 0 if donations >= param */
+    FLOW_QUERY_BALLOON_SCORE = 50,   /* 0 zero, 1 <1000, 2 <10000, 3 <61454, 4 max */
+    FLOW_QUERY_IN_WATER = 51,        /* 1 if the player is swimming */
+    FLOW_QUERY_IRON_BOOTS = 52,      /* 1 if iron boots are equipped */
+    FLOW_QUERY_BUILTIN_COUNT,
+} FlowGameQuery;
+
+/* Built-in event actions. Params (big-endian): one u32, two u16 (p0, p1), or four u8. */
+typedef enum FlowGameEvent {
+    FLOW_EVENT_SET_EVENT_FLAG = 0, /* sets event flags [p0] and [p1]; 0 = none */
+    FLOW_EVENT_CLEAR_EVENT_FLAG = 1,
+    FLOW_EVENT_ADD_RUPEES = 2,
+    FLOW_EVENT_REMOVE_RUPEES = 3,
+    FLOW_EVENT_ADD_HEARTS = 4,
+    FLOW_EVENT_REMOVE_HEARTS = 5,
+    FLOW_EVENT_ADD_MAGIC = 6,
+    FLOW_EVENT_REMOVE_MAGIC = 7,
+    FLOW_EVENT_START_EVENT = 8, /* publish (p0 event id, p1 item id) for the speaker to poll */
+    FLOW_EVENT_JUMP_FLOW = 9,   /* continue at flow [p]; 0 jumps to the stage/Midna flow */
+    FLOW_EVENT_SET_TEMP_FLAG = 10,
+    FLOW_EVENT_CLEAR_TEMP_FLAG = 11,
+    FLOW_EVENT_OPEN_DOOR = 12,       /* marks the flow as a door unlock path (probe only) */
+    FLOW_EVENT_SELECT_VERTICAL = 13, /* vertical selection; p = result index chosen on B cancel */
+    FLOW_EVENT_SET_SWITCH = 14,      /* p0 scope: 0 save, 1 dungeon, 2 zone, 3 one-zone; p1 bit */
+    FLOW_EVENT_CLEAR_SWITCH = 15,
+    FLOW_EVENT_SHOP_SELECT = 16, /* start shop item selection; four u8 shop params */
+    FLOW_EVENT_GIVE_ITEM = 17,   /* p0 item number, p1 count */
+    /* four u8 direction values for the speaker; p3 plays a sound */
+    FLOW_EVENT_STAGE_DIRECTION = 18,
+    FLOW_EVENT_SET_SPEAKER = 19,  /* point the box at talk partner [p1] */
+    FLOW_EVENT_WARP_PLAYER = 20,  /* move the player to the room spawn tagged [p] */
+    FLOW_EVENT_WAIT = 21,         /* close the box and wait [p] frames */
+    FLOW_EVENT_FILL_LANTERN = 22, /* refill oil to [p] percent; 0 = full */
+    /* p: 1-3 red/green/blue potion, 4 milk, 5 half milk, 6 oil, 7 hot spring water */
+    FLOW_EVENT_FILL_BOTTLE = 23,
+    FLOW_EVENT_SHOP_SOLD_OUT = 24,
+    FLOW_EVENT_SET_REGISTER = 25,  /* set the flow scratch register (see FLOW_QUERY_REGISTER) */
+    FLOW_EVENT_TENT_PURCHASE = 26, /* unattended stand purchase; marks the item sold out */
+    FLOW_EVENT_FILL_BOMBS = 27,    /* u8 p0 bag select, u8 p1 operation; u16 p1 count */
+    FLOW_EVENT_SELL_BOMBS = 28,    /* empty the selected bag and pay out */
+    /* horizontal selection; p = result index chosen on B cancel */
+    FLOW_EVENT_SELECT_HORIZONTAL = 29,
+    FLOW_EVENT_FILL_ARROWS = 30, /* p1 count, 0 = max; p0 nonzero defers the refill */
+    FLOW_EVENT_RETURN_RENTAL_BOMB_BAG = 31,
+    FLOW_EVENT_FADE_IN = 32, /* p0: 0 black, 1 white; p1 frames */
+    FLOW_EVENT_FADE_OUT = 33,
+    FLOW_EVENT_SET_TRADE_ITEM = 34, /* set the trade-quest item */
+    FLOW_EVENT_REMOVE_ITEM = 35,
+    FLOW_EVENT_SET_SAVE_SWITCH = 36, /* set save switch (p0 area, p1 bit) */
+    FLOW_EVENT_CLEAR_SAVE_SWITCH = 37,
+    FLOW_EVENT_RECEIVE_LETTER = 38,
+    FLOW_EVENT_UNLOCK_MAP_REGION = 39,
+    FLOW_EVENT_EMPTY_BOTTLE = 40, /* p as in FLOW_EVENT_FILL_BOTTLE */
+    FLOW_EVENT_ADD_DONATION = 41,
+    FLOW_EVENT_UNUSED_42 = 42, /* no-op */
+    FLOW_EVENT_BUILTIN_COUNT,
+} FlowGameEvent;
+
+typedef enum FlowQueryPhase {
+    FLOW_QUERY_PHASE_PROBE = 0,
+    FLOW_QUERY_PHASE_EXECUTE = 1,
+} FlowQueryPhase;
+
+typedef struct FlowQueryContext {
+    const void* speaker_actor;
+    uint16_t parameter;
+    uint8_t result_count;
+    uint8_t phase; /* FlowQueryPhase */
+} FlowQueryContext;
+
+typedef uint16_t (*FlowQueryFn)(ModContext* ctx, const FlowQueryContext* query, void* user_data);
+
+typedef struct FlowEventContext {
+    const void* speaker_actor;
+    uint8_t parameters[4];
+} FlowEventContext;
+
+typedef void (*FlowEventFn)(ModContext* ctx, const FlowEventContext* event, void* user_data);
+
+typedef struct FlowService {
+    ServiceHeader header;
+
+    ModResult (*begin_graph)(ModContext* ctx, uint16_t group, FlowGraphHandle* out_handle);
+    /* Allocates one node ID. Fill it with fill_node before commit_graph. */
+    ModResult (*allocate_node)(ModContext* ctx, FlowGraphHandle handle, uint16_t* out_id);
+    /* Adds a series of edges with the given targets. */
+    ModResult (*add_edges)(ModContext* ctx, FlowGraphHandle handle, const uint16_t* targets,
+        uint16_t count, uint16_t* out_first);
+    /* May be called again to replace a node until commit_graph. */
+    ModResult (*fill_node)(
+        ModContext* ctx, FlowGraphHandle handle, uint16_t node_index, const FlowNodeData* node);
+    /* Replace a native node or edge when the graph commits; reverted when it is removed. */
+    ModResult (*patch_node)(
+        ModContext* ctx, FlowGraphHandle handle, uint16_t node_index, const FlowNodeData* node);
+    ModResult (*patch_edge)(
+        ModContext* ctx, FlowGraphHandle handle, uint16_t edge_index, uint16_t target_node);
+    ModResult (*commit_graph)(ModContext* ctx, FlowGraphHandle handle);
+    ModResult (*remove_graph)(ModContext* ctx, FlowGraphHandle handle);
+
+    ModResult (*register_query)(ModContext* ctx, const char* debug_name, FlowQueryFn fn,
+        void* user_data, FlowQueryId* out_id);
+    ModResult (*register_event)(ModContext* ctx, const char* debug_name, FlowEventFn fn,
+        void* user_data, FlowEventId* out_id);
+} FlowService;
+
+MOD_DECLARE_SERVICE(FlowService, svc_flow, FLOW_SERVICE_ID, FLOW_SERVICE_MAJOR, FLOW_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/flow.hpp b/sdk/include/mods/svc/flow.hpp
new file mode 100644
index 0000000000..c7671f69a6
--- /dev/null
+++ b/sdk/include/mods/svc/flow.hpp
@@ -0,0 +1,687 @@
+#pragma once
+
+#include <mods/bits.hpp>
+#include <mods/svc/flow.h>
+#include <mods/svc/message.h>
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+#include <span>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace mods::flow {
+
+static_assert(sizeof(FlowNodeData) == 8);
+static_assert(sizeof(MessageEntryData) == 20);
+
+inline constexpr uint16_t kCustomNodeMin = 0x8000;
+inline constexpr uint16_t kCustomEdgeMin = 0x8000;
+inline constexpr uint16_t kCustomMessageMin = 0x8000;
+inline constexpr uint16_t kEnd = 0xffff;
+
+/* entryIndex is the INF1 entry index, not the message ID stored inside the entry.
+ * For custom messages the entry index equals the MessageId. */
+constexpr FlowNodeData message(
+    uint8_t subtype, uint16_t entryIndex, uint16_t nextNode, uint16_t unknown = 0) {
+    FlowNodeData node{};
+    node.bytes[0] = 1;
+    node.bytes[1] = subtype;
+    write_bits(node.bytes + 2, entryIndex);
+    write_bits(node.bytes + 4, nextNode);
+    write_bits(node.bytes + 6, unknown);
+    return node;
+}
+
+constexpr FlowNodeData branch(
+    uint8_t resultCount, FlowQueryId query, uint16_t parameter, uint16_t firstEdge) {
+    FlowNodeData node{};
+    node.bytes[0] = 2;
+    node.bytes[1] = resultCount;
+    write_bits(node.bytes + 2, query);
+    write_bits(node.bytes + 4, parameter);
+    write_bits(node.bytes + 6, firstEdge);
+    return node;
+}
+
+constexpr FlowNodeData event(FlowEventId eventId, uint16_t edge, std::array<uint8_t, 4> params) {
+    FlowNodeData node{};
+    node.bytes[0] = 3;
+    node.bytes[1] = eventId;
+    write_bits(node.bytes + 2, edge);
+    for (size_t i = 0; i < params.size(); ++i) {
+        node.bytes[4 + i] = params[i];
+    }
+    return node;
+}
+
+class Graph {
+public:
+    Graph() = default;
+    Graph(FlowGraphHandle handle, ModResult result) : mHandle{handle}, mResult{result} {}
+    Graph(const Graph&) = delete;
+    Graph& operator=(const Graph&) = delete;
+    Graph(Graph&& other) noexcept { *this = std::move(other); }
+    Graph& operator=(Graph&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+    ~Graph() { reset(); }
+
+    explicit operator bool() const { return mResult == MOD_OK; }
+    ModResult result() const { return mResult; }
+    FlowGraphHandle handle() const { return mHandle; }
+    void reset() {
+        if (mHandle != 0 && svc_flow != nullptr) {
+            svc_flow->remove_graph(mod_ctx, mHandle);
+            mHandle = 0;
+        }
+    }
+
+private:
+    FlowGraphHandle mHandle{};
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+class GraphBuilder;
+
+class NodeRef {
+public:
+    NodeRef() = default;
+
+    /* Set the successor of a message or event node: a node ID or kEnd */
+    NodeRef next(uint16_t target) const;
+    /* Set a branch node's result targets */
+    NodeRef results(std::initializer_list<uint16_t> targets) const;
+    NodeRef results(std::span<const uint16_t> targets) const;
+
+    uint16_t id() const { return mId; }
+    operator uint16_t() const { return mId; }
+
+private:
+    friend class GraphBuilder;
+    NodeRef(GraphBuilder* builder, uint16_t id) : mBuilder{builder}, mId{id} {}
+
+    GraphBuilder* mBuilder = nullptr;
+    uint16_t mId = 0;
+};
+
+class GraphBuilder {
+public:
+    explicit GraphBuilder(uint16_t group) {
+        if (svc_flow == nullptr) {
+            mResult = MOD_UNAVAILABLE;
+            return;
+        }
+        mResult = svc_flow->begin_graph(mod_ctx, group, &mHandle);
+    }
+    GraphBuilder(const GraphBuilder&) = delete;
+    GraphBuilder& operator=(const GraphBuilder&) = delete;
+    ~GraphBuilder() {
+        if (mHandle != 0 && svc_flow != nullptr) {
+            svc_flow->remove_graph(mod_ctx, mHandle);
+        }
+    }
+
+    /* entryIndex is an INF1 entry index for native messages, or a registered MessageId */
+    NodeRef add_message(uint16_t entryIndex, uint8_t subtype = 0) {
+        return append(message(subtype, entryIndex, 0), true);
+    }
+    NodeRef add_branch(FlowQueryId query, uint16_t parameter) {
+        return append(branch(0, query, parameter, 0), true);
+    }
+    NodeRef add_event(FlowEventId eventId, std::array<uint8_t, 4> params) {
+        return append(event(eventId, 0, params), true);
+    }
+    NodeRef add_node(const FlowNodeData& node) { return append(node, false); }
+
+    GraphBuilder& patch_node(uint16_t nodeIndex, const FlowNodeData& node) {
+        if (mResult == MOD_OK) {
+            mResult = svc_flow->patch_node(mod_ctx, mHandle, nodeIndex, &node);
+        }
+        return *this;
+    }
+    GraphBuilder& patch_edge(uint16_t edgeIndex, uint16_t targetNode) {
+        if (mResult == MOD_OK) {
+            mResult = svc_flow->patch_edge(mod_ctx, mHandle, edgeIndex, targetNode);
+        }
+        return *this;
+    }
+    GraphBuilder& patch_branch(uint16_t nodeIndex, FlowQueryId query, uint16_t parameter,
+        std::span<const uint16_t> targets) {
+        if (mResult != MOD_OK || targets.empty() || targets.size() > 0xff) {
+            if (mResult == MOD_OK) {
+                mResult = MOD_INVALID_ARGUMENT;
+            }
+            return *this;
+        }
+        uint16_t first = 0;
+        mResult = svc_flow->add_edges(
+            mod_ctx, mHandle, targets.data(), static_cast<uint16_t>(targets.size()), &first);
+        if (mResult == MOD_OK) {
+            patch_node(nodeIndex,
+                branch(static_cast<uint8_t>(targets.size()), query, parameter, first));
+        }
+        return *this;
+    }
+    GraphBuilder& patch_event(uint16_t nodeIndex, FlowEventId eventId,
+        std::array<uint8_t, 4> params, uint16_t target) {
+        if (mResult != MOD_OK) {
+            return *this;
+        }
+        uint16_t edge = 0;
+        mResult = svc_flow->add_edges(mod_ctx, mHandle, &target, 1, &edge);
+        if (mResult == MOD_OK) {
+            patch_node(nodeIndex, event(eventId, edge, params));
+        }
+        return *this;
+    }
+
+    Graph commit() {
+        for (const auto& node : mNodes) {
+            if (node.typed && !node.wired) {
+                mResult = MOD_INVALID_ARGUMENT;
+            }
+        }
+        for (const auto& node : mNodes) {
+            if (mResult != MOD_OK) {
+                break;
+            }
+            mResult = svc_flow->fill_node(mod_ctx, mHandle, node.id, &node.data);
+        }
+        if (mResult == MOD_OK) {
+            mResult = svc_flow->commit_graph(mod_ctx, mHandle);
+        }
+        if (mResult != MOD_OK) {
+            return {0, mResult};  // the builder destructor removes the graph
+        }
+        return {std::exchange(mHandle, 0), MOD_OK};
+    }
+
+private:
+    friend class NodeRef;
+
+    struct BuilderNode {
+        uint16_t id;
+        FlowNodeData data;
+        bool typed;
+        bool wired;
+    };
+
+    NodeRef append(const FlowNodeData& node, bool typed) {
+        uint16_t id = 0;
+        if (mResult == MOD_OK) {
+            mResult = svc_flow->allocate_node(mod_ctx, mHandle, &id);
+        }
+        if (mResult == MOD_OK) {
+            mNodes.push_back({id, node, typed, false});
+        }
+        return {this, id};
+    }
+
+    BuilderNode* find(uint16_t id) {
+        for (auto& node : mNodes) {
+            if (node.id == id) {
+                return &node;
+            }
+        }
+        return nullptr;
+    }
+
+    void set_next(uint16_t id, uint16_t target) {
+        if (mResult != MOD_OK) {
+            return;
+        }
+        auto* node = find(id);
+        if (node == nullptr || node->wired) {
+            mResult = MOD_INVALID_ARGUMENT;
+            return;
+        }
+        node->wired = true;
+        switch (node->data.bytes[0]) {
+        case 1:
+            write_bits(node->data.bytes + 4, target);
+            break;
+        case 3: {
+            uint16_t first = 0;
+            mResult = svc_flow->add_edges(mod_ctx, mHandle, &target, 1, &first);
+            if (mResult == MOD_OK) {
+                write_bits(node->data.bytes + 2, first);
+            }
+            break;
+        }
+        default:
+            mResult = MOD_INVALID_ARGUMENT;
+        }
+    }
+
+    void set_results(uint16_t id, std::span<const uint16_t> targets) {
+        if (mResult != MOD_OK) {
+            return;
+        }
+        auto* node = find(id);
+        if (node == nullptr || node->wired || node->data.bytes[0] != 2 || targets.size() == 0 ||
+            targets.size() > 0xff)
+        {
+            mResult = MOD_INVALID_ARGUMENT;
+            return;
+        }
+        node->wired = true;
+        uint16_t first = 0;
+        mResult = svc_flow->add_edges(
+            mod_ctx, mHandle, targets.data(), static_cast<uint16_t>(targets.size()), &first);
+        if (mResult == MOD_OK) {
+            node->data.bytes[1] = static_cast<uint8_t>(targets.size());
+            write_bits(node->data.bytes + 6, first);
+        }
+    }
+
+    FlowGraphHandle mHandle{};
+    std::vector<BuilderNode> mNodes;
+    ModResult mResult = MOD_OK;
+};
+
+inline NodeRef NodeRef::next(uint16_t target) const {
+    if (mBuilder != nullptr) {
+        mBuilder->set_next(mId, target);
+    }
+    return *this;
+}
+
+inline NodeRef NodeRef::results(std::initializer_list<uint16_t> targets) const {
+    return results(std::span{targets.begin(), targets.size()});
+}
+
+inline NodeRef NodeRef::results(std::span<const uint16_t> targets) const {
+    if (mBuilder != nullptr) {
+        mBuilder->set_results(mId, targets);
+    }
+    return *this;
+}
+
+/* Single-patch convenience functions */
+inline Graph patch_node(uint16_t group, uint16_t nodeIndex, const FlowNodeData& node) {
+    GraphBuilder builder{group};
+    builder.patch_node(nodeIndex, node);
+    return builder.commit();
+}
+
+inline Graph patch_edge(uint16_t group, uint16_t edgeIndex, uint16_t targetNode) {
+    GraphBuilder builder{group};
+    builder.patch_edge(edgeIndex, targetNode);
+    return builder.commit();
+}
+
+class Query {
+public:
+    Query() = default;
+    Query(FlowQueryId id, ModResult result) : mId{id}, mResult{result} {}
+    explicit operator bool() const { return mResult == MOD_OK; }
+    FlowQueryId id() const { return mId; }
+    ModResult result() const { return mResult; }
+
+private:
+    FlowQueryId mId{};
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline Query register_query(const char* debugName, FlowQueryFn fn, void* userData = nullptr) {
+    FlowQueryId id{};
+    const ModResult result = svc_flow != nullptr ?
+                                 svc_flow->register_query(mod_ctx, debugName, fn, userData, &id) :
+                                 MOD_UNAVAILABLE;
+    return {id, result};
+}
+
+class Event {
+public:
+    Event() = default;
+    Event(FlowEventId id, ModResult result) : mId{id}, mResult{result} {}
+    explicit operator bool() const { return mResult == MOD_OK; }
+    FlowEventId id() const { return mId; }
+    ModResult result() const { return mResult; }
+
+private:
+    FlowEventId mId{};
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline Event register_event(const char* debugName, FlowEventFn fn, void* userData = nullptr) {
+    FlowEventId id{};
+    const ModResult result = svc_flow != nullptr ?
+                                 svc_flow->register_event(mod_ctx, debugName, fn, userData, &id) :
+                                 MOD_UNAVAILABLE;
+    return {id, result};
+}
+
+/* Message presentation/style attributes (INF1) */
+class MessageStyle {
+public:
+    constexpr MessageStyle() { mData.bytes[12] = 0xff; }
+    constexpr explicit MessageStyle(MessageEntryData data) : mData{data} {}
+
+    /* saveBitLabels index set when the message displays. */
+    [[nodiscard]] constexpr MessageStyle event_label_id(uint16_t value) const {
+        return set_u16(6, value);
+    }
+    /* Z2SpeechMgr2 voice bank ID */
+    [[nodiscard]] constexpr MessageStyle speaker(uint8_t value) const { return set_u8(8, value); }
+    [[nodiscard]] constexpr MessageStyle box_kind(MessageBoxKind value) const {
+        return set_u8(9, static_cast<uint8_t>(value));
+    }
+    [[nodiscard]] constexpr MessageStyle draw_type(MessageDrawType value) const {
+        return set_u8(10, static_cast<uint8_t>(value));
+    }
+    [[nodiscard]] constexpr MessageStyle box_position(MessageBoxPosition value) const {
+        return set_u8(11, static_cast<uint8_t>(value));
+    }
+    /* 0 centered (JP builds only), 1 left */
+    [[nodiscard]] constexpr MessageStyle line_alignment(uint8_t value) const {
+        return set_u8(13, value);
+    }
+    /* Grunt emotion index for the voice bank */
+    [[nodiscard]] constexpr MessageStyle speaker_mood(uint8_t value) const {
+        return set_u8(14, value);
+    }
+    /* 1-10 focus talk-actor slot, >=11 talk-camera style, 0 none */
+    [[nodiscard]] constexpr MessageStyle camera_attr(uint8_t value) const {
+        return set_u8(15, value);
+    }
+    /* NPC talk motion attribute */
+    [[nodiscard]] constexpr MessageStyle talk_anim(uint8_t value) const {
+        return set_u8(16, value);
+    }
+    /* NPC talk face attribute */
+    [[nodiscard]] constexpr MessageStyle face_anim(uint8_t value) const {
+        return set_u8(17, value);
+    }
+    /* INF1 bytes 18-19, normally 0x0400. */
+    [[nodiscard]] constexpr MessageStyle trailing_data(uint16_t value) const {
+        return set_u16(18, value);
+    }
+    [[nodiscard]] constexpr const MessageEntryData& data() const { return mData; }
+
+private:
+    [[nodiscard]] constexpr MessageStyle set_u8(size_t offset, uint8_t value) const {
+        MessageStyle style = *this;
+        style.mData.bytes[offset] = value;
+        return style;
+    }
+    [[nodiscard]] constexpr MessageStyle set_u16(size_t offset, uint16_t value) const {
+        MessageStyle style = *this;
+        write_bits(style.mData.bytes + offset, value);
+        return style;
+    }
+    MessageEntryData mData{};
+};
+
+class MessageVariant {
+public:
+    MessageVariant() = default;
+    MessageVariant(MessageLanguage language, MessageEntryData entry, std::vector<uint8_t> text,
+        ModResult result = MOD_OK)
+        : mLanguage{language}, mEntry{entry}, mText{std::move(text)}, mResult{result} {}
+
+    explicit operator bool() const { return mResult == MOD_OK; }
+    ModResult result() const { return mResult; }
+    MessageLanguage language() const { return mLanguage; }
+    const MessageEntryData& entry() const { return mEntry; }
+    const std::vector<uint8_t>& text() const { return mText; }
+    MessageVariantData data() const {
+        return {static_cast<uint8_t>(mLanguage), mEntry, mText.data(), mText.size()};
+    }
+
+private:
+    MessageLanguage mLanguage = MESSAGE_LANGUAGE_ENGLISH;
+    MessageEntryData mEntry{};
+    std::vector<uint8_t> mText;
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+class MessageBuilder {
+public:
+    explicit MessageBuilder(MessageStyle style = {}) : mStyle{style} { mText.push_back(0); }
+
+    /* Style setters forwarded to MessageStyle */
+    MessageBuilder& event_label_id(uint16_t value) {
+        return style(&MessageStyle::event_label_id, value);
+    }
+    MessageBuilder& speaker(uint8_t value) { return style(&MessageStyle::speaker, value); }
+    MessageBuilder& box_kind(MessageBoxKind value) { return style(&MessageStyle::box_kind, value); }
+    MessageBuilder& draw_type(MessageDrawType value) {
+        return style(&MessageStyle::draw_type, value);
+    }
+    MessageBuilder& box_position(MessageBoxPosition value) {
+        return style(&MessageStyle::box_position, value);
+    }
+    MessageBuilder& line_alignment(uint8_t value) {
+        return style(&MessageStyle::line_alignment, value);
+    }
+    MessageBuilder& speaker_mood(uint8_t value) {
+        return style(&MessageStyle::speaker_mood, value);
+    }
+    MessageBuilder& camera_attr(uint8_t value) { return style(&MessageStyle::camera_attr, value); }
+    MessageBuilder& talk_anim(uint8_t value) { return style(&MessageStyle::talk_anim, value); }
+    MessageBuilder& face_anim(uint8_t value) { return style(&MessageStyle::face_anim, value); }
+    MessageBuilder& trailing_data(uint16_t value) {
+        return style(&MessageStyle::trailing_data, value);
+    }
+
+    /* Content builder functions */
+    MessageBuilder& text(std::string_view value) {
+        if (!mText.empty()) {
+            mText.pop_back();
+        }
+        mText.insert(mText.end(), value.begin(), value.end());
+        mText.push_back(0);
+        return *this;
+    }
+    MessageBuilder& raw_tag(uint8_t group, uint16_t type, std::span<const uint8_t> arguments) {
+        if (arguments.size() > 250) {
+            mResult = MOD_INVALID_ARGUMENT;
+            return *this;
+        }
+        mText.pop_back();
+        mText.push_back(0x1a);
+        mText.push_back(static_cast<uint8_t>(5 + arguments.size()));
+        mText.push_back(group);
+        mText.push_back(static_cast<uint8_t>(type >> 8));
+        mText.push_back(static_cast<uint8_t>(type));
+        mText.insert(mText.end(), arguments.begin(), arguments.end());
+        mText.push_back(0);
+        return *this;
+    }
+    MessageBuilder& text_color(MessageTextColor color) {
+        const auto index = static_cast<uint8_t>(color);
+        return raw_tag(0xFF, 0, {&index, 1});
+    }
+    /* Full 32-bit text color (Dusklight extension) */
+    MessageBuilder& text_color(uint32_t rgba) {
+        std::array<uint8_t, 4> arguments{};
+        write_bits(arguments.data(), rgba);
+        return raw_tag(0xFF, 0, arguments);
+    }
+    /* Full 32-bit text vertical gradient colors (Dusklight extension) */
+    MessageBuilder& text_color(uint32_t upperRgba, uint32_t lowerRgba) {
+        std::array<uint8_t, 8> arguments{};
+        write_bits(arguments.data(), upperRgba);
+        write_bits(arguments.data() + sizeof(upperRgba), lowerRgba);
+        return raw_tag(0xFF, 0, arguments);
+    }
+    MessageBuilder& text_scale(uint16_t percent) { return timed_tag(255, 1, percent); }
+    MessageBuilder& character_delay(uint16_t frames) { return timed_tag(0, 6, frames); }
+    MessageBuilder& pause(uint16_t frames) { return timed_tag(0, 7, frames); }
+    MessageBuilder& auto_advance(uint16_t frames) { return timed_tag(0, 4, frames); }
+    MessageBuilder& auto_advance_alternate(uint16_t frames) { return timed_tag(0, 3, frames); }
+    MessageBuilder& input_or_timeout(uint16_t frames) { return timed_tag(0, 5, frames); }
+    MessageBuilder& input_after_delay(uint16_t frames) { return timed_tag(0, 54, frames); }
+    /* Insert the player's name. */
+    MessageBuilder& player_name() { return raw_tag(0, 0, {}); }
+    /* End a prompt that presents a selection; the options live in the target flow node. */
+    MessageBuilder& await_choice() { return raw_tag(0, 32, {}); }
+    /* Option list for a vertical selection message. Only two or three options are supported.
+     * `initial` configures the highlighted option on open. */
+    MessageBuilder& options(std::string_view first, std::string_view second, uint8_t initial = 0) {
+        option(8, 0, initial, first);
+        return option(8, 1, initial, second);
+    }
+    MessageBuilder& options(std::string_view first, std::string_view second, std::string_view third,
+        uint8_t initial = 0) {
+        option(9, 0, initial, first);
+        option(9, 1, initial, second);
+        return option(9, 2, initial, third);
+    }
+    MessageVariant build(MessageLanguage language) const {
+        return {language, mStyle.data(), mText, mResult};
+    }
+
+private:
+    MessageBuilder& option(
+        uint16_t type, uint8_t position, uint8_t initial, std::string_view value) {
+        if (position > 0) {
+            text("\n");
+        }
+        uint8_t marker = static_cast<uint8_t>(position + 1);
+        if (position == initial) {
+            marker = 1;
+        } else if (position == 0) {
+            marker = static_cast<uint8_t>(initial + 1);
+        }
+        raw_tag(0, type, {&marker, 1});
+        return text(value);
+    }
+
+    template <typename Setter, typename Value>
+    MessageBuilder& style(Setter setter, Value value) {
+        mStyle = (mStyle.*setter)(value);
+        return *this;
+    }
+
+    MessageBuilder& timed_tag(uint8_t group, uint16_t type, uint16_t value) {
+        return raw_tag(
+            group, type, std::array{static_cast<uint8_t>(value >> 8), static_cast<uint8_t>(value)});
+    }
+
+    MessageStyle mStyle;
+    std::vector<uint8_t> mText;
+    ModResult mResult = MOD_OK;
+};
+
+class MessageOverride {
+public:
+    MessageOverride() = default;
+    MessageOverride(MessageOverrideHandle handle, ModResult result)
+        : mHandle{handle}, mResult{result} {}
+    MessageOverride(const MessageOverride&) = delete;
+    MessageOverride& operator=(const MessageOverride&) = delete;
+    MessageOverride(MessageOverride&& other) noexcept { *this = std::move(other); }
+    MessageOverride& operator=(MessageOverride&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+    ~MessageOverride() { reset(); }
+
+    explicit operator bool() const { return mResult == MOD_OK; }
+    ModResult result() const { return mResult; }
+    MessageOverrideHandle handle() const { return mHandle; }
+    void reset() {
+        if (mHandle != 0 && svc_message != nullptr) {
+            svc_message->remove_override(mod_ctx, mHandle);
+            mHandle = 0;
+        }
+    }
+
+private:
+    MessageOverrideHandle mHandle{};
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline MessageOverride override_message(
+    uint16_t group, uint16_t messageId, MessageLanguage language, std::span<const uint8_t> text) {
+    MessageOverrideHandle handle{};
+    const ModResult result = svc_message != nullptr ? svc_message->override_message(mod_ctx, group,
+                                                          messageId, static_cast<uint8_t>(language),
+                                                          text.data(), text.size(), &handle) :
+                                                      MOD_UNAVAILABLE;
+    return {handle, result};
+}
+
+inline MessageOverride override_message_fn(uint16_t group, uint16_t messageId,
+    MessageLanguage language, MessageOverrideFn fn, void* userData = nullptr) {
+    MessageOverrideHandle handle{};
+    const ModResult result = svc_message != nullptr ?
+                                 svc_message->override_message_fn(mod_ctx, group, messageId,
+                                     static_cast<uint8_t>(language), fn, userData, &handle) :
+                                 MOD_UNAVAILABLE;
+    return {handle, result};
+}
+
+class RegisteredMessage {
+public:
+    RegisteredMessage() = default;
+    RegisteredMessage(MessageId id, MessageHandle handle, ModResult result)
+        : mId{id}, mHandle{handle}, mResult{result} {}
+    RegisteredMessage(const RegisteredMessage&) = delete;
+    RegisteredMessage& operator=(const RegisteredMessage&) = delete;
+    RegisteredMessage(RegisteredMessage&& other) noexcept { *this = std::move(other); }
+    RegisteredMessage& operator=(RegisteredMessage&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mId = other.mId;
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+    ~RegisteredMessage() { reset(); }
+    explicit operator bool() const { return mResult == MOD_OK; }
+    MessageId id() const { return mId; }
+    ModResult result() const { return mResult; }
+    void reset() {
+        if (mHandle != 0 && svc_message != nullptr) {
+            svc_message->remove_message(mod_ctx, mHandle);
+            mHandle = 0;
+        }
+    }
+
+private:
+    MessageId mId{};
+    MessageHandle mHandle{};
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline RegisteredMessage register_message(
+    uint16_t group, std::span<const MessageVariant> variants) {
+    std::vector<MessageVariantData> data;
+    data.reserve(variants.size());
+    for (const auto& variant : variants) {
+        if (!variant) {
+            return {0, 0, variant.result()};
+        }
+        data.push_back(variant.data());
+    }
+    MessageId id{};
+    MessageHandle handle{};
+    const ModResult result = svc_message != nullptr ? svc_message->register_message(mod_ctx, group,
+                                                          data.data(), data.size(), &id, &handle) :
+                                                      MOD_UNAVAILABLE;
+    return {id, handle, result};
+}
+
+inline RegisteredMessage register_message(
+    uint16_t group, std::initializer_list<MessageVariant> variants) {
+    return register_message(group, std::span{variants.begin(), variants.size()});
+}
+
+}  // namespace mods::flow
diff --git a/include/mods/svc/game.h b/sdk/include/mods/svc/game.h
similarity index 52%
rename from include/mods/svc/game.h
rename to sdk/include/mods/svc/game.h
index fbd914d4bc..61a10968e6 100644
--- a/include/mods/svc/game.h
+++ b/sdk/include/mods/svc/game.h
@@ -1,30 +1,26 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
 
 /*
- * Mods that link or hook game code directly must import this service; service-only and asset-only
- * mods must not.
+ * The mod SDK imports this service automatically for mods built with FEATURES game; service-only
+ * and asset-only mods do not require it.
  *
  * Major version is the game-code ABI epoch: it is bumped when game-visible struct or vtable layouts
  * change incompatibly (e.g. a TARGET_PC field added to an existing game struct). The loader's
  * ordinary version check then fails mods built against the old epoch with a clear message instead
  * of letting them corrupt memory.
  */
-#define GAME_SERVICE_ID "dev.twilitrealm.dusklight.game"
-#define GAME_SERVICE_MAJOR 1u
+#define GAME_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "game"
+#define GAME_SERVICE_MAJOR 2u
 #define GAME_SERVICE_MINOR 0u
 
 typedef struct GameService {
     ServiceHeader header;
 } GameService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<GameService> {
-    static constexpr const char* id = GAME_SERVICE_ID;
-    static constexpr uint16_t major_version = GAME_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(GameService, svc_game, GAME_SERVICE_ID, GAME_SERVICE_MAJOR, GAME_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/game_mode.h b/sdk/include/mods/svc/game_mode.h
new file mode 100644
index 0000000000..d17a8f003c
--- /dev/null
+++ b/sdk/include/mods/svc/game_mode.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <mods/api.h>
+#include <mods/svc/config.h>
+
+#define GAME_MODE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "gamemode"
+#define GAME_MODE_SERVICE_MAJOR 1u
+#define GAME_MODE_SERVICE_MINOR 0u
+
+/* MOD_OK on success; failures disable the mod. */
+typedef ModResult (*GameModeCallback)(void* user_data, ModError* out_error);
+
+typedef enum GameModeNewSaveState {
+    GAME_MODE_STATE_PENDING = 0,
+    GAME_MODE_STATE_PROCEED,
+    GAME_MODE_STATE_RETURN,
+} GameModeNewSaveState;
+
+/* Set state to PROCEED after custom UI completes, or RETURN to cancel.
+ * State pointer is valid until selection completes. */
+typedef ModResult (*GameModeNewSaveSelectCallback)(
+    void* user_data, GameModeNewSaveState* state, ModError* out_error);
+
+typedef struct {
+    uint32_t struct_size;
+    const char* game_mode_id;
+    const char* full_name;
+    const char save_name[32];         // Empty uses default (gczelda2); max 31 chars
+    void* user_data;                  // Pointer will be passed to all callbacks
+    GameModeCallback on_activated;    // Called when the game mode is selected
+    GameModeCallback on_deactivated;  // Called when the game mode is deselected
+    GameModeCallback on_play;         // Called when play is pressed
+    GameModeCallback on_save_loaded;  // Called whenever a save file is loaded
+    GameModeCallback on_new_save;     // Called when a new save is created
+    GameModeNewSaveSelectCallback on_new_save_select;
+    GameModeCallback on_game_reset;  // Called when the game is reset
+    GameModeCallback on_tick;        // Called on every game tick while active
+} GameModeDesc;
+
+#define GAME_MODE_DESC_INIT {sizeof(GameModeDesc)}
+
+typedef struct GameModeService {
+    ServiceHeader header;
+    ModResult (*register_game_mode)(ModContext* ctx, const GameModeDesc* desc);
+    ModResult (*unregister_game_mode)(ModContext* ctx, const char* id);
+    ModResult (*is_active)(ModContext* ctx, const char* game_mode_id, bool* out_active);
+} GameModeService;
+
+MOD_DECLARE_SERVICE(GameModeService, svc_game_mode, GAME_MODE_SERVICE_ID, GAME_MODE_SERVICE_MAJOR,
+    GAME_MODE_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/gfx.h b/sdk/include/mods/svc/gfx.h
new file mode 100644
index 0000000000..787958716b
--- /dev/null
+++ b/sdk/include/mods/svc/gfx.h
@@ -0,0 +1,342 @@
+#pragma once
+
+#include <mods/api.h>
+#include <mods/svc/window.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#if !defined(DUSK_BUILDING_GAME) && !defined(DUSK_MOD_FEATURE_WEBGPU)
+#error "mods/svc/gfx.h requires add_mod(... FEATURES webgpu)"
+#endif
+
+#include <webgpu/webgpu.h>
+
+/*
+ * Direct WebGPU access at various stages of the rendering pipeline. Mods use the wgpu* C API
+ * (via webgpu/webgpu.h) for custom draws and compute dispatches.
+ *
+ * Every service function must be called on the game thread. GfxStageFn callbacks run on the game
+ * thread during frame recording. push_draw, push_* and pass functions are valid from a stage
+ * callback and anywhere else GX commands are being recorded.
+ *
+ * GfxDrawFn and GfxComputeFn callbacks run on the render worker thread while the frame is encoded.
+ * They may use only the handles in their context struct and raw wgpu* calls; no other service may
+ * be called from them.
+ *
+ * All WGPU handles provided by this service are borrowed. Handles in callback contexts are valid
+ * only for the duration of the callback; views in GfxResolvedTargets are valid for the current
+ * frame only. GPU objects a mod creates through raw wgpu calls are its own responsibility and
+ * should be released in mod_shutdown. The device outlives all mods.
+ */
+
+#define GFX_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "gfx"
+#define GFX_SERVICE_MAJOR 1u
+#define GFX_SERVICE_MINOR 2u
+
+/* Maximum size for push_draw payload */
+#define GFX_INLINE_DRAW_PAYLOAD_SIZE 128u
+#define GFX_MAX_COLOR_ATTACHMENTS 8u
+#define GFX_SCENE_COLOR_ATTACHMENT_INDEX 0u
+
+typedef enum GfxAttachmentSemantic {
+    GFX_ATTACHMENT_SCENE_COLOR,
+    GFX_ATTACHMENT_NORMAL,
+    GFX_ATTACHMENT_AUXILIARY,
+} GfxAttachmentSemantic;
+
+typedef struct GfxColorAttachmentLayout {
+    GfxAttachmentSemantic semantic;
+    WGPUTextureFormat format;
+    uint32_t width;
+    uint32_t height;
+} GfxColorAttachmentLayout;
+
+typedef struct GfxRenderTargetLayout {
+    uint32_t struct_size;
+    uint64_t key;
+    /* At least one; scene color is at GFX_SCENE_COLOR_ATTACHMENT_INDEX. */
+    uint32_t color_attachment_count;
+    GfxColorAttachmentLayout color_attachments[GFX_MAX_COLOR_ATTACHMENTS];
+    WGPUTextureFormat depth_stencil_format;
+    uint32_t sample_count;
+} GfxRenderTargetLayout;
+
+#define GFX_RENDER_TARGET_LAYOUT_INIT                                                              \
+    {sizeof(GfxRenderTargetLayout), 0u, 0u,                                                        \
+        {{GFX_ATTACHMENT_AUXILIARY, WGPUTextureFormat_Undefined}}, WGPUTextureFormat_Undefined,    \
+        1u}
+
+/*
+ * Initializes pipeline color targets for a render-target layout. Only scene color is writable;
+ * callers that write another semantic should override that target afterward.
+ */
+static uint32_t gfx_init_color_target_states(const GfxRenderTargetLayout* layout,
+    WGPUColorTargetState targets[GFX_MAX_COLOR_ATTACHMENTS], const WGPUBlendState* scene_blend,
+    WGPUColorWriteMask scene_write_mask) {
+    if (layout == NULL || targets == NULL) {
+        return 0;
+    }
+    const uint32_t count = layout->color_attachment_count < GFX_MAX_COLOR_ATTACHMENTS ?
+                               layout->color_attachment_count :
+                               GFX_MAX_COLOR_ATTACHMENTS;
+    for (uint32_t i = 0; i < GFX_MAX_COLOR_ATTACHMENTS; ++i) {
+        WGPUColorTargetState target = WGPU_COLOR_TARGET_STATE_INIT;
+        if (i < count) {
+            target.format = layout->color_attachments[i].format;
+            target.writeMask = WGPUColorWriteMask_None;
+        }
+        targets[i] = target;
+    }
+    if (count != 0) {
+        targets[GFX_SCENE_COLOR_ATTACHMENT_INDEX].blend = scene_blend;
+        targets[GFX_SCENE_COLOR_ATTACHMENT_INDEX].writeMask = scene_write_mask;
+    }
+    return count;
+}
+
+/* 0 is never a valid handle. */
+typedef uint64_t GfxDrawTypeHandle;
+typedef uint64_t GfxStageHookHandle;
+typedef uint64_t GfxComputeTypeHandle;
+typedef uint64_t GfxPresentTargetHandle;
+
+/* A suballocation in one of the shared per-frame streaming buffers. */
+typedef struct GfxRange {
+    uint32_t offset;
+    uint32_t size;
+} GfxRange;
+
+/*
+ * Device and legacy primary scene-pass configuration. Use get_scene_target_layout when creating
+ * scene pipelines. Offscreen passes from create_pass are always single-sample.
+ */
+typedef struct GfxDeviceInfo {
+    uint32_t struct_size;
+    WGPUDevice device;              /* borrowed */
+    WGPUQueue queue;                /* borrowed */
+    WGPUTextureFormat color_format; /* scene color target format */
+    WGPUTextureFormat depth_format; /* scene depth target format */
+    uint32_t sample_count;          /* scene pass MSAA sample count */
+    bool uses_reversed_z;           /* true means depth 1.0 is near */
+    WGPUInstance instance;          /* borrowed; added in GfxService 1.1 */
+    WGPUAdapter adapter;            /* borrowed; added in GfxService 1.1 */
+} GfxDeviceInfo;
+
+#define GFX_DEVICE_INFO_INIT                                                                       \
+    {sizeof(GfxDeviceInfo), NULL, NULL, WGPUTextureFormat_Undefined, WGPUTextureFormat_Undefined,  \
+        1u, false, NULL, NULL}
+
+/*
+ * Passed to GfxDrawFn on the render worker thread; valid only during the call. The pass pipeline,
+ * bind group, viewport, and scissor state is restored by the host after the callback returns.
+ */
+typedef struct GfxDrawContext {
+    uint32_t struct_size;
+    WGPUDevice device;
+    WGPUQueue queue;
+    WGPURenderPassEncoder pass;
+    WGPUBuffer vertex_buffer;
+    WGPUBuffer index_buffer;
+    WGPUBuffer uniform_buffer;
+    WGPUBuffer storage_buffer;
+    /* deprecated: use layout.color_attachments[GFX_SCENE_COLOR_ATTACHMENT_INDEX].format */
+    WGPUTextureFormat color_format;
+    /* deprecated: use layout.depth_stencil_format */
+    WGPUTextureFormat depth_format;
+    /* deprecated: use layout.sample_count */
+    uint32_t sample_count;
+    /* deprecated: use layout.color_attachments[GFX_SCENE_COLOR_ATTACHMENT_INDEX].width */
+    uint32_t target_width;
+    /* deprecated: use layout.color_attachments[GFX_SCENE_COLOR_ATTACHMENT_INDEX].height */
+    uint32_t target_height;
+    bool uses_reversed_z;
+    GfxRenderTargetLayout layout; /* added in GfxService 1.2 */
+} GfxDrawContext;
+
+typedef void (*GfxDrawFn)(ModContext* ctx, const GfxDrawContext* draw_ctx, const void* payload,
+    size_t payload_size, void* user_data);
+
+typedef struct GfxDrawTypeDesc {
+    uint32_t struct_size;
+    const char* label; /* optional debug label */
+    GfxDrawFn draw;    /* required; called from the render worker thread */
+    void* user_data;
+} GfxDrawTypeDesc;
+
+#define GFX_DRAW_TYPE_DESC_INIT {sizeof(GfxDrawTypeDesc), NULL, NULL, NULL}
+
+typedef enum GfxStage {
+    GFX_STAGE_SCENE_AFTER_TERRAIN = 0,
+    GFX_STAGE_FRAME_BEFORE_HUD = 1,
+    GFX_STAGE_FRAME_AFTER_HUD = 2,
+    GFX_STAGE_SCENE_BEGIN = 3,
+    GFX_STAGE_SCENE_AFTER_OPAQUE = 4,
+} GfxStage;
+
+typedef struct GfxStageContext {
+    uint32_t struct_size;
+    GfxStage stage;
+    const void* game_view;     /* view_class* for world-camera stages; NULL otherwise */
+    const void* game_viewport; /* view_port_class* for world-camera stages; NULL otherwise */
+} GfxStageContext;
+
+typedef void (*GfxStageFn)(ModContext* ctx, const GfxStageContext* stage_ctx, void* user_data);
+
+typedef struct GfxStageHookDesc {
+    uint32_t struct_size;
+    GfxStageFn callback; /* required */
+    void* user_data;
+} GfxStageHookDesc;
+
+#define GFX_STAGE_HOOK_DESC_INIT {sizeof(GfxStageHookDesc), NULL, NULL}
+
+typedef struct GfxResolveDesc {
+    uint32_t struct_size;
+    bool color;
+    bool depth;
+} GfxResolveDesc;
+
+#define GFX_RESOLVE_DESC_INIT {sizeof(GfxResolveDesc), true, false}
+
+typedef struct GfxResolvedTargets {
+    uint32_t struct_size;
+    WGPUTextureView color; /* single-sample snapshot in color_format */
+    WGPUTextureView depth; /* single-sample raw depth snapshot, R32Float when available */
+    WGPUTextureFormat color_format;
+    uint32_t width;
+    uint32_t height;
+} GfxResolvedTargets;
+
+#define GFX_RESOLVED_TARGETS_INIT                                                                  \
+    {sizeof(GfxResolvedTargets), NULL, NULL, WGPUTextureFormat_Undefined, 0u, 0u}
+
+/*
+ * Passed to GfxComputeFn on the render worker thread; valid only during the call. The encoder is
+ * the frame command encoder between scene render passes. Leave no pass open and never finish or
+ * release the encoder.
+ */
+typedef struct GfxComputeContext {
+    uint32_t struct_size;
+    WGPUDevice device;
+    WGPUQueue queue;
+    WGPUCommandEncoder encoder;
+    WGPUBuffer vertex_buffer;
+    WGPUBuffer index_buffer;
+    WGPUBuffer uniform_buffer;
+    WGPUBuffer storage_buffer;
+} GfxComputeContext;
+
+typedef void (*GfxComputeFn)(ModContext* ctx, const GfxComputeContext* compute_ctx,
+    const void* payload, size_t payload_size, void* user_data);
+
+typedef struct GfxComputeTypeDesc {
+    uint32_t struct_size;
+    const char* label;     /* optional debug label */
+    GfxComputeFn callback; /* required; called from the render worker thread */
+    void* user_data;
+} GfxComputeTypeDesc;
+
+#define GFX_COMPUTE_TYPE_DESC_INIT {sizeof(GfxComputeTypeDesc), NULL, NULL, NULL}
+
+/*
+ * Invoked on the render worker while the frame encoder is open. The target texture and view have
+ * been acquired by the host and are borrowed for the callback. Record all target work on encoder,
+ * leave no pass open, and do not finish, submit, or present it. The host submits the shared command
+ * buffer and presents the target after submission. The streaming buffers contain data appended on
+ * the game thread before push_present.
+ */
+typedef struct GfxPresentContext {
+    uint32_t struct_size;
+    WGPUDevice device;
+    WGPUQueue queue;
+    WGPUCommandEncoder encoder;
+    WGPUTexture target_texture;
+    WGPUTextureView target_view;
+    WGPUTextureFormat target_format;
+    uint32_t target_width;
+    uint32_t target_height;
+    WGPUBuffer vertex_buffer;
+    WGPUBuffer index_buffer;
+    WGPUBuffer uniform_buffer;
+    WGPUBuffer storage_buffer;
+} GfxPresentContext;
+
+typedef void (*GfxPresentFn)(ModContext* ctx, const GfxPresentContext* present_ctx,
+    const void* payload, size_t payload_size, void* user_data);
+
+typedef struct GfxPresentTargetDesc {
+    uint32_t struct_size;
+    const char* label; /* optional debug label */
+    uint32_t width;    /* required for raw surfaces; ignored for WindowService windows */
+    uint32_t height;
+    WGPUTextureUsage usage; /* 0 defaults to RenderAttachment */
+    WGPUTextureFormat preferred_format;
+    WGPUCompositeAlphaMode preferred_alpha_mode;
+    GfxPresentFn render;
+    void* user_data;
+} GfxPresentTargetDesc;
+
+#define GFX_PRESENT_TARGET_DESC_INIT                                                               \
+    {sizeof(GfxPresentTargetDesc), NULL, 0u, 0u, WGPUTextureUsage_None,                            \
+        WGPUTextureFormat_Undefined, WGPUCompositeAlphaMode_Auto, NULL, NULL}
+
+typedef struct GfxService {
+    ServiceHeader header;
+
+    ModResult (*get_device_info)(ModContext* ctx, GfxDeviceInfo* out_info);
+    void* (*get_proc_address)(ModContext* ctx, const char* name);
+
+    ModResult (*register_draw_type)(
+        ModContext* ctx, const GfxDrawTypeDesc* desc, GfxDrawTypeHandle* out_handle);
+    ModResult (*unregister_draw_type)(ModContext* ctx, GfxDrawTypeHandle handle);
+    ModResult (*push_draw)(
+        ModContext* ctx, GfxDrawTypeHandle handle, const void* payload, size_t payload_size);
+
+    ModResult (*register_compute_type)(
+        ModContext* ctx, const GfxComputeTypeDesc* desc, GfxComputeTypeHandle* out_handle);
+    ModResult (*unregister_compute_type)(ModContext* ctx, GfxComputeTypeHandle handle);
+    ModResult (*push_compute)(
+        ModContext* ctx, GfxComputeTypeHandle handle, const void* payload, size_t payload_size);
+
+    ModResult (*push_verts)(
+        ModContext* ctx, const void* data, size_t size, size_t alignment, GfxRange* out_range);
+    ModResult (*push_indices)(
+        ModContext* ctx, const void* data, size_t size, size_t alignment, GfxRange* out_range);
+    ModResult (*push_uniform)(ModContext* ctx, const void* data, size_t size, GfxRange* out_range);
+    ModResult (*push_storage)(ModContext* ctx, const void* data, size_t size, GfxRange* out_range);
+
+    ModResult (*register_stage_hook)(ModContext* ctx, GfxStage stage, const GfxStageHookDesc* desc,
+        GfxStageHookHandle* out_handle);
+    ModResult (*unregister_stage_hook)(ModContext* ctx, GfxStageHookHandle handle);
+
+    ModResult (*resolve_pass)(
+        ModContext* ctx, const GfxResolveDesc* desc, GfxResolvedTargets* out_targets);
+    ModResult (*create_pass)(ModContext* ctx, uint32_t width, uint32_t height);
+
+    /* Minor version 1 */
+
+    ModResult (*register_present_target)(ModContext* ctx, WGPUSurface surface,
+        const GfxPresentTargetDesc* desc, GfxPresentTargetHandle* out_handle);
+    ModResult (*register_window_present_target)(ModContext* ctx, WindowHandle window,
+        const GfxPresentTargetDesc* desc, GfxPresentTargetHandle* out_handle);
+    /* Raw-surface targets only; WindowService target resizes are managed automatically. */
+    ModResult (*resize_present_target)(
+        ModContext* ctx, GfxPresentTargetHandle handle, uint32_t width, uint32_t height);
+    ModResult (*unregister_present_target)(ModContext* ctx, GfxPresentTargetHandle handle);
+    /*
+     * MOD_OK means the task was queued.
+     * MOD_UNAVAILABLE means no task could be queued now (for example, a window has no pixel size).
+     * MOD_ERROR means an earlier task found the surface lost or deterministically invalid;
+     * unregister and recreate the target before pushing again.
+     */
+    ModResult (*push_present)(
+        ModContext* ctx, GfxPresentTargetHandle handle, const void* payload, size_t payload_size);
+
+    /* Minor version 2 */
+
+    ModResult (*get_scene_target_layout)(ModContext* ctx, GfxRenderTargetLayout* out_layout);
+} GfxService;
+
+MOD_DECLARE_SERVICE(GfxService, svc_gfx, GFX_SERVICE_ID, GFX_SERVICE_MAJOR, GFX_SERVICE_MINOR);
diff --git a/include/mods/svc/hook.h b/sdk/include/mods/svc/hook.h
similarity index 69%
rename from include/mods/svc/hook.h
rename to sdk/include/mods/svc/hook.h
index d1a75fa6cc..30b199b386 100644
--- a/include/mods/svc/hook.h
+++ b/sdk/include/mods/svc/hook.h
@@ -1,22 +1,28 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
 
 /*
- * Intercept game functions by address. Prefer the typed helpers in mods/hook.hpp
- * (hook_add_pre/hook_add_post/hook_replace over a &Class::method): they generate the
- * trampoline and hide install/dispatch, which are the low-level primitives those helpers
- * build. resolve() maps a symbol name to an address for targets you can't name at compile time
- * (file-local statics included).
+ * Hooks allow intercepting calls to game functions, allowing you to:
+ * - Modify arguments
+ * - Perform your own work before (pre), after (post) or instead of (replace) the original call
+ * - From a pre hook, conditionally skip the original call and return your own value
  *
- * Every call is game-thread-only. Install and removal must run with no hooked function on the
- * stack; the loader guarantees this by applying mod lifecycle changes between frames, which is
- * why hooking a function that never returns (the outermost loop) makes a mod un-unloadable.
+ * In most cases, you'll want to instead use the C++ helpers in mods/svc/hook.hpp
+ * (mods::hook::add_pre/add_post/replace). They generate the trampoline passed to
+ * install and provide compile-time type checking.
+ *
+ * resolve() resolves an address by symbol name for targets you can't name at compile time
+ * (file-local statics included).
  */
 
-#define HOOK_SERVICE_ID "dev.twilitrealm.dusklight.hook"
+#define HOOK_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "hook"
 #define HOOK_SERVICE_MAJOR 1u
-#define HOOK_SERVICE_MINOR 0u
+#define HOOK_SERVICE_MINOR 1u
 
 /* Symbol flags reported by resolve() */
 typedef enum HookSymbolFlags {
@@ -46,7 +52,7 @@ typedef enum HookReplacePolicy {
 /*
  * Hook callbacks. `args` is an array of pointers to the call's arguments (index 0 is `this`
  * for member functions); `retval` points at the return slot (NULL for void). Read and write
- * them through dusk::mods::arg<T> / arg_ref<T> from mods/hook.hpp. `userdata` is the pointer
+ * them through mods::arg<T> / arg_ref<T> from mods/svc/hook.hpp. `userdata` is the pointer
  * from HookOptions. All run on the game thread, in the hooked call's own stack frame.
  */
 typedef HookAction (*HookPreFn)(ModContext* ctx, void* args, void* retval, void* userdata);
@@ -68,11 +74,18 @@ typedef struct HookService {
     ServiceHeader header;
 
     /*
-     * Install a trampoline detour on fn_addr and return the address to call the original through in
-     * *out_original_fn. The typed helpers generate the trampoline and call this; mods normally
-     * don't. The first mod to install a given target owns the live detour; later mods register as
-     * candidates so a hook survives the owner unloading (the detour is handed off and every
-     * original pointer is rewritten). Idempotent per (mod, out slot).
+     * Install a hook on fn_addr.
+     *
+     * trampoline_fn must point to a function that matches the original function's signature and
+     * dispatches pre- and post- hooks. This dispatch trampoline is normally generated at compile
+     * time using C++ template instantiation (see mods/svc/hook.hpp).
+     *
+     * The first hook install on a target will implicitly install a detour (patched instructions
+     * on the target that jump to the dispatch trampoline). When all hooks are uninstalled from a
+     * target, the detour is completely uninstalled.
+     *
+     * The address that the dispatch trampoline should call the original function through is written
+     * to out_original_fn.
      */
     ModResult (*install)(
         ModContext* ctx, void* fn_addr, void* trampoline_fn, void** out_original_fn);
@@ -112,14 +125,16 @@ typedef struct HookService {
      */
     ModResult (*resolve)(
         ModContext* ctx, const char* symbol, void** out_addr, HookSymbolFlags* out_flags);
+
+    /* Minor version 1 */
+
+    /*
+     * Uninstall the current mod's hook on fn_addr and unregister all callbacks.
+     * If no other mods have a hook installed on the target, the detour is uninstalled entirely.
+     *
+     * original_fn_slot must match the out_original_fn passed to install.
+     */
+    ModResult (*uninstall)(ModContext* ctx, void* fn_addr, void** original_fn_slot);
 } HookService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<HookService> {
-    static constexpr const char* id = HOOK_SERVICE_ID;
-    static constexpr uint16_t major_version = HOOK_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(HookService, svc_hook, HOOK_SERVICE_ID, HOOK_SERVICE_MAJOR, HOOK_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/hook.hpp b/sdk/include/mods/svc/hook.hpp
new file mode 100644
index 0000000000..eab3115d01
--- /dev/null
+++ b/sdk/include/mods/svc/hook.hpp
@@ -0,0 +1,264 @@
+#pragma once
+
+#if !defined(DUSK_BUILDING_GAME) && !defined(DUSK_MOD_FEATURE_GAME)
+#error "DEFINE_HOOK requires add_mod(... FEATURES game)"
+#endif
+
+#include <mods/svc/hook.h>
+
+#include <memory>
+#include <type_traits>
+
+namespace mods {
+
+template <class T>
+T arg(void* argsRaw, int n) noexcept {
+    void** args = static_cast<void**>(argsRaw);
+    return *static_cast<std::add_pointer_t<std::remove_reference_t<T>>>(args[n]);
+}
+
+template <class T>
+std::remove_reference_t<T>& arg_ref(void* argsRaw, int n) noexcept {
+    void** args = static_cast<void**>(argsRaw);
+    return *static_cast<std::add_pointer_t<std::remove_reference_t<T>>>(args[n]);
+}
+
+/*
+ * Trampoline generator + per-target state. Tag makes each hooked target's statics distinct; the
+ * target address comes from the declaration's metadata record, resolved by the host at mod
+ * initialization.
+ */
+template <class Tag, class R, class... A>
+struct HookImpl {
+    static inline R (*g_orig)(A...) = nullptr;
+    static inline const HookService* hooks = nullptr;
+    static inline void* target = nullptr;
+
+    static bool dispatch_pre(void* args, void* retval) {
+        if (hooks == nullptr) {
+            return false;
+        }
+
+        int skipOriginal = 0;
+        const ModResult result = hooks->dispatch_pre(mod_ctx, target, args, retval, &skipOriginal);
+        return result == MOD_OK && skipOriginal != 0;
+    }
+
+    static void dispatch_post(void* args, void* retval) {
+        if (hooks != nullptr) {
+            hooks->dispatch_post(mod_ctx, target, args, retval);
+        }
+    }
+
+    static R trampoline(A... args) {
+        if constexpr (sizeof...(A) == 0) {
+            if constexpr (std::is_void_v<R>) {
+                const bool skipOriginal = dispatch_pre(nullptr, nullptr);
+                if (!skipOriginal) {
+                    g_orig(args...);
+                }
+                dispatch_post(nullptr, nullptr);
+            } else {
+                R result{};
+                const bool skipOriginal =
+                    dispatch_pre(nullptr, static_cast<void*>(std::addressof(result)));
+                if (!skipOriginal) {
+                    result = g_orig(args...);
+                }
+                dispatch_post(nullptr, static_cast<void*>(std::addressof(result)));
+                return result;
+            }
+        } else {
+            void* ptrs[] = {static_cast<void*>(std::addressof(args))...};
+            if constexpr (std::is_void_v<R>) {
+                const bool skipOriginal = dispatch_pre(static_cast<void*>(ptrs), nullptr);
+                if (!skipOriginal) {
+                    g_orig(args...);
+                }
+                dispatch_post(static_cast<void*>(ptrs), nullptr);
+            } else {
+                R result{};
+                const bool skipOriginal = dispatch_pre(
+                    static_cast<void*>(ptrs), static_cast<void*>(std::addressof(result)));
+                if (!skipOriginal) {
+                    result = g_orig(args...);
+                }
+                dispatch_post(static_cast<void*>(ptrs), static_cast<void*>(std::addressof(result)));
+                return result;
+            }
+        }
+    }
+};
+
+namespace detail {
+template <auto Target>
+using TargetTag = std::integral_constant<decltype(Target), Target>;
+template <FixedString Name>
+struct NameTag {};
+}  // namespace detail
+
+/*
+ * Typed base for a hook on a function named at compile time (&daAlink_c::execute, &free_fn).
+ * Instantiate through DEFINE_HOOK, which pairs it with the metadata record the host resolves.
+ */
+template <auto Target>
+struct Hook;
+
+template <class C, class R, class... A, R (C::*Target)(A...)>
+struct Hook<Target> : HookImpl<detail::TargetTag<Target>, R, C*, A...> {};
+
+template <class C, class R, class... A, R (C::*Target)(A...) const>
+struct Hook<Target> : HookImpl<detail::TargetTag<Target>, R, const C*, A...> {};
+
+template <class R, class... A, R (*Target)(A...)>
+struct Hook<Target> : HookImpl<detail::TargetTag<Target>, R, A...> {};
+
+/*
+ * Typed base for a hook on a function by its symbol name, for targets you can't name in C++:
+ * file-local statics, private members, or symbols without a header. The signature is written
+ * free-style with the receiver first and is *not* compiler-checked. Instantiate through
+ * DEFINE_HOOK_SYMBOL.
+ */
+template <FixedString Name, class Sig>
+struct NamedHook;
+
+template <FixedString Name, class R, class... A>
+struct NamedHook<Name, R(A...)> : HookImpl<detail::NameTag<Name>, R, A...> {};
+
+/*
+ * Declare a hook target.  The declaration emits a metadata record that the host resolves at mod
+ * initialization. Every hook target must be declared.
+ *
+ *   DEFINE_HOOK(&daAlink_c::execute, LinkExecute);
+ *   DEFINE_HOOK_SYMBOL("daAlink_hookshotAtHitCallBack",
+ *       void(fopAc_ac_c*, dCcD_GObjInf*, fopAc_ac_c*, dCcD_GObjInf*), HookshotHit);
+ *
+ *   mods::hook::add_pre<LinkExecute>(on_link_execute);
+ *
+ * DEFINE_HOOK_SYMBOL names may be the platform mangled name (dlopen convention, no Mach-O
+ * leading underscore) or the demangled qualified display name; overloaded display names are
+ * ambiguous and need the mangled form.
+ */
+#if defined(__GNUC__) && !defined(__clang__) && defined(__ELF__)
+#define DEFINE_HOOK(target, alias)                                                                 \
+    MOD_META_RECORD static constinit auto mod_meta_hook_##alias =                                  \
+        ::mods::detail::make_local_hook_record<(target), ::mods::FixedString{#target}>();          \
+    struct alias : ::mods::Hook<(target)> {                                                        \
+        static void* resolved_target() { return mod_meta_hook_##alias.resolved; }                  \
+    }
+#else
+#define DEFINE_HOOK(target, alias)                                                                 \
+    [[maybe_unused]] static const void* const mod_meta_hook_##alias =                              \
+        &::mods::detail::HookRecordFor<(target), ::mods::FixedString{#target}>::Holder::record;    \
+    struct alias : ::mods::Hook<(target)> {                                                        \
+        static void* resolved_target() {                                                           \
+            return ::mods::detail::HookRecordFor<(target),                                         \
+                ::mods::FixedString{#target}>::Holder::record.resolved;                            \
+        }                                                                                          \
+    }
+#endif
+
+#define DEFINE_HOOK_SYMBOL(name, sig, alias)                                                       \
+    MOD_META_RECORD static constinit auto mod_meta_hook_##alias =                                  \
+        ::mods::detail::make_hook_name_record<::mods::FixedString{name}>();                        \
+    struct alias : ::mods::NamedHook<::mods::FixedString{name}, sig> {                             \
+        static void* resolved_target() { return mod_meta_hook_##alias.resolved; }                  \
+    }
+
+namespace hook {
+
+template <class Entry>
+ModResult install(const HookService* hooks) {
+    if (hooks == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+
+    Entry::hooks = hooks;
+    if (Entry::target == nullptr) {
+        void* resolved = Entry::resolved_target();
+        if (resolved == nullptr) {
+            return MOD_UNAVAILABLE;
+        }
+        Entry::target = resolved;
+    }
+    return hooks->install(mod_ctx, Entry::target, reinterpret_cast<void*>(Entry::trampoline),
+        reinterpret_cast<void**>(&Entry::g_orig));
+}
+
+template <class Entry>
+ModResult install() {
+    return install<Entry>(svc_hook);
+}
+
+template <class Entry>
+ModResult add_pre(
+    const HookService* hooks, HookPreFn callback, const HookOptions* options = nullptr) {
+    const ModResult installed = install<Entry>(hooks);
+    if (installed != MOD_OK) {
+        return installed;
+    }
+
+    return hooks->add_pre(mod_ctx, Entry::target, callback, options);
+}
+
+template <class Entry>
+ModResult add_pre(HookPreFn callback, const HookOptions* options = nullptr) {
+    return add_pre<Entry>(svc_hook, callback, options);
+}
+
+template <class Entry>
+ModResult add_post(
+    const HookService* hooks, HookPostFn callback, const HookOptions* options = nullptr) {
+    const ModResult installed = install<Entry>(hooks);
+    if (installed != MOD_OK) {
+        return installed;
+    }
+
+    return hooks->add_post(mod_ctx, Entry::target, callback, options);
+}
+
+template <class Entry>
+ModResult add_post(HookPostFn callback, const HookOptions* options = nullptr) {
+    return add_post<Entry>(svc_hook, callback, options);
+}
+
+template <class Entry>
+ModResult replace(
+    const HookService* hooks, HookReplaceFn callback, const HookOptions* options = nullptr) {
+    const ModResult installed = install<Entry>(hooks);
+    if (installed != MOD_OK) {
+        return installed;
+    }
+
+    return hooks->replace(mod_ctx, Entry::target, callback, options);
+}
+
+template <class Entry>
+ModResult replace(HookReplaceFn callback, const HookOptions* options = nullptr) {
+    return replace<Entry>(svc_hook, callback, options);
+}
+
+template <class Entry>
+ModResult uninstall(const HookService* hooks) {
+    if (hooks == nullptr || !SERVICE_HAS(hooks, HookService, uninstall) ||
+        hooks->uninstall == nullptr || Entry::target == nullptr)
+    {
+        return MOD_UNAVAILABLE;
+    }
+
+    const ModResult result =
+        hooks->uninstall(mod_ctx, Entry::target, reinterpret_cast<void**>(&Entry::g_orig));
+    if (result == MOD_OK) {
+        Entry::hooks = nullptr;
+        Entry::g_orig = nullptr;
+    }
+    return result;
+}
+
+template <class Entry>
+ModResult uninstall() {
+    return uninstall<Entry>(svc_hook);
+}
+
+}  // namespace hook
+}  // namespace mods
diff --git a/include/mods/svc/host.h b/sdk/include/mods/svc/host.h
similarity index 79%
rename from include/mods/svc/host.h
rename to sdk/include/mods/svc/host.h
index 43c19cadfb..2b751f34c3 100644
--- a/include/mods/svc/host.h
+++ b/sdk/include/mods/svc/host.h
@@ -1,15 +1,19 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
 
 /*
  * The host service: the calling mod's identity and its runtime interface to the loader.
  * Always available; every other service can be reached from it.
  */
 
-#define HOST_SERVICE_ID "dev.twilitrealm.dusklight.host"
+#define HOST_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "host"
 #define HOST_SERVICE_MAJOR 2u
-#define HOST_SERVICE_MINOR 0u
+#define HOST_SERVICE_MINOR 2u
 
 /*
  * Ignore unknown values: later service minors may add events.
@@ -91,14 +95,25 @@ typedef struct HostService {
     ModResult (*watch_mod_lifecycle)(
         ModContext* ctx, ModLifecycleFn fn, void* user_data, uint64_t* out_handle);
     ModResult (*unwatch_mod_lifecycle)(ModContext* ctx, uint64_t handle);
+
+    /* Minor version 1 */
+
+    /*
+     * Read-only directory containing this platform's packaged native runtime: the mod module
+     * and any RUNTIME_LIBRARIES. The path is absolute and remains valid until mod_shutdown
+     * returns. Libraries loaded dynamically from here are owned by the mod and must be unloaded
+     * during mod_shutdown.
+     */
+    const char* (*native_dir)(ModContext* ctx);
+
+    /* Minor version 2 */
+
+    /*
+     * A persistent writable directory reserved for the calling mod, created on first use.
+     *
+     * The returned path remains valid until mod_shutdown returns. *out_path is null on failure.
+     */
+    ModResult (*data_dir)(ModContext* ctx, const char** out_path);
 } HostService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<HostService> {
-    static constexpr const char* id = HOST_SERVICE_ID;
-    static constexpr uint16_t major_version = HOST_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(HostService, svc_host, HOST_SERVICE_ID, HOST_SERVICE_MAJOR, HOST_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/http.h b/sdk/include/mods/svc/http.h
new file mode 100644
index 0000000000..2c880b3b80
--- /dev/null
+++ b/sdk/include/mods/svc/http.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define HTTP_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "http"
+#define HTTP_SERVICE_MAJOR 1u
+#define HTTP_SERVICE_MINOR 0u
+
+/* Handle for an in-flight request. 0 is never a valid handle. */
+typedef uint64_t HttpRequestHandle;
+
+typedef enum HttpMethod {
+    HTTP_METHOD_GET = 0,
+    HTTP_METHOD_POST = 1,
+    HTTP_METHOD_HEAD = 2,
+} HttpMethod;
+
+/* Transport-level outcome. HTTP status errors are reported through status_code. */
+typedef enum HttpError {
+    HTTP_ERROR_NONE = 0,
+    HTTP_ERROR_INVALID_URL = 1,
+    HTTP_ERROR_UNSUPPORTED_SCHEME = 2,
+    HTTP_ERROR_TIMEOUT = 3,
+    HTTP_ERROR_TOO_LARGE = 4,
+    HTTP_ERROR_CANCELED = 5,
+    HTTP_ERROR_IO = 6,
+    HTTP_ERROR_NETWORK = 7,
+} HttpError;
+
+typedef struct HttpHeader {
+    const char* name;
+    const char* value;
+} HttpHeader;
+
+typedef struct HttpRequestDesc {
+    uint32_t struct_size;
+    HttpMethod method;
+    const char* url;
+    const HttpHeader* headers;
+    uint32_t header_count;
+    /* Request body; POST only. */
+    const void* body;
+    size_t body_size;
+    /* Absolute destination under this mod's data_dir or mod_dir, or NULL for an in-memory body.
+     * GET and POST only. */
+    const char* download_path;
+    uint32_t connect_timeout_ms; /* 0 = 10 seconds */
+    uint32_t idle_timeout_ms;    /* 0 = 10 seconds without network progress */
+    uint32_t total_timeout_ms;   /* 0 = no total timeout */
+    size_t max_body_bytes;       /* 0 = 1 MiB; ignored for downloads */
+} HttpRequestDesc;
+
+#define HTTP_REQUEST_DESC_INIT                                                                     \
+    {sizeof(HttpRequestDesc), HTTP_METHOD_GET, NULL, NULL, 0u, NULL, 0u, NULL, 0u, 0u, 0u, 0u}
+
+/* Snapshot valid only for the duration of the completion callback. */
+typedef struct HttpResult {
+    uint32_t struct_size;
+    HttpError error;
+    const char* error_message;
+    int32_t status_code;
+    const HttpHeader* headers;
+    uint32_t header_count;
+    const void* body;
+    size_t body_size;
+    /* Published absolute destination, or NULL unless a download succeeded. */
+    const char* download_path;
+} HttpResult;
+
+/* Runs on the game thread exactly once, unless the calling mod begins deactivation first. */
+typedef void (*HttpCompleteFn)(
+    ModContext* ctx, HttpRequestHandle request, const HttpResult* result, void* user_data);
+
+typedef struct HttpProgress {
+    uint32_t struct_size;
+    uint64_t completed_bytes;
+    uint64_t total_bytes;
+    bool total_known;
+} HttpProgress;
+
+#define HTTP_PROGRESS_INIT {sizeof(HttpProgress), 0u, 0u, false}
+
+typedef struct HttpService {
+    ServiceHeader header;
+
+    /* Starts an asynchronous HTTPS request. */
+    ModResult (*request)(ModContext* ctx, const HttpRequestDesc* desc, HttpCompleteFn fn,
+        void* user_data, HttpRequestHandle* out_handle);
+    ModResult (*progress)(ModContext* ctx, HttpRequestHandle request, HttpProgress* out_progress);
+    /* Requests cancellation. The completion callback still runs if the mod remains active. */
+    ModResult (*cancel)(ModContext* ctx, HttpRequestHandle request);
+} HttpService;
+
+MOD_DECLARE_SERVICE(HttpService, svc_http, HTTP_SERVICE_ID, HTTP_SERVICE_MAJOR, HTTP_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/http.hpp b/sdk/include/mods/svc/http.hpp
new file mode 100644
index 0000000000..906bf3d0d2
--- /dev/null
+++ b/sdk/include/mods/svc/http.hpp
@@ -0,0 +1,204 @@
+#pragma once
+
+#include <mods/svc/http.h>
+
+#include <algorithm>
+#include <cctype>
+#include <cstdint>
+#include <functional>
+#include <limits>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace mods::http {
+
+struct Header {
+    std::string name;
+    std::string value;
+};
+
+struct Request {
+    HttpMethod method = HTTP_METHOD_GET;
+    std::string url;
+    std::vector<Header> headers;
+    std::string body;
+    std::string downloadPath;
+    uint32_t connectTimeoutMs = 0;
+    uint32_t idleTimeoutMs = 0;
+    uint32_t totalTimeoutMs = 0;
+    size_t maxBodyBytes = 0;
+};
+
+struct Response {
+    HttpError error = HTTP_ERROR_NETWORK;
+    std::string errorMessage;
+    int statusCode = 0;
+    std::vector<Header> headers;
+    std::vector<uint8_t> body;
+    std::string downloadPath;
+
+    bool ok() const { return error == HTTP_ERROR_NONE && statusCode >= 200 && statusCode < 300; }
+
+    const std::string* header(std::string_view name) const {
+        const auto equal = [](std::string_view left, std::string_view right) {
+            return left.size() == right.size() &&
+                   std::equal(left.begin(), left.end(), right.begin(), [](char a, char b) {
+                       return std::tolower(static_cast<unsigned char>(a)) ==
+                              std::tolower(static_cast<unsigned char>(b));
+                   });
+        };
+        const auto iter = std::find_if(headers.begin(), headers.end(),
+            [&](const Header& value) { return equal(value.name, name); });
+        return iter != headers.end() ? &iter->value : nullptr;
+    }
+};
+
+namespace detail {
+
+struct Completion {
+    HttpRequestHandle handle = 0;
+    std::function<void(Response)> callback;
+};
+
+inline std::unordered_map<HttpRequestHandle, std::unique_ptr<Completion>> completions;
+
+inline void complete(ModContext*, HttpRequestHandle handle, const HttpResult* raw, void* userData) {
+    const auto iter = completions.find(handle);
+    if (iter == completions.end() || iter->second.get() != userData) {
+        return;
+    }
+    auto completion = std::move(iter->second);
+    completions.erase(iter);
+
+    Response response;
+    if (raw != nullptr) {
+        response.error = raw->error;
+        response.errorMessage = raw->error_message != nullptr ? raw->error_message : "";
+        response.statusCode = raw->status_code;
+        response.headers.reserve(raw->header_count);
+        for (uint32_t i = 0; i < raw->header_count; ++i) {
+            response.headers.push_back({
+                .name = raw->headers[i].name != nullptr ? raw->headers[i].name : "",
+                .value = raw->headers[i].value != nullptr ? raw->headers[i].value : "",
+            });
+        }
+        if (raw->body != nullptr && raw->body_size != 0) {
+            const auto* begin = static_cast<const uint8_t*>(raw->body);
+            response.body.assign(begin, begin + raw->body_size);
+        }
+        response.downloadPath = raw->download_path != nullptr ? raw->download_path : "";
+    }
+    if (completion->callback) {
+        completion->callback(std::move(response));
+    }
+}
+
+}  // namespace detail
+
+class Pending {
+public:
+    Pending() = default;
+    Pending(HttpRequestHandle handle, ModResult result) : mHandle{handle}, mResult{result} {}
+    ~Pending() { reset(); }
+    Pending(const Pending&) = delete;
+    Pending& operator=(const Pending&) = delete;
+    Pending(Pending&& other) noexcept { *this = std::move(other); }
+    Pending& operator=(Pending&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+
+    explicit operator bool() const {
+        if (mResult != MOD_OK || mHandle == 0 || svc_http == nullptr ||
+            !detail::completions.contains(mHandle))
+        {
+            return false;
+        }
+        HttpProgress value = HTTP_PROGRESS_INIT;
+        return svc_http->progress(mod_ctx, mHandle, &value) == MOD_OK;
+    }
+    ModResult result() const { return mResult; }
+    HttpRequestHandle handle() const { return mHandle; }
+
+    HttpProgress progress() const {
+        HttpProgress value = HTTP_PROGRESS_INIT;
+        if (mHandle != 0 && svc_http != nullptr) {
+            svc_http->progress(mod_ctx, mHandle, &value);
+        }
+        return value;
+    }
+
+    void cancel() {
+        if (mHandle != 0 && svc_http != nullptr) {
+            if (svc_http->cancel(mod_ctx, mHandle) != MOD_OK) {
+                detail::completions.erase(mHandle);
+            }
+        }
+    }
+
+    void detach() { mHandle = 0; }
+
+private:
+    void reset() {
+        cancel();
+        mHandle = 0;
+    }
+
+    HttpRequestHandle mHandle = 0;
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline Pending request(const Request& request, std::function<void(Response)> callback) {
+    if (svc_http == nullptr) {
+        return {0, MOD_UNAVAILABLE};
+    }
+    if (!callback) {
+        return {0, MOD_INVALID_ARGUMENT};
+    }
+
+    if (request.headers.size() > std::numeric_limits<uint32_t>::max()) {
+        return {0, MOD_INVALID_ARGUMENT};
+    }
+    std::vector<HttpHeader> headers;
+    headers.reserve(request.headers.size());
+    for (const auto& header : request.headers) {
+        headers.push_back({
+            .name = header.name.c_str(),
+            .value = header.value.c_str(),
+        });
+    }
+    HttpRequestDesc desc = HTTP_REQUEST_DESC_INIT;
+    desc.method = request.method;
+    desc.url = request.url.c_str();
+    desc.headers = headers.empty() ? nullptr : headers.data();
+    desc.header_count = static_cast<uint32_t>(headers.size());
+    desc.body = request.body.empty() ? nullptr : request.body.data();
+    desc.body_size = request.body.size();
+    desc.download_path = request.downloadPath.empty() ? nullptr : request.downloadPath.c_str();
+    desc.connect_timeout_ms = request.connectTimeoutMs;
+    desc.idle_timeout_ms = request.idleTimeoutMs;
+    desc.total_timeout_ms = request.totalTimeoutMs;
+    desc.max_body_bytes = request.maxBodyBytes;
+
+    auto completion = std::make_unique<detail::Completion>();
+    auto* userData = completion.get();
+    completion->callback = std::move(callback);
+    HttpRequestHandle handle = 0;
+    const auto result = svc_http->request(mod_ctx, &desc, detail::complete, userData, &handle);
+    if (result != MOD_OK) {
+        return {0, result};
+    }
+    completion->handle = handle;
+    detail::completions.emplace(handle, std::move(completion));
+    return {handle, result};
+}
+
+}  // namespace mods::http
diff --git a/sdk/include/mods/svc/item.h b/sdk/include/mods/svc/item.h
new file mode 100644
index 0000000000..58cf7743e4
--- /dev/null
+++ b/sdk/include/mods/svc/item.h
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define ITEM_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "item"
+#define ITEM_SERVICE_MAJOR 2u
+#define ITEM_SERVICE_MINOR 3u
+
+/* 0 is never a valid handle. */
+typedef uint64_t ItemCheckHandle;
+typedef uint64_t ItemGiveHandle;
+
+/*
+ * Item check resolution and inventory grants.
+ *
+ * Check names are case-sensitive. Resolvers must be free of side effects because previews may be
+ * resolved repeatedly. For checks representing a non-item side effect, vanilla_item is 0xFF:
+ * resolving to 0xFF preserves that side effect, while resolving to another item replaces it.
+ *
+ * Registrations and pending grants are removed when the calling mod is detached. Callbacks run on
+ * the game thread. Check names are listed in <mods/items.h>.
+ */
+
+/* Host-owned callback data, valid only for the duration of the callback. */
+typedef struct ItemCheckInfo {
+    const char* name;
+    const void* giver_actor; /* fopAc_ac_c*, or NULL when unavailable */
+    uint8_t vanilla_item;
+    uint8_t current_item;
+    uint8_t current_display_item;
+    bool was_resolved;
+} ItemCheckInfo;
+
+typedef struct ItemCheckResolution {
+    uint8_t item;
+    uint8_t display_item; /* leave unset (0xFF/NONE) to use the item */
+    bool was_resolved;
+} ItemCheckResolution;
+
+/* Return true and write out_result to replace the result, or false to leave it unchanged. */
+typedef bool (*ItemCheckResolveFn)(
+    ModContext* ctx, const ItemCheckInfo* info, ItemCheckResolution* out_result, void* user_data);
+
+typedef enum ItemGiveOrigin {
+    ITEM_GIVE_ORIGIN_GAME = 0,
+    ITEM_GIVE_ORIGIN_QUEUE = 1,
+    ITEM_GIVE_ORIGIN_QUEUE_SILENT = 2,
+} ItemGiveOrigin;
+
+/* Host-owned callback data, valid only for the duration of the callback. */
+typedef struct ItemGiveInfo {
+    const char* check_name;  /* NULL when the grant is not attributed to a check */
+    const void* giver_actor; /* fopAc_ac_c*, or NULL when unavailable */
+    uint8_t item;
+    uint8_t origin; /* ItemGiveOrigin */
+} ItemGiveInfo;
+
+typedef void (*ItemGiveObserveFn)(ModContext* ctx, const ItemGiveInfo* info, void* user_data);
+
+enum {
+    /* Apply the inventory change without a get-item demo. */
+    ITEM_GIVE_SILENT = 1u << 0,
+    /* Resolve item_no as the named check's vanilla item when the queue entry is dispatched. */
+    ITEM_GIVE_RESOLVE = 1u << 1,
+};
+
+typedef struct ItemService {
+    ServiceHeader header;
+
+    /* Set or replace the calling mod's fixed override for name. */
+    ModResult (*set_check_override)(ModContext* ctx, const char* name, uint8_t item_no);
+
+    ModResult (*clear_check_override)(ModContext* ctx, const char* name);
+
+    /* Register for name, or for every check when name is NULL. out_handle may be NULL. */
+    ModResult (*set_check_resolver)(ModContext* ctx, const char* name, ItemCheckResolveFn fn,
+        void* user_data, ItemCheckHandle* out_handle);
+
+    ModResult (*clear_check_resolver)(ModContext* ctx, ItemCheckHandle handle);
+
+    /* Resolve a live preview without granting an item or notifying give observers. */
+    ModResult (*resolve_check)(
+        ModContext* ctx, const char* name, uint8_t vanilla_item, uint8_t* out_item);
+
+    /*
+     * Add a grant to the global FIFO. check_name may be NULL unless ITEM_GIVE_RESOLVE is set.
+     * Entries wait until gameplay is in a safe state and are cleared when the active save slot
+     * changes.
+     */
+    ModResult (*give_item)(
+        ModContext* ctx, const char* check_name, uint8_t item_no, uint32_t flags);
+
+    /* Observe inventory grants. out_handle may be NULL. */
+    ModResult (*observe_gives)(
+        ModContext* ctx, ItemGiveObserveFn fn, void* user_data, ItemGiveHandle* out_handle);
+
+    ModResult (*unobserve_gives)(ModContext* ctx, ItemGiveHandle handle);
+
+    /* Minor version 2 */
+
+    /* Resolve a live preview (item + display item) without granting an item or notifying give
+     * observers. */
+    ModResult (*resolve_check_full)(ModContext* ctx, const char* name, uint8_t vanilla_item,
+        ItemCheckResolution* out_resolution);
+} ItemService;
+
+MOD_DECLARE_SERVICE(ItemService, svc_item, ITEM_SERVICE_ID, ITEM_SERVICE_MAJOR, ITEM_SERVICE_MINOR);
diff --git a/include/mods/svc/log.h b/sdk/include/mods/svc/log.h
similarity index 77%
rename from include/mods/svc/log.h
rename to sdk/include/mods/svc/log.h
index bad94f9503..2401b4dccf 100644
--- a/include/mods/svc/log.h
+++ b/sdk/include/mods/svc/log.h
@@ -1,13 +1,17 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
 
 /*
  * Logging into the game's console and log files. Messages are attributed to the calling mod
  * (prefixed with its ID).
  */
 
-#define LOG_SERVICE_ID "dev.twilitrealm.dusklight.log"
+#define LOG_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "log"
 #define LOG_SERVICE_MAJOR 1u
 #define LOG_SERVICE_MINOR 0u
 
@@ -36,12 +40,4 @@ typedef struct LogService {
     void (*error)(ModContext* ctx, const char* message);
 } LogService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<LogService> {
-    static constexpr const char* id = LOG_SERVICE_ID;
-    static constexpr uint16_t major_version = LOG_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(LogService, svc_log, LOG_SERVICE_ID, LOG_SERVICE_MAJOR, LOG_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/log.hpp b/sdk/include/mods/svc/log.hpp
new file mode 100644
index 0000000000..372cf06d8d
--- /dev/null
+++ b/sdk/include/mods/svc/log.hpp
@@ -0,0 +1,46 @@
+#pragma once
+
+#if !defined(DUSK_BUILDING_GAME) && !defined(DUSK_MOD_FEATURE_FMT)
+#error "mods/svc/log.hpp requires add_mod(... FEATURES fmt)"
+#endif
+
+#include <mods/svc/log.h>
+
+#include <fmt/format.h>
+
+#include <utility>
+
+namespace mods::log {
+
+template <typename... Args>
+void write(LogLevel level, fmt::format_string<Args...> formatString, Args&&... args) {
+    const auto message = fmt::format(formatString, std::forward<Args>(args)...);
+    svc_log->write(mod_ctx, level, message.c_str());
+}
+
+template <typename... Args>
+void trace(fmt::format_string<Args...> formatString, Args&&... args) {
+    write(LOG_LEVEL_TRACE, formatString, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+void debug(fmt::format_string<Args...> formatString, Args&&... args) {
+    write(LOG_LEVEL_DEBUG, formatString, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+void info(fmt::format_string<Args...> formatString, Args&&... args) {
+    write(LOG_LEVEL_INFO, formatString, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+void warn(fmt::format_string<Args...> formatString, Args&&... args) {
+    write(LOG_LEVEL_WARN, formatString, std::forward<Args>(args)...);
+}
+
+template <typename... Args>
+void error(fmt::format_string<Args...> formatString, Args&&... args) {
+    write(LOG_LEVEL_ERROR, formatString, std::forward<Args>(args)...);
+}
+
+}  // namespace mods::log
diff --git a/sdk/include/mods/svc/message.h b/sdk/include/mods/svc/message.h
new file mode 100644
index 0000000000..d3833d904e
--- /dev/null
+++ b/sdk/include/mods/svc/message.h
@@ -0,0 +1,126 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define MESSAGE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "message"
+#define MESSAGE_SERVICE_MAJOR 1u
+#define MESSAGE_SERVICE_MINOR 1u
+
+typedef uint16_t MessageId;
+typedef uint64_t MessageHandle;
+typedef uint64_t MessageOverrideHandle;
+
+/* INF1 entry data */
+typedef struct MessageEntryData {
+    uint8_t bytes[20];
+} MessageEntryData;
+static_assert(sizeof(MessageEntryData) == 20);
+
+/* INF1 box kind (offset 0x09): message screen class */
+typedef enum MessageBoxKind {
+    MESSAGE_BOX_TALK = 0,         /* ordinary dialogue box */
+    MESSAGE_BOX_DEMO_CAPTION = 1, /* boxless cutscene caption */
+    MESSAGE_BOX_SIGN = 2,         /* signs and posted notices */
+    MESSAGE_BOX_PLAIN = 5,        /* boxless system text */
+    MESSAGE_BOX_KANBAN = 6,       /* signboard screen class; unused */
+    MESSAGE_BOX_STAFF_ROLL = 7,
+    MESSAGE_BOX_LIGHT_SPIRIT = 8, /* spirit text window and glow */
+    MESSAGE_BOX_ITEM_GET = 9,     /* centered item-get box */
+    MESSAGE_BOX_ITEM_NAME = 11,   /* UI string fetch, no box */
+    MESSAGE_BOX_PLACE_NAME = 12,  /* area intro banner */
+    MESSAGE_BOX_MIDNA = 13,       /* Midna dialogue colors and glow */
+    MESSAGE_BOX_ANIMAL = 14,      /* wolf-form animal speech glow */
+    MESSAGE_BOX_NOTICE = 15,      /* floating gameplay notice; can't be used during dialogue */
+    MESSAGE_BOX_SAVE = 16,        /* save and memory card prompts */
+    MESSAGE_BOX_HOWL = 17,        /* howling stone UI */
+    MESSAGE_BOX_BOSS_NAME = 19,   /* boss intro banner */
+} MessageBoxKind;
+
+/* INF1 draw type (offset 0x0A): text pacing */
+typedef enum MessageDrawType {
+    MESSAGE_DRAW_TYPED = 0,         /* types per-character; A skips typing */
+    MESSAGE_DRAW_INSTANT = 1,       /* whole page at once (menus, prompts) */
+    MESSAGE_DRAW_TYPED_NO_SKIP = 2, /* types per-character; A does not skip */
+    MESSAGE_DRAW_FADE = 3,          /* page fades in */
+    MESSAGE_DRAW_UI_NAME = 4,       /* UI string fetch (item names), no box pacing */
+    MESSAGE_DRAW_TYPED_SLOW = 5,    /* weighted slow typing (light spirit speech) */
+    MESSAGE_DRAW_UI_ACTION = 7,     /* UI string fetch (action button labels) */
+    MESSAGE_DRAW_FADE_SLOW = 9,     /* slow page fade (staff credits) */
+} MessageDrawType;
+
+/* INF1 box position (offset 0x0B) */
+typedef enum MessageBoxPosition {
+    MESSAGE_POSITION_BOTTOM = 0,
+    MESSAGE_POSITION_TOP = 1,
+    MESSAGE_POSITION_MIDDLE = 2,
+    MESSAGE_POSITION_AUTO = 3, /* top or bottom, avoiding the speaker on screen */
+} MessageBoxPosition;
+
+/* Applies to both the text and gradient colors. */
+typedef enum MessageTextColor {
+    MESSAGE_COLOR_DEFAULT = 0, /* box default */
+    MESSAGE_COLOR_RED = 1,     /* 0xF07878 */
+    MESSAGE_COLOR_GREEN = 2,   /* 0xAADC8C */
+    MESSAGE_COLOR_BLUE = 3,    /* 0xA0B4DC */
+    MESSAGE_COLOR_YELLOW = 4,  /* 0xDCDC82 */
+    MESSAGE_COLOR_SKY = 5,     /* 0xB4C8E6 */
+    MESSAGE_COLOR_PURPLE = 6,  /* 0xC8A0DC */
+    MESSAGE_COLOR_WHITE = 7,   /* 0xFFFFFF */
+    MESSAGE_COLOR_ORANGE = 8,  /* 0xDCAA78 */
+} MessageTextColor;
+
+/* Message text language. 5 (Dutch) is unused. */
+typedef enum MessageLanguage {
+    MESSAGE_LANGUAGE_ENGLISH = 0,
+    MESSAGE_LANGUAGE_GERMAN = 1,
+    MESSAGE_LANGUAGE_FRENCH = 2,
+    MESSAGE_LANGUAGE_SPANISH = 3,
+    MESSAGE_LANGUAGE_ITALIAN = 4,
+    MESSAGE_LANGUAGE_JAPANESE = 6,
+} MessageLanguage;
+
+typedef struct MessageVariantData {
+    uint8_t language; /* MessageLanguage */
+    MessageEntryData entry;
+    const uint8_t* text;
+    size_t text_size;
+} MessageVariantData;
+
+typedef struct MessageTextData {
+    const uint8_t* text;
+    size_t text_size;
+} MessageTextData;
+
+typedef struct MessageOverrideContext {
+    uint16_t group;
+    uint16_t message_id;
+    uint8_t language; /* MessageLanguage */
+    const uint8_t* original_text;
+    size_t original_text_size;
+} MessageOverrideContext;
+
+/* Return true with a valid out_text to override, or false to try the next registration. */
+typedef bool (*MessageOverrideFn)(ModContext* ctx, const MessageOverrideContext* message,
+    MessageTextData* out_text, void* user_data);
+
+typedef struct MessageService {
+    ServiceHeader header;
+
+    ModResult (*override_message)(ModContext* ctx, uint16_t group, uint16_t message_id,
+        uint8_t language, const uint8_t* text, size_t text_size, MessageOverrideHandle* out_handle);
+    ModResult (*override_message_fn)(ModContext* ctx, uint16_t group, uint16_t message_id,
+        uint8_t language, MessageOverrideFn fn, void* user_data, MessageOverrideHandle* out_handle);
+    ModResult (*remove_override)(ModContext* ctx, MessageOverrideHandle handle);
+
+    ModResult (*register_message)(ModContext* ctx, uint16_t group,
+        const MessageVariantData* variants, size_t variant_count, MessageId* out_id,
+        MessageHandle* out_handle);
+    ModResult (*remove_message)(ModContext* ctx, MessageHandle handle);
+} MessageService;
+
+MOD_DECLARE_SERVICE(
+    MessageService, svc_message, MESSAGE_SERVICE_ID, MESSAGE_SERVICE_MAJOR, MESSAGE_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/net.h b/sdk/include/mods/svc/net.h
new file mode 100644
index 0000000000..9202ff50ad
--- /dev/null
+++ b/sdk/include/mods/svc/net.h
@@ -0,0 +1,145 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define NET_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "net"
+#define NET_SERVICE_MAJOR 1u
+#define NET_SERVICE_MINOR 0u
+
+/** 0 is never a valid handle. */
+typedef uint64_t NetHandle;
+
+typedef enum NetError {
+    NET_ERROR_NONE = 0,
+    NET_ERROR_INVALID_ENDPOINT = 1,
+    NET_ERROR_RESOLVE = 2,
+    NET_ERROR_TIMEOUT = 3,
+    NET_ERROR_REFUSED = 4,
+    NET_ERROR_UNREACHABLE = 5,
+    NET_ERROR_RESET = 6,
+    NET_ERROR_ADDRESS_IN_USE = 7,
+    NET_ERROR_PERMISSION = 8,
+    NET_ERROR_TOO_LARGE = 9,
+    NET_ERROR_CANCELED = 10,
+    NET_ERROR_NETWORK = 11,
+} NetError;
+
+#define NET_ENDPOINT_MAX 80
+/** NUL-terminated tcp://host:port or udp://host:port endpoint. */
+typedef struct NetEndpoint {
+    char text[NET_ENDPOINT_MAX];
+} NetEndpoint;
+
+typedef struct NetConnectDesc {
+    uint32_t struct_size;
+    /** TCP endpoint. Hostnames and IP literals are accepted. */
+    const char* endpoint;
+    /** 0 defaults to 10 seconds. Resolution is included. */
+    uint32_t connect_timeout_ms;
+    /** 0 defaults to 5 seconds for flush and peer EOF. */
+    uint32_t close_timeout_ms;
+    /** 0 defaults to 1 MiB. Maximum of 8 MiB. */
+    size_t max_send_queue_bytes;
+    bool no_delay;
+    /** Sampled when each event is polled. */
+    void* user_data;
+} NetConnectDesc;
+
+#define NET_CONNECT_DESC_INIT {sizeof(NetConnectDesc), NULL, 0u, 0u, 0u, true, NULL}
+
+typedef struct NetListenDesc {
+    uint32_t struct_size;
+    /** TCP endpoint with an IP literal. Port 0 requests an ephemeral port. */
+    const char* bind;
+    uint32_t close_timeout_ms;
+    size_t max_send_queue_bytes;
+    bool no_delay;
+    void* user_data;
+} NetListenDesc;
+
+#define NET_LISTEN_DESC_INIT {sizeof(NetListenDesc), NULL, 0u, 0u, true, NULL}
+
+typedef struct NetDatagramDesc {
+    uint32_t struct_size;
+    /** UDP endpoint with an IP literal. Port 0 requests an ephemeral port. */
+    const char* bind;
+    size_t max_send_queue_bytes;
+    void* user_data;
+} NetDatagramDesc;
+
+#define NET_DATAGRAM_DESC_INIT {sizeof(NetDatagramDesc), NULL, 0u, NULL}
+
+typedef enum NetEventType {
+    NET_EVENT_NONE = 0,
+    NET_EVENT_CONNECTED = 1,
+    NET_EVENT_ACCEPTED = 2,
+    NET_EVENT_STREAM_DATA = 3,
+    NET_EVENT_DATAGRAM = 4,
+    NET_EVENT_DROPPED = 5,
+    NET_EVENT_RESOLVED = 6,
+    NET_EVENT_CLOSED = 7,
+} NetEventType;
+
+typedef struct NetEvent {
+    uint32_t struct_size;
+    NetEventType type;
+    /** Source handle. A CLOSED or RESOLVED handle is invalid after poll_event returns it. */
+    NetHandle handle;
+    void* user_data;
+    NetHandle accepted;
+    /** Peer, datagram source, or resolved endpoint as applicable. */
+    NetEndpoint endpoint;
+    /** Valid until this mod's next poll_event call or deactivation. */
+    const void* data;
+    size_t size;
+    uint32_t dropped;
+    NetError error;
+    /** Never NULL. Valid until this mod's next poll_event call or deactivation. */
+    const char* error_message;
+} NetEvent;
+
+#define NET_EVENT_INIT                                                                             \
+    {sizeof(NetEvent), NET_EVENT_NONE, 0u, NULL, 0u, {{0}}, NULL, 0u, 0u, NET_ERROR_NONE, ""}
+
+typedef struct NetStats {
+    uint32_t struct_size;
+    size_t queued_send_bytes;
+    uint64_t inbound_dropped;
+    uint64_t send_failures;
+    uint64_t bytes_sent;
+    uint64_t bytes_received;
+} NetStats;
+
+#define NET_STATS_INIT {sizeof(NetStats), 0u, 0u, 0u, 0u, 0u}
+
+typedef struct NetService {
+    ServiceHeader header;
+
+    /** Starts an asynchronous TCP connection. */
+    ModResult (*connect)(ModContext* ctx, const NetConnectDesc* desc, NetHandle* out_handle);
+    /** Opens a TCP listener and returns its local endpoint. */
+    ModResult (*listen)(ModContext* ctx, const NetListenDesc* desc, NetHandle* out_handle,
+        NetEndpoint* out_local, NetError* out_error);
+    /** Opens a UDP socket and returns its local endpoint. */
+    ModResult (*open_datagram)(ModContext* ctx, const NetDatagramDesc* desc, NetHandle* out_handle,
+        NetEndpoint* out_local, NetError* out_error);
+    /** Resolves a TCP or UDP endpoint asynchronously. */
+    ModResult (*resolve)(
+        ModContext* ctx, const char* endpoint, void* user_data, NetHandle* out_handle);
+    /** Returns MOD_OK and NET_EVENT_NONE when the queue is empty. */
+    ModResult (*poll_event)(ModContext* ctx, NetEvent* out_event);
+    /** Copies bytes to a connected stream's outbound queue. */
+    ModResult (*send)(ModContext* ctx, NetHandle stream, const void* data, size_t size);
+    /** Copies one datagram for a literal UDP destination. The maximum size is 65,507 bytes. */
+    ModResult (*send_to)(
+        ModContext* ctx, NetHandle socket, const char* endpoint, const void* data, size_t size);
+    ModResult (*set_user_data)(ModContext* ctx, NetHandle handle, void* user_data);
+    ModResult (*stats)(ModContext* ctx, NetHandle handle, NetStats* out_stats);
+    ModResult (*close)(ModContext* ctx, NetHandle handle);
+} NetService;
+
+MOD_DECLARE_SERVICE(NetService, svc_net, NET_SERVICE_ID, NET_SERVICE_MAJOR, NET_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/net.hpp b/sdk/include/mods/svc/net.hpp
new file mode 100644
index 0000000000..44edf4001b
--- /dev/null
+++ b/sdk/include/mods/svc/net.hpp
@@ -0,0 +1,189 @@
+#pragma once
+
+#include <mods/svc/net.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace mods::net {
+
+class Socket {
+public:
+    Socket() = default;
+    Socket(NetHandle handle, ModResult result) : mHandle{handle}, mResult{result} {}
+    ~Socket() { reset(); }
+
+    Socket(const Socket&) = delete;
+    Socket& operator=(const Socket&) = delete;
+    Socket(Socket&& other) noexcept { *this = std::move(other); }
+    Socket& operator=(Socket&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+
+    explicit operator bool() const { return mResult == MOD_OK && mHandle != 0; }
+
+    ModResult result() const { return mResult; }
+    NetHandle handle() const { return mHandle; }
+
+    ModResult send(std::span<const std::byte> bytes) const {
+        return svc_net != nullptr && mHandle != 0 ?
+                   svc_net->send(mod_ctx, mHandle, bytes.data(), bytes.size()) :
+                   MOD_UNAVAILABLE;
+    }
+
+    ModResult send_to(std::string_view endpoint, std::span<const std::byte> bytes) const {
+        if (svc_net == nullptr || mHandle == 0) {
+            return MOD_UNAVAILABLE;
+        }
+        const std::string endpointText{endpoint};
+        return svc_net->send_to(mod_ctx, mHandle, endpointText.c_str(), bytes.data(), bytes.size());
+    }
+
+    std::optional<NetStats> stats() const {
+        if (svc_net == nullptr || mHandle == 0) {
+            return std::nullopt;
+        }
+        NetStats value = NET_STATS_INIT;
+        if (svc_net->stats(mod_ctx, mHandle, &value) != MOD_OK) {
+            return std::nullopt;
+        }
+        return value;
+    }
+
+    ModResult set_user_data(void* userData) const {
+        return svc_net != nullptr && mHandle != 0 ?
+                   svc_net->set_user_data(mod_ctx, mHandle, userData) :
+                   MOD_UNAVAILABLE;
+    }
+
+    ModResult close() {
+        if (mHandle == 0) {
+            return mResult == MOD_OK ? MOD_OK : MOD_UNAVAILABLE;
+        }
+        mResult = svc_net != nullptr ? svc_net->close(mod_ctx, mHandle) : MOD_UNAVAILABLE;
+        mHandle = 0;
+        return mResult;
+    }
+
+    void detach() { mHandle = 0; }
+
+private:
+    void reset() { (void)close(); }
+
+    NetHandle mHandle = 0;
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+struct BindOutcome {
+    std::string local;
+    NetError error = NET_ERROR_NONE;
+};
+
+inline Socket connect(std::string_view endpoint, NetConnectDesc options = NET_CONNECT_DESC_INIT) {
+    if (svc_net == nullptr) {
+        return {0, MOD_UNAVAILABLE};
+    }
+    const std::string endpointText{endpoint};
+    options.struct_size = sizeof(options);
+    options.endpoint = endpointText.c_str();
+    NetHandle handle = 0;
+    const ModResult result = svc_net->connect(mod_ctx, &options, &handle);
+    return {handle, result};
+}
+
+inline Socket listen(std::string_view bind, BindOutcome* out = nullptr,
+    NetListenDesc options = NET_LISTEN_DESC_INIT) {
+    if (svc_net == nullptr) {
+        return {0, MOD_UNAVAILABLE};
+    }
+    const std::string bindText{bind};
+    options.struct_size = sizeof(options);
+    options.bind = bindText.c_str();
+    NetHandle handle = 0;
+    NetEndpoint local{};
+    NetError error = NET_ERROR_NONE;
+    const ModResult result = svc_net->listen(mod_ctx, &options, &handle, &local, &error);
+    if (out != nullptr) {
+        *out = {.local = local.text, .error = error};
+    }
+    return {handle, result};
+}
+
+inline Socket open_datagram(std::string_view bind, BindOutcome* out = nullptr,
+    NetDatagramDesc options = NET_DATAGRAM_DESC_INIT) {
+    if (svc_net == nullptr) {
+        return {0, MOD_UNAVAILABLE};
+    }
+    const std::string bindText{bind};
+    options.struct_size = sizeof(options);
+    options.bind = bindText.c_str();
+    NetHandle handle = 0;
+    NetEndpoint local{};
+    NetError error = NET_ERROR_NONE;
+    const ModResult result = svc_net->open_datagram(mod_ctx, &options, &handle, &local, &error);
+    if (out != nullptr) {
+        *out = {.local = local.text, .error = error};
+    }
+    return {handle, result};
+}
+
+inline Socket resolve(std::string_view endpoint, void* userData = nullptr) {
+    if (svc_net == nullptr) {
+        return {0, MOD_UNAVAILABLE};
+    }
+    const std::string endpointText{endpoint};
+    NetHandle handle = 0;
+    const ModResult result = svc_net->resolve(mod_ctx, endpointText.c_str(), userData, &handle);
+    return {handle, result};
+}
+
+inline Socket adopt(NetHandle accepted) {
+    return {accepted, accepted != 0 ? MOD_OK : MOD_INVALID_ARGUMENT};
+}
+
+struct Event {
+    NetEventType type = NET_EVENT_NONE;
+    NetHandle handle = 0;
+    void* userData = nullptr;
+    NetHandle accepted = 0;
+    std::string_view endpoint;
+    std::span<const std::byte> data;
+    uint32_t dropped = 0;
+    NetError error = NET_ERROR_NONE;
+    std::string_view message;
+};
+
+inline bool poll(Event& out) {
+    out = {};
+    if (svc_net == nullptr) {
+        return false;
+    }
+    NetEvent raw = NET_EVENT_INIT;
+    if (svc_net->poll_event(mod_ctx, &raw) != MOD_OK || raw.type == NET_EVENT_NONE) {
+        return false;
+    }
+    out.type = raw.type;
+    out.handle = raw.handle;
+    out.userData = raw.user_data;
+    out.accepted = raw.accepted;
+    out.endpoint = raw.endpoint.text;
+    if (raw.data != nullptr && raw.size != 0) {
+        out.data = {static_cast<const std::byte*>(raw.data), raw.size};
+    }
+    out.dropped = raw.dropped;
+    out.error = raw.error;
+    out.message = raw.error_message != nullptr ? raw.error_message : "";
+    return true;
+}
+
+}  // namespace mods::net
diff --git a/include/mods/svc/overlay.h b/sdk/include/mods/svc/overlay.h
similarity index 85%
rename from include/mods/svc/overlay.h
rename to sdk/include/mods/svc/overlay.h
index 9fc86fc850..ee4318ea4f 100644
--- a/include/mods/svc/overlay.h
+++ b/sdk/include/mods/svc/overlay.h
@@ -1,8 +1,12 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
 
-#define OVERLAY_SERVICE_ID "dev.twilitrealm.dusklight.overlay"
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define OVERLAY_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "overlay"
 #define OVERLAY_SERVICE_MAJOR 1u
 #define OVERLAY_SERVICE_MINOR 0u
 
@@ -46,12 +50,5 @@ typedef struct OverlayService {
     ModResult (*remove)(ModContext* ctx, OverlayHandle handle);
 } OverlayService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<OverlayService> {
-    static constexpr const char* id = OVERLAY_SERVICE_ID;
-    static constexpr uint16_t major_version = OVERLAY_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(
+    OverlayService, svc_overlay, OVERLAY_SERVICE_ID, OVERLAY_SERVICE_MAJOR, OVERLAY_SERVICE_MINOR);
diff --git a/include/mods/svc/resource.h b/sdk/include/mods/svc/resource.h
similarity index 77%
rename from include/mods/svc/resource.h
rename to sdk/include/mods/svc/resource.h
index 1173b2ab1d..516dcab20a 100644
--- a/include/mods/svc/resource.h
+++ b/sdk/include/mods/svc/resource.h
@@ -1,13 +1,18 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
 
 /*
  * Read-only access to the res/ tree of the calling mod's own bundle. Reload serves the new
- * bundle's contents. For writable storage, use HostService::mod_dir.
+ * bundle's contents. Use HostService::data_dir for persistent storage or HostService::mod_dir
+ * for temporary storage.
  */
 
-#define RESOURCE_SERVICE_ID "dev.twilitrealm.dusklight.resource"
+#define RESOURCE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "resource"
 #define RESOURCE_SERVICE_MAJOR 1u
 #define RESOURCE_SERVICE_MINOR 0u
 
@@ -41,12 +46,5 @@ typedef struct ResourceService {
     void (*free)(ModContext* ctx, ResourceBuffer* buffer);
 } ResourceService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<ResourceService> {
-    static constexpr const char* id = RESOURCE_SERVICE_ID;
-    static constexpr uint16_t major_version = RESOURCE_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(ResourceService, svc_resource, RESOURCE_SERVICE_ID, RESOURCE_SERVICE_MAJOR,
+    RESOURCE_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/save.h b/sdk/include/mods/svc/save.h
new file mode 100644
index 0000000000..d9eb7432be
--- /dev/null
+++ b/sdk/include/mods/svc/save.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define SAVE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "save"
+#define SAVE_SERVICE_MAJOR 1u
+#define SAVE_SERVICE_MINOR 0u
+
+/* 0 is never a valid handle. */
+typedef uint64_t SaveObserverHandle;
+
+/* Maximum combined blob size per mod and save slot. */
+#define SAVE_BLOB_BUDGET_BYTES 65536u
+
+/*
+ * Per-slot mod storage.
+ *
+ * Blobs are scoped to the calling mod and saved alongside each slot. Current-slot calls return
+ * MOD_UNAVAILABLE when no slot is active.
+ *
+ * Callbacks run on the game thread. Observer registrations are removed when the calling mod is
+ * detached.
+ */
+
+/* slot is the save-file index (0..2). */
+typedef void (*SaveEventFn)(ModContext* ctx, uint32_t slot, void* user_data);
+
+typedef struct SaveService {
+    ServiceHeader header;
+
+    /* Store a copy in the current slot. Returns MOD_UNAVAILABLE if the limit would be exceeded. */
+    ModResult (*set_blob)(ModContext* ctx, const char* name, const void* data, size_t size);
+
+    /*
+     * Read a blob from the current slot. Pass NULL for buf to query its size. Otherwise,
+     * inout_size is the buffer capacity on input and the blob size on success. Returns
+     * MOD_UNAVAILABLE if the blob does not exist.
+     */
+    ModResult (*get_blob)(ModContext* ctx, const char* name, void* buf, size_t* inout_size);
+
+    ModResult (*delete_blob)(ModContext* ctx, const char* name);
+
+    /*
+     * Register save lifecycle callbacks. At least one callback is required. on_new_save runs
+     * after clearing the slot's blobs, on_save_loaded after activating the slot, and
+     * on_save_written after a successful game save. out_handle may be NULL.
+     */
+    ModResult (*observe_saves)(ModContext* ctx, SaveEventFn on_new_save, SaveEventFn on_save_loaded,
+        SaveEventFn on_save_written, void* user_data, SaveObserverHandle* out_handle);
+
+    ModResult (*unobserve_saves)(ModContext* ctx, SaveObserverHandle handle);
+
+    /* Read the calling mod's blob from any slot. Uses the get_blob buffer contract. */
+    ModResult (*peek_blob)(
+        ModContext* ctx, uint32_t slot, const char* name, void* buf, size_t* inout_size);
+
+} SaveService;
+
+MOD_DECLARE_SERVICE(SaveService, svc_save, SAVE_SERVICE_ID, SAVE_SERVICE_MAJOR, SAVE_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/stage.h b/sdk/include/mods/svc/stage.h
new file mode 100644
index 0000000000..9dbd94cff1
--- /dev/null
+++ b/sdk/include/mods/svc/stage.h
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define STAGE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "stage"
+#define STAGE_SERVICE_MAJOR 1u
+#define STAGE_SERVICE_MINOR 0u
+
+/* 0 is never a valid handle. */
+typedef uint64_t StageActorHandle;
+
+/*
+ * Runtime edits to Stage Info (.dzs/.dzr) data.
+ */
+
+typedef struct StageService {
+    ServiceHeader header;
+
+    /*
+     * Actor Node (ACTR/TGSC/SCOB/Door) Editing:
+     * stage must be a non-empty name of at most 8 characters. room 0xff and layer -1 match any room
+     * or layer for patch and delete operations; add_actor requires a specific room. Later-loaded mods
+     * win conflicts. record_crc is the CRC-32 of the unmodified record. Registrations are removed when
+     * the calling mod is detached. out_handle may be NULL.
+     */
+    ModResult (*patch_actor)(ModContext* ctx, const char* stage, uint8_t room, int8_t layer,
+        uint32_t record_crc, const void* record, size_t record_size, StageActorHandle* out_handle);
+
+    ModResult (*delete_actor)(ModContext* ctx, const char* stage, uint8_t room, int8_t layer,
+        uint32_t record_crc, StageActorHandle* out_handle);
+
+    ModResult (*add_actor)(ModContext* ctx, const char* stage, uint8_t room, int8_t layer,
+        const void* record, size_t record_size, StageActorHandle* out_handle);
+
+    ModResult (*remove_actor_edit)(ModContext* ctx, StageActorHandle handle);
+} StageService;
+
+MOD_DECLARE_SERVICE(
+    StageService, svc_stage, STAGE_SERVICE_ID, STAGE_SERVICE_MAJOR, STAGE_SERVICE_MINOR);
diff --git a/include/mods/svc/texture.h b/sdk/include/mods/svc/texture.h
similarity index 87%
rename from include/mods/svc/texture.h
rename to sdk/include/mods/svc/texture.h
index d664c5f99d..0de813cd04 100644
--- a/include/mods/svc/texture.h
+++ b/sdk/include/mods/svc/texture.h
@@ -1,8 +1,12 @@
 #pragma once
 
-#include "mods/api.h"
+#include <mods/api.h>
 
-#define TEXTURE_SERVICE_ID "dev.twilitrealm.dusklight.texture"
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define TEXTURE_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "texture"
 #define TEXTURE_SERVICE_MAJOR 1u
 #define TEXTURE_SERVICE_MINOR 0u
 
@@ -70,19 +74,12 @@ typedef struct TextureService {
      * "tex1_{w}x{h}_{hash}_{fmt}.dds"); "_mipN" sidecars next to it are picked up automatically.
      * The file is decoded lazily on first use by the renderer.
      */
-    ModResult (*register_file)(ModContext* ctx, const char* bundle_path,
-        TextureReplacementHandle* out_handle);
+    ModResult (*register_file)(
+        ModContext* ctx, const char* bundle_path, TextureReplacementHandle* out_handle);
 
     /* Remove a replacement previously registered by the calling mod. */
     ModResult (*unregister)(ModContext* ctx, TextureReplacementHandle handle);
 } TextureService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<TextureService> {
-    static constexpr const char* id = TEXTURE_SERVICE_ID;
-    static constexpr uint16_t major_version = TEXTURE_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(
+    TextureService, svc_texture, TEXTURE_SERVICE_ID, TEXTURE_SERVICE_MAJOR, TEXTURE_SERVICE_MINOR);
diff --git a/include/mods/svc/ui.h b/sdk/include/mods/svc/ui.h
similarity index 65%
rename from include/mods/svc/ui.h
rename to sdk/include/mods/svc/ui.h
index d9f2ac669e..bcac0c53fa 100644
--- a/include/mods/svc/ui.h
+++ b/sdk/include/mods/svc/ui.h
@@ -1,22 +1,27 @@
 #pragma once
 
-#include "mods/api.h"
-#include "mods/svc/config.h"
+#include <mods/api.h>
+#include <mods/svc/config.h>
+#include <mods/svc/file.h>
 
-#define UI_SERVICE_ID "dev.twilitrealm.dusklight.ui"
-#define UI_SERVICE_MAJOR 1u
-#define UI_SERVICE_MINOR 0u
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define UI_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "ui"
+#define UI_SERVICE_MAJOR 2u
+#define UI_SERVICE_MINOR 2u
 
 /*
- * UI primitives: a panel inside the host Mods window, mod-owned windows, dialogs, scoped
- * RCSS stylesheets and menu bar tabs.
+ * UI primitives: a panel inside the host Mods window, mod-owned windows, dialogs, toasts,
+ * scoped RCSS stylesheets and menu bar tabs.
  *
  * All calls must be made on the game thread from mod callbacks (initialize, update, hooks, or UI
  * callbacks). Handles are opaque, generation-checked ids; a stale or unknown handle fails with
  * MOD_INVALID_ARGUMENT. Element handles die with the content that owns them: a panel or tab rebuild
- * destroys the previous build's elements, so re-acquire handles inside the build callback rather
- * than caching them. Strings are UTF-8 and, in both directions, only valid for the duration of the
- * call.
+ * destroys the previous build's elements, so re-acquire handles in each build callback and use them
+ * only until the next rebuild. Strings are UTF-8 and, in both directions, only valid for the
+ * duration of the call.
  */
 
 /* 0 is never a valid handle. */
@@ -47,6 +52,9 @@ typedef enum UiControlKind {
     UI_CONTROL_NUMBER = 2, /* integer stepper with min/max/step */
     UI_CONTROL_STRING = 3, /* text input */
     UI_CONTROL_SELECT = 4, /* one of `options`; the value is the option index */
+    UI_CONTROL_COLOR = 5,  /* RGB/RGBA color string with a picker */
+    UI_CONTROL_GROUP = 6,  /* navigation row (on_pressed) */
+    UI_CONTROL_FILE_PICKER = 7, /* file/folder picker with an opaque string location */
 } UiControlKind;
 
 typedef enum UiControlBinding {
@@ -56,14 +64,20 @@ typedef enum UiControlBinding {
     /* The control reads and writes `config_var` (a ConfigService handle owned by the calling mod)
      * directly: persistence, change notifications and the modified indicator (value != default) are
      * wired automatically. The var type must match the control kind: TOGGLE = bool, NUMBER and
-     * SELECT = int, STRING = string. Float vars are not bindable; use callbacks. */
+     * SELECT = int, STRING, COLOR and FILE_PICKER = string. Float vars are not bindable; use
+     * callbacks. */
     UI_BINDING_CONFIG_VAR = 1,
 } UiControlBinding;
 
-/* Tagged by the control's kind: TOGGLE reads bool_value, NUMBER and SELECT read int_value, STRING
- * reads string_value. string_value passed to a setter is only valid during the call; a getter
- * should point it at storage owned by the mod (e.g. a static buffer) that stays valid until the
- * next call into the mod — the host copies it right after the getter returns. */
+typedef enum UiStringSetMode {
+    UI_STRING_SET_ON_COMMIT = 0, /* invokes `set` when input is committed */
+    UI_STRING_SET_ON_CHANGE = 1, /* invokes `set` on every text change (e.g. while typing) */
+} UiStringSetMode;
+
+/* Tagged by the control's kind: TOGGLE reads bool_value, NUMBER and SELECT read int_value, STRING,
+ * COLOR and FILE_PICKER read string_value. string_value passed to a setter is only valid during the
+ * call; a getter should point it at storage owned by the mod (e.g. a static buffer) that stays valid
+ * until the next call into the mod. The host copies it right after the getter returns. */
 typedef struct UiControlValue {
     uint32_t struct_size;
     bool bool_value;
@@ -87,16 +101,16 @@ typedef struct UiControlDesc {
     /* Optional RML shown as contextual help when the control is focused or hovered. Only rendered
      * where a help pane exists (mod window tabs). */
     const char* help_rml;
-    UiControlBinding binding;   /* ignored for BUTTON */
+    UiControlBinding binding;   /* ignored for BUTTON and GROUP */
     ConfigVarHandle config_var; /* UI_BINDING_CONFIG_VAR */
-    UiControlGetFn get;         /* UI_BINDING_CALLBACKS (all kinds but BUTTON) */
-    UiControlSetFn set;         /* UI_BINDING_CALLBACKS (all kinds but BUTTON) */
-    UiPressedFn on_pressed;     /* BUTTON only. Required for BUTTON. */
+    UiControlGetFn get;         /* UI_BINDING_CALLBACKS (all kinds but BUTTON/GROUP) */
+    UiControlSetFn set;         /* UI_BINDING_CALLBACKS (all kinds but BUTTON/GROUP) */
+    UiPressedFn on_pressed;     /* BUTTON/GROUP only. Required for both. */
     UiPredicateFn is_disabled;  /* optional */
     /* Optional override for the modified indicator. CONFIG_VAR controls derive it from value !=
      * default when this is NULL. */
     UiPredicateFn is_modified;
-    /* Passed to every callback above. */
+    /* Passed to every callback. */
     void* user_data;
     /* NUMBER: inclusive clamp range and step. min == max means the defaults (0 .. INT32_MAX); step
      * < 1 means 1. */
@@ -111,17 +125,60 @@ typedef struct UiControlDesc {
     const char* const* options;
     size_t option_count;
     int32_t max_length; /* STRING: maximum input length; < 1 means unlimited */
+    /* COLOR: optional RRGGBB/RRGGBBAA values for presets. "rainbow" is a special value. */
+    const char* const* color_presets;
+    size_t color_preset_count;
+    bool color_alpha;                /* COLOR: use RRGGBBAA values instead of RRGGBB */
+    UiPredicateFn is_selected;       /* BUTTON/GROUP: optional selected state */
+    UiStringSetMode string_set_mode; /* STRING: when to invoke the setter */
+    /* FILE_PICKER: optional file filters and folder selection mode. */
+    const FileFilter* file_filters;
+    size_t file_filter_count;
+    bool directory_mode;
 } UiControlDesc;
 
 #define UI_CONTROL_DESC_INIT                                                                       \
     {sizeof(UiControlDesc), UI_CONTROL_BUTTON, NULL, NULL, UI_BINDING_CALLBACKS, 0u, NULL, NULL,   \
-        NULL, NULL, NULL, NULL, 0, 0, 1, NULL, NULL, NULL, 0u, 0}
+        NULL, NULL, NULL, NULL, 0, 0, 1, NULL, NULL, NULL, 0u, 0, NULL, 0u, false, NULL,           \
+        UI_STRING_SET_ON_COMMIT, NULL, 0u, false}
+
+typedef uint64_t UiListHandle;
+
+/* Must be initialized with UI_LIST_ITEM_INIT */
+typedef struct UiListItem {
+    uint32_t struct_size;
+    uint64_t key;      /* required; unique, stable item key */
+    const char* label; /* required; visible item text */
+} UiListItem;
+
+#define UI_LIST_ITEM_INIT {sizeof(UiListItem), 0u, NULL}
+
+typedef void (*UiListPressedFn)(
+    ModContext* ctx, UiListHandle list, uint64_t item_key, void* user_data);
+typedef bool (*UiListPredicateFn)(
+    ModContext* ctx, UiListHandle list, uint64_t item_key, void* user_data);
+
+/* Must be initialized with UI_LIST_DESC_INIT */
+typedef struct UiListDesc {
+    uint32_t struct_size;
+    const UiListItem* items; /* optional; initial set of items */
+    size_t item_count;
+    UiListPressedFn on_pressed;    /* required */
+    UiListPredicateFn is_selected; /* optional; polled only for render-visible rows */
+    UiListPredicateFn is_disabled; /* optional; polled only for render-visible rows */
+    void* user_data;
+} UiListDesc;
+
+#define UI_LIST_DESC_INIT {sizeof(UiListDesc), NULL, 0u, NULL, NULL, NULL, NULL}
+
+/* Build pane contents. A non-MOD_OK result fails the mod. */
+typedef ModResult (*UiPaneBuildFn)(
+    ModContext* ctx, UiElementHandle pane, void* user_data, ModError* out_error);
 
 /* Build the panel contents. `panel` accepts the pane_add_* functions; it and
  * every element created in it are destroyed (handles invalidated) whenever the
  * panel is rebuilt, e.g. on tab switches. A non-MOD_OK result fails the mod. */
-typedef ModResult (*UiPanelBuildFn)(
-    ModContext* ctx, UiElementHandle panel, void* user_data, ModError* out_error);
+typedef UiPaneBuildFn UiPanelBuildFn;
 /* Called every frame while the panel is the visible tab. */
 typedef ModResult (*UiPanelUpdateFn)(ModContext* ctx, void* user_data, ModError* out_error);
 
@@ -135,6 +192,19 @@ typedef struct UiModsPanelDesc {
 
 #define UI_MODS_PANEL_DESC_INIT {sizeof(UiModsPanelDesc), NULL, NULL, NULL}
 
+/* Builds the contents associated with a group button. The target pane is cleared immediately
+ * before this callback and is valid only while its tab remains built. */
+typedef UiPaneBuildFn UiGroupBuildFn;
+
+typedef struct UiGroupDesc {
+    uint32_t struct_size;
+    const char* label;    /* required */
+    UiGroupBuildFn build; /* required */
+    void* user_data;
+} UiGroupDesc;
+
+#define UI_GROUP_DESC_INIT {sizeof(UiGroupDesc), NULL, NULL, NULL}
+
 /* Build one tab of a mod window. `left_pane` is the interactive column,
  * `right_pane` shows contextual help (controls' help_rml and SELECT options
  * render there). Rebuilt on every tab activation. */
@@ -170,15 +240,17 @@ typedef struct UiWindowDesc {
 
 typedef void (*UiDialogActionFn)(ModContext* ctx, UiDialogHandle dialog, void* user_data);
 
-/* Note: array element without struct_size; a future change requires appending
- * a v2 desc struct rather than growing this one. */
 typedef struct UiDialogAction {
+    uint32_t struct_size;
     const char* label; /* required */
     UiDialogActionFn on_pressed;
     void* user_data;
-    bool keep_open; /* false = the dialog closes after on_pressed returns */
+    bool keep_open;            /* false = the dialog closes after on_pressed returns */
+    UiPredicateFn is_disabled; /* optional; polled every frame while the dialog is visible */
 } UiDialogAction;
 
+#define UI_DIALOG_ACTION_INIT {sizeof(UiDialogAction), NULL, NULL, NULL, false, NULL}
+
 typedef struct UiDialogDesc {
     uint32_t struct_size;
     const char* title;    /* plain text; required */
@@ -192,11 +264,14 @@ typedef struct UiDialogDesc {
     /* Fired on cancel (B/Escape) before the dialog closes; the dialog always
      * closes on dismiss. */
     UiDialogActionFn on_dismiss;
-    void* user_data; /* passed to on_dismiss */
+    void* user_data; /* passed to build and on_dismiss */
+    /* Optional content builder. The pane is rendered below body_rml and above the actions. Its
+     * handle and all child element handles remain valid until the dialog closes. */
+    UiPaneBuildFn build;
 } UiDialogDesc;
 
 #define UI_DIALOG_DESC_INIT                                                                        \
-    {sizeof(UiDialogDesc), NULL, NULL, UI_DIALOG_NORMAL, NULL, NULL, 0u, NULL, NULL}
+    {sizeof(UiDialogDesc), NULL, NULL, UI_DIALOG_NORMAL, NULL, NULL, 0u, NULL, NULL, NULL}
 
 /* A tab added to the in-game menu bar. */
 typedef struct UiMenuTabDesc {
@@ -208,6 +283,19 @@ typedef struct UiMenuTabDesc {
 
 #define UI_MENU_TAB_DESC_INIT {sizeof(UiMenuTabDesc), NULL, NULL, NULL}
 
+typedef struct UiToastDesc {
+    uint32_t struct_size;
+    /* Optional RCSS class, such as "warning" or a custom mod-defined type. */
+    const char* type;
+    /* Optional RML. At least one of title_rml or body_rml must be non-empty. */
+    const char* title_rml;
+    const char* body_rml;
+    /* How long the toast remains open; 0 uses the default of 5000 ms. */
+    uint32_t duration_ms;
+} UiToastDesc;
+
+#define UI_TOAST_DESC_INIT {sizeof(UiToastDesc), NULL, NULL, NULL, 0u}
+
 typedef struct UiService {
     ServiceHeader header;
 
@@ -225,6 +313,10 @@ typedef struct UiService {
         ModContext* ctx, UiElementHandle pane, float value, UiElementHandle* out_elem);
     ModResult (*pane_add_control)(ModContext* ctx, UiElementHandle pane, const UiControlDesc* desc,
         UiElementHandle* out_elem);
+    /* Add a group button to one pane that builds controls in its paired pane.
+     * The panes must be the left and right handles from the same UiTabBuildFn call. */
+    ModResult (*pane_add_group)(ModContext* ctx, UiElementHandle group_pane,
+        UiElementHandle target_pane, const UiGroupDesc* desc, UiElementHandle* out_elem);
 
     /* Element updates. The handle kind must match the setter (text/rml on text
      * rows, progress on progress bars). */
@@ -246,9 +338,6 @@ typedef struct UiService {
     ModResult (*dialog_set_body)(ModContext* ctx, UiDialogHandle dialog, const char* body_rml);
     /* Replace the dialog icon ("" removes it; names as in UiDialogDesc.icon). */
     ModResult (*dialog_set_icon)(ModContext* ctx, UiDialogHandle dialog, const char* icon);
-    /* Append one action button (same callback rules as at push). */
-    ModResult (*dialog_add_action)(
-        ModContext* ctx, UiDialogHandle dialog, const UiDialogAction* action);
 
     /* Whether any focus-stack document is currently visible (visible documents block gamepad
      * input). */
@@ -271,14 +360,20 @@ typedef struct UiService {
     ModResult (*register_menu_tab)(
         ModContext* ctx, const UiMenuTabDesc* desc, UiMenuTabHandle* out_tab);
     ModResult (*unregister_menu_tab)(ModContext* ctx, UiMenuTabHandle tab);
+
+    /* Enqueue a toast notification. */
+    ModResult (*push_toast)(ModContext* ctx, const UiToastDesc* desc);
+
+    ModResult (*get_clipboard_text)(
+        ModContext* ctx, char* buffer, size_t bufferSize, size_t* outLength);
+    ModResult (*set_clipboard_text)(ModContext* ctx, const char* text);
+
+    /* A scrollable virtualized list of items. */
+    ModResult (*pane_add_list)(
+        ModContext* ctx, UiElementHandle pane, const UiListDesc* desc, UiListHandle* out_list);
+    /* Replace all items in a list with a new set. */
+    ModResult (*list_set_items)(
+        ModContext* ctx, UiListHandle list, const UiListItem* items, size_t item_count);
 } UiService;
 
-#ifdef __cplusplus
-#include "mods/service.hpp"
-
-template <>
-struct dusk::mods::ServiceTraits<UiService> {
-    static constexpr const char* id = UI_SERVICE_ID;
-    static constexpr uint16_t major_version = UI_SERVICE_MAJOR;
-};
-#endif
+MOD_DECLARE_SERVICE(UiService, svc_ui, UI_SERVICE_ID, UI_SERVICE_MAJOR, UI_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/ui.hpp b/sdk/include/mods/svc/ui.hpp
new file mode 100644
index 0000000000..7994cad1dc
--- /dev/null
+++ b/sdk/include/mods/svc/ui.hpp
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <mods/svc/ui.h>
+
+#include <string>
+#include <utility>
+
+namespace mods::ui {
+
+inline ModResult get_clipboard_text(std::string& outText) {
+    outText.clear();
+
+    size_t textLength = 0;
+    auto result = svc_ui->get_clipboard_text(mod_ctx, nullptr, 0, &textLength);
+    if (result != MOD_OK) {
+        return result;
+    }
+
+    for (int attempt = 0; attempt < 3; ++attempt) {
+        std::string buffer(textLength + 1, '\0');
+        size_t actualLength = 0;
+
+        result = svc_ui->get_clipboard_text(
+            mod_ctx, buffer.data(), buffer.size(), &actualLength);
+
+        if (result == MOD_OK) {
+            buffer.resize(actualLength);
+            outText = std::move(buffer);
+            return MOD_OK;
+        }
+
+        // Retry if the clipboard grew between the two calls.
+        if (result != MOD_INVALID_ARGUMENT || actualLength <= textLength) {
+            return result;
+        }
+
+        textLength = actualLength;
+    }
+
+    return MOD_ERROR;
+}
+
+inline ModResult set_clipboard_text(const std::string& text) {
+    return svc_ui->set_clipboard_text(mod_ctx, text.c_str());
+}
+
+}  // namespace mods::ui
\ No newline at end of file
diff --git a/sdk/include/mods/svc/websocket.h b/sdk/include/mods/svc/websocket.h
new file mode 100644
index 0000000000..abd36410ef
--- /dev/null
+++ b/sdk/include/mods/svc/websocket.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <mods/api.h>
+#include <mods/svc/http.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#define WEBSOCKET_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "websocket"
+#define WEBSOCKET_SERVICE_MAJOR 1u
+#define WEBSOCKET_SERVICE_MINOR 0u
+
+/** Generational connection handle. Zero is never valid. */
+typedef uint64_t WebSocketHandle;
+
+/** Connection outcome. Callers must tolerate values added by later service minors. */
+typedef enum WebSocketError {
+    WEBSOCKET_ERROR_NONE = 0,
+    WEBSOCKET_ERROR_INVALID_URL = 1,
+    WEBSOCKET_ERROR_UNSUPPORTED_SCHEME = 2,
+    WEBSOCKET_ERROR_TIMEOUT = 3,
+    WEBSOCKET_ERROR_TOO_LARGE = 4,
+    WEBSOCKET_ERROR_CANCELED = 5,
+    WEBSOCKET_ERROR_NETWORK = 6,
+    WEBSOCKET_ERROR_PROTOCOL = 7,
+    WEBSOCKET_ERROR_HANDSHAKE = 8,
+} WebSocketError;
+
+typedef enum WebSocketMessageKind {
+    WEBSOCKET_MESSAGE_TEXT = 0,
+    WEBSOCKET_MESSAGE_BINARY = 1,
+} WebSocketMessageKind;
+
+typedef struct WebSocketConnectDesc {
+    uint32_t struct_size;
+    /** wss:// URL, or ws:// for localhost, 127.0.0.1, or [::1]. */
+    const char* url;
+    /** Request headers. WebSocket handshake headers and User-Agent are reserved. */
+    const HttpHeader* headers;
+    uint32_t header_count;
+    const char* const* protocols;
+    uint32_t protocol_count;
+    uint32_t connect_timeout_ms;
+    uint32_t close_timeout_ms;
+    uint32_t keepalive_interval_ms;
+    /** 0 defaults to 1 MiB. Maximum of 16 MiB. */
+    size_t max_message_bytes;
+    /** Passed in every event. */
+    void* user_data;
+} WebSocketConnectDesc;
+
+#define WEBSOCKET_CONNECT_DESC_INIT                                                                \
+    {sizeof(WebSocketConnectDesc), NULL, NULL, 0u, NULL, 0u, 0u, 0u, 0u, 0u, NULL}
+
+typedef enum WebSocketEventType {
+    WEBSOCKET_EVENT_NONE = 0,
+    WEBSOCKET_EVENT_OPEN = 1,
+    WEBSOCKET_EVENT_MESSAGE = 2,
+    WEBSOCKET_EVENT_CLOSED = 3,
+} WebSocketEventType;
+
+typedef struct WebSocketEvent {
+    uint32_t struct_size;
+    WebSocketEventType type;
+    WebSocketHandle ws;
+    void* user_data;
+
+    const char* protocol;
+    /** Handshake response headers for OPEN or a handshake-rejected CLOSED event. */
+    const HttpHeader* headers;
+    uint32_t header_count;
+
+    WebSocketMessageKind message_kind;
+    /** Valid until this mod's next poll_event call or deactivation. */
+    const void* data;
+    size_t size;
+
+    WebSocketError error;
+    /** Never NULL. Valid until this mod's next poll_event call or deactivation. */
+    const char* error_message;
+    int32_t handshake_status;
+    uint16_t close_code;
+    const char* close_reason;
+} WebSocketEvent;
+
+#define WEBSOCKET_EVENT_INIT                                                                       \
+    {sizeof(WebSocketEvent), WEBSOCKET_EVENT_NONE, 0u, NULL, "", NULL, 0u, WEBSOCKET_MESSAGE_TEXT, \
+        NULL, 0u, WEBSOCKET_ERROR_NONE, "", 0, 0u, ""}
+
+typedef struct WebSocketService {
+    ServiceHeader header;
+
+    /** Starts a connection. */
+    ModResult (*connect)(
+        ModContext* ctx, const WebSocketConnectDesc* desc, WebSocketHandle* out_handle);
+    /** Returns MOD_OK and WEBSOCKET_EVENT_NONE when the queue is empty. */
+    ModResult (*poll_event)(ModContext* ctx, WebSocketEvent* out_event);
+    /** Copies a message into the outbound queue. */
+    ModResult (*send)(ModContext* ctx, WebSocketHandle ws, WebSocketMessageKind kind,
+        const void* data, size_t size);
+    /** Code 0 defaults to 1000; accepted: 1000, 1001, and 3000-4999. */
+    ModResult (*close)(ModContext* ctx, WebSocketHandle ws, uint16_t code, const char* reason);
+} WebSocketService;
+
+MOD_DECLARE_SERVICE(WebSocketService, svc_websocket, WEBSOCKET_SERVICE_ID, WEBSOCKET_SERVICE_MAJOR,
+    WEBSOCKET_SERVICE_MINOR);
diff --git a/sdk/include/mods/svc/websocket.hpp b/sdk/include/mods/svc/websocket.hpp
new file mode 100644
index 0000000000..57d8b37005
--- /dev/null
+++ b/sdk/include/mods/svc/websocket.hpp
@@ -0,0 +1,172 @@
+#pragma once
+
+#include <mods/svc/http.hpp>
+#include <mods/svc/websocket.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <span>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace mods::ws {
+
+struct Options {
+    std::string url;
+    std::vector<http::Header> headers;
+    std::vector<std::string> protocols;
+    uint32_t connectTimeoutMs = 0;
+    uint32_t closeTimeoutMs = 0;
+    uint32_t keepaliveIntervalMs = 0;
+    size_t maxMessageBytes = 0;
+    void* userData = nullptr;
+};
+
+class Connection {
+public:
+    Connection() = default;
+    Connection(WebSocketHandle handle, ModResult result) : mHandle{handle}, mResult{result} {}
+    ~Connection() { reset(); }
+
+    Connection(const Connection&) = delete;
+    Connection& operator=(const Connection&) = delete;
+    Connection(Connection&& other) noexcept { *this = std::move(other); }
+    Connection& operator=(Connection&& other) noexcept {
+        if (this != &other) {
+            reset();
+            mHandle = std::exchange(other.mHandle, 0);
+            mResult = other.mResult;
+        }
+        return *this;
+    }
+
+    explicit operator bool() const { return mResult == MOD_OK && mHandle != 0; }
+
+    ModResult result() const { return mResult; }
+    WebSocketHandle handle() const { return mHandle; }
+
+    ModResult send(WebSocketMessageKind kind, std::span<const std::byte> bytes) const {
+        return svc_websocket != nullptr && mHandle != 0 ?
+                   svc_websocket->send(mod_ctx, mHandle, kind, bytes.data(), bytes.size()) :
+                   MOD_UNAVAILABLE;
+    }
+
+    ModResult send_text(std::string_view text) const {
+        return svc_websocket != nullptr && mHandle != 0 ?
+                   svc_websocket->send(
+                       mod_ctx, mHandle, WEBSOCKET_MESSAGE_TEXT, text.data(), text.size()) :
+                   MOD_UNAVAILABLE;
+    }
+
+    ModResult send_binary(std::span<const std::byte> bytes) const {
+        return send(WEBSOCKET_MESSAGE_BINARY, bytes);
+    }
+
+    ModResult close(uint16_t code = 1000, std::string_view reason = {}) {
+        if (svc_websocket == nullptr || mHandle == 0) {
+            return MOD_UNAVAILABLE;
+        }
+        const std::string reasonText{reason};
+        mResult = svc_websocket->close(mod_ctx, mHandle, code, reasonText.c_str());
+        if (mResult == MOD_OK) {
+            mHandle = 0;
+        }
+        return mResult;
+    }
+
+    void detach() { mHandle = 0; }
+
+private:
+    void reset() {
+        if (mHandle != 0) {
+            (void)close(1001, "Connection owner released");
+            mHandle = 0;
+        }
+    }
+
+    WebSocketHandle mHandle = 0;
+    ModResult mResult = MOD_UNAVAILABLE;
+};
+
+inline Connection connect(const Options& options) {
+    if (svc_websocket == nullptr || options.headers.size() > std::numeric_limits<uint32_t>::max() ||
+        options.protocols.size() > std::numeric_limits<uint32_t>::max())
+    {
+        return {0, svc_websocket == nullptr ? MOD_UNAVAILABLE : MOD_INVALID_ARGUMENT};
+    }
+
+    std::vector<HttpHeader> headers;
+    headers.reserve(options.headers.size());
+    for (const auto& header : options.headers) {
+        headers.push_back({.name = header.name.c_str(), .value = header.value.c_str()});
+    }
+    std::vector<const char*> protocols;
+    protocols.reserve(options.protocols.size());
+    for (const auto& protocol : options.protocols) {
+        protocols.push_back(protocol.c_str());
+    }
+
+    WebSocketConnectDesc desc = WEBSOCKET_CONNECT_DESC_INIT;
+    desc.url = options.url.c_str();
+    desc.headers = headers.empty() ? nullptr : headers.data();
+    desc.header_count = static_cast<uint32_t>(headers.size());
+    desc.protocols = protocols.empty() ? nullptr : protocols.data();
+    desc.protocol_count = static_cast<uint32_t>(protocols.size());
+    desc.connect_timeout_ms = options.connectTimeoutMs;
+    desc.close_timeout_ms = options.closeTimeoutMs;
+    desc.keepalive_interval_ms = options.keepaliveIntervalMs;
+    desc.max_message_bytes = options.maxMessageBytes;
+    desc.user_data = options.userData;
+
+    WebSocketHandle handle = 0;
+    const ModResult result = svc_websocket->connect(mod_ctx, &desc, &handle);
+    return {handle, result};
+}
+
+struct Event {
+    WebSocketEventType type = WEBSOCKET_EVENT_NONE;
+    WebSocketHandle handle = 0;
+    void* userData = nullptr;
+    std::string_view protocol;
+    std::span<const HttpHeader> headers;
+    WebSocketMessageKind messageKind = WEBSOCKET_MESSAGE_TEXT;
+    std::span<const std::byte> data;
+    WebSocketError error = WEBSOCKET_ERROR_NONE;
+    std::string_view message;
+    int handshakeStatus = 0;
+    uint16_t closeCode = 0;
+    std::string_view closeReason;
+};
+
+inline bool poll(Event& out) {
+    out = {};
+    if (svc_websocket == nullptr) {
+        return false;
+    }
+    WebSocketEvent raw = WEBSOCKET_EVENT_INIT;
+    if (svc_websocket->poll_event(mod_ctx, &raw) != MOD_OK || raw.type == WEBSOCKET_EVENT_NONE) {
+        return false;
+    }
+    out.type = raw.type;
+    out.handle = raw.ws;
+    out.userData = raw.user_data;
+    out.protocol = raw.protocol != nullptr ? raw.protocol : "";
+    if (raw.headers != nullptr && raw.header_count != 0) {
+        out.headers = {raw.headers, raw.header_count};
+    }
+    out.messageKind = raw.message_kind;
+    if (raw.data != nullptr && raw.size != 0) {
+        out.data = {static_cast<const std::byte*>(raw.data), raw.size};
+    }
+    out.error = raw.error;
+    out.message = raw.error_message != nullptr ? raw.error_message : "";
+    out.handshakeStatus = raw.handshake_status;
+    out.closeCode = raw.close_code;
+    out.closeReason = raw.close_reason != nullptr ? raw.close_reason : "";
+    return true;
+}
+
+}  // namespace mods::ws
diff --git a/sdk/include/mods/svc/window.h b/sdk/include/mods/svc/window.h
new file mode 100644
index 0000000000..843e388ed8
--- /dev/null
+++ b/sdk/include/mods/svc/window.h
@@ -0,0 +1,103 @@
+#pragma once
+
+#include <mods/api.h>
+
+#ifdef __cplusplus
+#include <mods/service.hpp>
+#endif
+
+#include <limits.h>
+
+#define WINDOW_SERVICE_ID DUSKLIGHT_SERVICE_ID_PREFIX "window"
+#define WINDOW_SERVICE_MAJOR 1u
+#define WINDOW_SERVICE_MINOR 0u
+
+#define WINDOW_POSITION_UNDEFINED INT32_MIN
+
+typedef uint64_t WindowHandle;
+
+typedef enum WindowFlags {
+    WINDOW_FLAG_NONE = 0u,
+    WINDOW_FLAG_RESIZABLE = 1u << 0u,
+    WINDOW_FLAG_HIDDEN = 1u << 1u,
+    WINDOW_FLAG_BORDERLESS = 1u << 2u,
+    WINDOW_FLAG_ALWAYS_ON_TOP = 1u << 3u,
+    WINDOW_FLAG_TRANSPARENT = 1u << 4u,
+} WindowFlags;
+
+typedef enum WindowEventType {
+    WINDOW_EVENT_CLOSE_REQUESTED = 0,
+    WINDOW_EVENT_RESIZED = 1,
+    WINDOW_EVENT_MOVED = 2,
+    WINDOW_EVENT_FOCUS_GAINED = 3,
+    WINDOW_EVENT_FOCUS_LOST = 4,
+    WINDOW_EVENT_SHOWN = 5,
+    WINDOW_EVENT_HIDDEN = 6,
+} WindowEventType;
+
+typedef struct WindowEvent {
+    uint32_t struct_size;
+    WindowEventType type;
+    int32_t x;
+    int32_t y;
+    uint32_t width;
+    uint32_t height;
+    uint32_t pixel_width;
+    uint32_t pixel_height;
+    float display_scale;
+} WindowEvent;
+
+typedef void (*WindowEventFn)(
+    ModContext* ctx, WindowHandle window, const WindowEvent* event, void* user_data);
+
+typedef struct WindowDesc {
+    uint32_t struct_size;
+    const char* title;
+    uint32_t width;
+    uint32_t height;
+    int32_t x;
+    int32_t y;
+    uint32_t flags;
+    WindowEventFn on_event;
+    void* user_data;
+} WindowDesc;
+
+#define WINDOW_DESC_INIT                                                                           \
+    {sizeof(WindowDesc), NULL, 640u, 480u, WINDOW_POSITION_UNDEFINED, WINDOW_POSITION_UNDEFINED,   \
+        WINDOW_FLAG_RESIZABLE | WINDOW_FLAG_HIDDEN, NULL, NULL}
+
+typedef struct WindowInfo {
+    uint32_t struct_size;
+    int32_t x;
+    int32_t y;
+    uint32_t width;
+    uint32_t height;
+    uint32_t pixel_width;
+    uint32_t pixel_height;
+    float display_scale;
+    bool visible;
+    bool focused;
+} WindowInfo;
+
+#define WINDOW_INFO_INIT {sizeof(WindowInfo), 0, 0, 0u, 0u, 0u, 0u, 1.0f, false, false}
+
+/*
+ * Auxiliary native windows. All functions and callbacks run on the game thread. Window close
+ * events are requests; the window remains alive until destroy_window is called. Any graphics
+ * present target attached to a window must be unregistered before the window can be destroyed;
+ * at most one present target may be attached to a window at a time.
+ */
+typedef struct WindowService {
+    ServiceHeader header;
+
+    ModResult (*create_window)(ModContext* ctx, const WindowDesc* desc, WindowHandle* out_window);
+    ModResult (*destroy_window)(ModContext* ctx, WindowHandle window);
+    ModResult (*show_window)(ModContext* ctx, WindowHandle window);
+    ModResult (*hide_window)(ModContext* ctx, WindowHandle window);
+    ModResult (*set_title)(ModContext* ctx, WindowHandle window, const char* title);
+    ModResult (*set_size)(ModContext* ctx, WindowHandle window, uint32_t width, uint32_t height);
+    ModResult (*get_info)(ModContext* ctx, WindowHandle window, WindowInfo* out_info);
+} WindowService;
+
+MOD_DECLARE_SERVICE(
+    WindowService, svc_window, WINDOW_SERVICE_ID, WINDOW_SERVICE_MAJOR, WINDOW_SERVICE_MINOR);
diff --git a/sdk/luau/dusklight.d.luau b/sdk/luau/dusklight.d.luau
new file mode 100644
index 0000000000..619e2f4124
--- /dev/null
+++ b/sdk/luau/dusklight.d.luau
@@ -0,0 +1,160 @@
+--!strict
+
+export type IntegerInput = integer | number
+export type ConfigValue = boolean | integer | number | string
+export type ConfigVar<T> = {
+    get: (self: ConfigVar<T>) -> T,
+    set: (self: ConfigVar<T>, value: T) -> (),
+    subscribe: (self: ConfigVar<T>, callback: (value: T, previous: T) -> ()) -> ConfigSubscription,
+    unregister: (self: ConfigVar<T>) -> (),
+}
+export type ConfigSubscription = {
+    unsubscribe: (self: ConfigSubscription) -> (),
+}
+export type ConfigDesc = {
+    name: string,
+    type: "bool" | "int" | "float" | "string",
+    default: ConfigValue?,
+}
+export type ConfigModule = {
+    register: (desc: ConfigDesc) -> ConfigVar<any>,
+    subscribe: <T>(variable: ConfigVar<T>, callback: (value: T, previous: T) -> ()) -> ConfigSubscription,
+}
+
+export type OverlayHandle = { remove: (self: OverlayHandle) -> () }
+export type OverlayModule = {
+    add_file: (discPath: string, bundlePath: string) -> OverlayHandle,
+    add_buffer: (discPath: string, data: string) -> OverlayHandle,
+}
+export type TextureHandle = { unregister: (self: TextureHandle) -> () }
+export type TextureKey = {
+    texture_hash: integer,
+    tlut_hash: integer?,
+    width: IntegerInput,
+    height: IntegerInput,
+    gx_format: IntegerInput,
+    has_tlut: boolean?,
+}
+export type TextureData = {
+    data: string,
+    width: IntegerInput?,
+    height: IntegerInput?,
+    mip_count: IntegerInput?,
+    gx_format: IntegerInput?,
+}
+export type TextureModule = {
+    hash_wildcard: integer,
+    tlut_wildcard: integer,
+    register_file: (bundlePath: string) -> TextureHandle,
+    register_data: (key: TextureKey, data: TextureData) -> TextureHandle,
+}
+
+export type UiElement = {
+    add_section: (self: UiElement, title: string) -> (),
+    add_text: (self: UiElement, text: string) -> UiElement,
+    add_rml: (self: UiElement, rml: string) -> UiElement,
+    add_progress: (self: UiElement, value: number) -> UiElement,
+    add_control: (self: UiElement, desc: UiControlDesc) -> UiElement,
+    add_group: (self: UiElement, target: UiElement, desc: UiGroupDesc) -> UiElement,
+    add_list: (self: UiElement, desc: UiListDesc) -> UiList,
+    set_text: (self: UiElement, text: string) -> (),
+    set_rml: (self: UiElement, rml: string) -> (),
+    set_progress: (self: UiElement, value: number) -> (),
+    set_class: (self: UiElement, name: string, active: boolean) -> (),
+}
+export type UiControlDesc = {
+    kind: "button" | "toggle" | "number" | "string" | "select" | "color" | "group" | "file_picker",
+    label: string,
+    help_rml: string?,
+    config_var: ConfigVar<any>?,
+    get: (() -> ConfigValue)?,
+    set: ((value: ConfigValue) -> ())?,
+    on_pressed: (() -> ())?,
+    is_disabled: (() -> boolean)?,
+    is_modified: (() -> boolean)?,
+    is_selected: (() -> boolean)?,
+    min: IntegerInput?,
+    max: IntegerInput?,
+    step: IntegerInput?,
+    prefix: string?,
+    suffix: string?,
+    options: {string}?,
+    max_length: IntegerInput?,
+    color_presets: {string}?,
+    color_alpha: boolean?,
+    string_set_mode: ("commit" | "change")?,
+    file_filters: {{name: string, pattern: string}}?,
+    directory_mode: boolean?,
+}
+export type UiGroupDesc = { label: string, build: (pane: UiElement) -> () }
+export type UiListItem = { key: IntegerInput, label: string }
+export type UiListDesc = {
+    items: {UiListItem}?,
+    on_pressed: (list: UiList, key: integer) -> (),
+    is_selected: ((list: UiList, key: integer) -> boolean)?,
+    is_disabled: ((list: UiList, key: integer) -> boolean)?,
+}
+export type UiList = { set_items: (self: UiList, items: {UiListItem}) -> () }
+export type UiWindow = { close: (self: UiWindow) -> () }
+export type UiDialog = {
+    close: (self: UiDialog) -> (),
+    set_body: (self: UiDialog, rml: string) -> (),
+    set_icon: (self: UiDialog, icon: string) -> (),
+}
+export type UiStyle = { unregister: (self: UiStyle) -> () }
+export type UiMenuTab = { unregister: (self: UiMenuTab) -> () }
+export type UiTabDesc = {
+    title: string,
+    build: (window: UiWindow, left: UiElement, right: UiElement) -> (),
+    update: (() -> ())?,
+}
+export type UiModule = {
+    register_mods_panel: (desc: {build: (panel: UiElement) -> (), update: (() -> ())?}) -> (),
+    window_push: (desc: {tabs: {UiTabDesc}, rcss: string?, on_closed: ((window: UiWindow) -> ())?}) -> UiWindow,
+    dialog_push: (desc: {
+        title: string,
+        body_rml: string,
+        variant: ("normal" | "warning" | "danger")?,
+        icon: string?,
+        actions: {{label: string, on_pressed: ((dialog: UiDialog) -> ())?, keep_open: boolean?, is_disabled: (() -> boolean)?}},
+        on_dismiss: ((dialog: UiDialog) -> ())?,
+        build: ((pane: UiElement) -> ())?,
+    }) -> UiDialog,
+    is_any_document_visible: () -> boolean,
+    register_styles: (scope: string, rcss: string) -> UiStyle,
+    register_styles_file: (scope: string, path: string) -> UiStyle,
+    register_menu_tab: (desc: {label: string, on_selected: () -> ()}) -> UiMenuTab,
+    push_toast: (desc: {type: string?, title_rml: string?, body_rml: string?, duration_ms: IntegerInput?}) -> (),
+    get_clipboard_text: () -> string,
+    set_clipboard_text: (text: string) -> (),
+}
+
+export type LogModule = {
+    write: (level: "trace" | "debug" | "info" | "warn" | "error", message: string) -> (),
+    trace: (message: string) -> (),
+    debug: (message: string) -> (),
+    info: (message: string) -> (),
+    warn: (message: string) -> (),
+    error: (message: string) -> (),
+}
+export type HostModule = {
+    version: string,
+    mod_id: () -> string,
+    mod_name: () -> string,
+    mod_version: () -> string,
+    mod_dir: () -> string,
+    data_dir: () -> string,
+    on_update: (callback: () -> ()) -> (),
+    on_shutdown: (callback: () -> ()) -> (),
+    fail: (message: string) -> never,
+}
+export type ResourceModule = { load: (relativePath: string) -> string }
+
+declare function require(path: "dusklight.log"): LogModule
+declare function require(path: "dusklight.host"): HostModule
+declare function require(path: "dusklight.config"): ConfigModule
+declare function require(path: "dusklight.resource"): ResourceModule
+declare function require(path: "dusklight.overlay"): OverlayModule
+declare function require(path: "dusklight.texture"): TextureModule
+declare function require(path: "dusklight.ui"): UiModule
+declare function require(path: string): any
diff --git a/sdk/luau/template/mod.json b/sdk/luau/template/mod.json
new file mode 100644
index 0000000000..85a13a6459
--- /dev/null
+++ b/sdk/luau/template/mod.json
@@ -0,0 +1,8 @@
+{
+  "id": "com.example.my_script_mod",
+  "name": "My Script Mod",
+  "version": "1.0.0",
+  "author": "Your Name",
+  "description": "A Luau script mod",
+  "runtime": "dev.twilitrealm.luau@1.0"
+}
diff --git a/sdk/luau/template/res/main.luau b/sdk/luau/template/res/main.luau
new file mode 100644
index 0000000000..102988c164
--- /dev/null
+++ b/sdk/luau/template/res/main.luau
@@ -0,0 +1,8 @@
+local log = require("dusklight.log")
+local host = require("dusklight.host")
+
+log.info("My Script Mod initialized")
+
+host.on_shutdown(function()
+    log.info("My Script Mod shutting down")
+end)
diff --git a/sdk/pseudo_reloc.cpp b/sdk/pseudo_reloc.cpp
deleted file mode 100644
index f86d783f2d..0000000000
--- a/sdk/pseudo_reloc.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-// Mod SDK runtime (Windows): applies lld's MinGW-style runtime pseudo-relocations on
-// the plain MSVC CRT. This is what lets mods reference game data (`extern` globals) with no
-// __declspec(dllimport) annotations: `lld-link -lldmingw` auto-imports the data through IAT
-// slots and records fixups, and this module applies them at load time.
-//
-// The fixup pass runs as an early CRT initializer, and the IAT slots it reads were already
-// bound by the OS loader, so even mod static initializers observe patched references.
-
-#include <windows.h>
-
-#include <cstdint>
-#include <cstdio>
-#include <cstring>
-
-extern "C" char __RUNTIME_PSEUDO_RELOC_LIST__;
-extern "C" char __RUNTIME_PSEUDO_RELOC_LIST_END__;
-extern "C" IMAGE_DOS_HEADER __ImageBase;
-
-namespace {
-
-struct HdrV2 {
-    uint32_t magic1;
-    uint32_t magic2;
-    uint32_t version;
-};
-struct ItemV2 {
-    uint32_t sym;     // RVA of the __imp_ slot (OS-bound IAT entry)
-    uint32_t target;  // RVA of the reference to patch
-    uint32_t flags;   // low 8 bits: bit width of the reference
-};
-
-bool g_relocsFailed = false;
-
-void report(const char* fmt, ...) {
-    char buf[512];
-    va_list args;
-    va_start(args, fmt);
-    vsnprintf(buf, sizeof(buf), fmt, args);
-    va_end(args);
-    fprintf(stderr, "%s\n", buf);
-    OutputDebugStringA(buf);
-}
-
-bool compute_fixup(const ItemV2& item, char* base, intptr_t* out) {
-    char* impSlot = base + item.sym;
-    const intptr_t real = *reinterpret_cast<intptr_t*>(impSlot);
-    char* target = base + item.target;
-    const int bits = static_cast<int>(item.flags & 0xff);
-
-    intptr_t reldata;
-    switch (bits) {
-    case 8:
-        reldata = *reinterpret_cast<int8_t*>(target);
-        break;
-    case 16:
-        reldata = *reinterpret_cast<int16_t*>(target);
-        break;
-    case 32:
-        reldata = *reinterpret_cast<int32_t*>(target);
-        break;
-    case 64:
-        reldata = *reinterpret_cast<int64_t*>(target);
-        break;
-    default:
-        report("unsupported %d-bit pseudo-relocation at RVA 0x%x", bits, item.target);
-        return false;
-    }
-    reldata -= reinterpret_cast<intptr_t>(impSlot);
-    reldata += real;
-
-    if (bits < 64) {
-        const intptr_t maxUnsigned = (intptr_t{1} << bits) - 1;
-        const intptr_t minSigned = -(intptr_t{1} << (bits - 1));
-        if (reldata > maxUnsigned || reldata < minSigned) {
-            report("%d-bit data fixup at RVA 0x%x is out of range (delta %+lld)", bits, item.target,
-                static_cast<long long>(reldata));
-            return false;
-        }
-    }
-    *out = reldata;
-    return true;
-}
-
-}  // namespace
-
-// lld refuses to emit runtime pseudo-relocs unless a function with exactly this (mingw CRT)
-// name exists in the image. It is also our actual entry point.
-extern "C" void _pei386_runtime_relocator() {
-    char* base = reinterpret_cast<char*>(&__ImageBase);
-    char* start = &__RUNTIME_PSEUDO_RELOC_LIST__;
-    char* end = &__RUNTIME_PSEUDO_RELOC_LIST_END__;
-    if (end - start < static_cast<ptrdiff_t>(sizeof(HdrV2))) {
-        return;  // no data auto-imports in this mod
-    }
-    const HdrV2* hdr = reinterpret_cast<const HdrV2*>(start);
-    if (hdr->magic1 != 0 || hdr->magic2 != 0 || hdr->version != 1) {
-        report("unexpected pseudo-relocation list format");
-        g_relocsFailed = true;
-        return;
-    }
-    const ItemV2* items = reinterpret_cast<const ItemV2*>(hdr + 1);
-    const ItemV2* itemsEnd = reinterpret_cast<const ItemV2*>(end);
-
-    // Validate everything before writing anything, so a bad fixup can't leave the image
-    // half-patched.
-    intptr_t scratch;
-    for (const ItemV2* it = items; it < itemsEnd; ++it) {
-        if (!compute_fixup(*it, base, &scratch)) {
-            g_relocsFailed = true;
-            return;
-        }
-    }
-    for (const ItemV2* it = items; it < itemsEnd; ++it) {
-        intptr_t reldata;
-        compute_fixup(*it, base, &reldata);
-        char* target = base + it->target;
-        const size_t len = static_cast<size_t>(it->flags & 0xff) / 8;
-        DWORD old = 0;
-        if (!VirtualProtect(target, len, PAGE_EXECUTE_READWRITE, &old)) {
-            report("VirtualProtect failed at RVA 0x%x", it->target);
-            g_relocsFailed = true;
-            return;
-        }
-        std::memcpy(target, &reldata, len);
-        VirtualProtect(target, len, old, &old);
-    }
-}
-
-using PVFV = void (*)();
-#pragma section(".CRT$XCB", read)
-extern "C" __declspec(allocate(".CRT$XCB")) PVFV dusk_mod_pseudo_reloc_init =
-    _pei386_runtime_relocator;
-
-BOOL WINAPI DllMain(HINSTANCE, DWORD reason, LPVOID) {
-    if (reason == DLL_PROCESS_ATTACH && g_relocsFailed) {
-        return FALSE;
-    }
-    return TRUE;
-}
diff --git a/sdk/src/game_feature.cpp b/sdk/src/game_feature.cpp
new file mode 100644
index 0000000000..15fa16c443
--- /dev/null
+++ b/sdk/src/game_feature.cpp
@@ -0,0 +1,5 @@
+#include <mods/service.hpp>
+#include <mods/svc/game.h>
+
+// Linking the game feature makes the loader enforce the game ABI epoch.
+IMPORT_SERVICE(GameService, svc_game);
diff --git a/src/DynamicLink.cpp b/src/DynamicLink.cpp
index dae7da52de..c1ca5b1775 100644
--- a/src/DynamicLink.cpp
+++ b/src/DynamicLink.cpp
@@ -142,11 +142,11 @@ DynamicModuleControl::DynamicModuleControl(char const* name) {
 }
 #endif
 
-u32 DynamicModuleControl::sAllocBytes;
+DUSK_GAME_DATA u32 DynamicModuleControl::sAllocBytes;
 
-JKRArchive* DynamicModuleControl::sArchive;
+DUSK_GAME_DATA JKRArchive* DynamicModuleControl::sArchive;
 
-JKRFileCache* DynamicModuleControl::sFileCache;
+DUSK_GAME_DATA JKRFileCache* DynamicModuleControl::sFileCache;
 
 static const char* baseString = "Base";
 
diff --git a/src/SSystem/SComponent/c_API.cpp b/src/SSystem/SComponent/c_API.cpp
index a6ecf42d75..0db032bb8a 100644
--- a/src/SSystem/SComponent/c_API.cpp
+++ b/src/SSystem/SComponent/c_API.cpp
@@ -12,7 +12,7 @@ extern int mDoGph_AfterOfDraw();
 extern int mDoGph_Painter();
 extern int mDoGph_Create();
 
-cAPI_Interface g_cAPI_Interface = {
+DUSK_GAME_DATA cAPI_Interface g_cAPI_Interface = {
     (cAPIGph_Mthd)mDoGph_Create,
     (cAPIGph_Mthd)mDoGph_BeforeOfDraw,
     (cAPIGph_Mthd)mDoGph_AfterOfDraw,
diff --git a/src/SSystem/SComponent/c_angle.cpp b/src/SSystem/SComponent/c_angle.cpp
index 4d04f980b2..90179b9050 100644
--- a/src/SSystem/SComponent/c_angle.cpp
+++ b/src/SSystem/SComponent/c_angle.cpp
@@ -7,11 +7,11 @@
 
 extern f32 cM_atan2f(f32, f32);
 
-const cSAngle cSAngle::_0(static_cast<s16>(0));
-const cSAngle cSAngle::_1(static_cast<s16>(0xb6));
-const cSAngle cSAngle::_90(static_cast<s16>(0x4000));
-const cSAngle cSAngle::_180(static_cast<s16>(-0x8000));
-const cSAngle cSAngle::_270(static_cast<s16>(-0x4000));
+DUSK_GAME_DATA const cSAngle cSAngle::_0(static_cast<s16>(0));
+DUSK_GAME_DATA const cSAngle cSAngle::_1(static_cast<s16>(0xb6));
+DUSK_GAME_DATA const cSAngle cSAngle::_90(static_cast<s16>(0x4000));
+DUSK_GAME_DATA const cSAngle cSAngle::_180(static_cast<s16>(-0x8000));
+DUSK_GAME_DATA const cSAngle cSAngle::_270(static_cast<s16>(-0x4000));
 
 #ifdef __MWERKS__
 cSAngle::cSAngle(const cSAngle& angle) {
diff --git a/src/SSystem/SComponent/c_cc_d.cpp b/src/SSystem/SComponent/c_cc_d.cpp
index 76c4920b8f..df6fa5b39c 100644
--- a/src/SSystem/SComponent/c_cc_d.cpp
+++ b/src/SSystem/SComponent/c_cc_d.cpp
@@ -10,7 +10,7 @@
 
 #define CHECK_FLOAT_RANGE(line, x) JUT_ASSERT(line, -1.0e32f < x && x < 1.0e32f);
 
-cXyz cCcD_ShapeAttr::m_virtual_center = cXyz::Zero;
+DUSK_GAME_DATA cXyz cCcD_ShapeAttr::m_virtual_center = cXyz::Zero;
 
 void cCcD_DivideInfo::Set(u32 xDivInfo, u32 yDivInfo, u32 zDivInfo) {
     mXDivInfo = xDivInfo;
diff --git a/src/SSystem/SComponent/c_counter.cpp b/src/SSystem/SComponent/c_counter.cpp
index 7da967f25f..e8ec9b2aeb 100644
--- a/src/SSystem/SComponent/c_counter.cpp
+++ b/src/SSystem/SComponent/c_counter.cpp
@@ -5,7 +5,7 @@
 
 #include "SSystem/SComponent/c_counter.h"
 
-counter_class g_Counter;
+DUSK_GAME_DATA counter_class g_Counter;
 
 void cCt_Counter(int resetCounter1) {
     if (resetCounter1 == 1) {
diff --git a/src/SSystem/SComponent/c_lib.cpp b/src/SSystem/SComponent/c_lib.cpp
index 0f1404642f..2b5bb6e0d8 100644
--- a/src/SSystem/SComponent/c_lib.cpp
+++ b/src/SSystem/SComponent/c_lib.cpp
@@ -496,7 +496,7 @@ s32 cLib_distanceAngleS(s16 x, s16 y) {
 
 static Mtx mtx[10];
 
-Mtx* calc_mtx = mtx;
+DUSK_GAME_DATA Mtx* calc_mtx = mtx;
 
 /**
  * Initializes calc_mtx to mtx stack
diff --git a/src/SSystem/SComponent/c_m3d.cpp b/src/SSystem/SComponent/c_m3d.cpp
index c44ea66bf8..ae11a5268b 100644
--- a/src/SSystem/SComponent/c_m3d.cpp
+++ b/src/SSystem/SComponent/c_m3d.cpp
@@ -17,7 +17,7 @@
 #define FLT_EPSILON std::numeric_limits<float>::epsilon()
 #endif
 
-const f32 G_CM3D_F_ABS_MIN = 32 * FLT_EPSILON;
+DUSK_GAME_DATA const f32 G_CM3D_F_ABS_MIN = 32 * FLT_EPSILON;
 
 void cM3d_InDivPos1(const Vec* pVecA, const Vec* pVecB, f32 pF, Vec* pOut) {
     Vec tmp;
diff --git a/src/SSystem/SComponent/c_malloc.cpp b/src/SSystem/SComponent/c_malloc.cpp
index 3de7fcbf62..83956c3a79 100644
--- a/src/SSystem/SComponent/c_malloc.cpp
+++ b/src/SSystem/SComponent/c_malloc.cpp
@@ -6,7 +6,7 @@
 #include "SSystem/SComponent/c_malloc.h"
 #include "JSystem/JKernel/JKRHeap.h"
 
-JKRHeap* cMl::Heap;
+DUSK_GAME_DATA JKRHeap* cMl::Heap;
 
 void cMl::init(JKRHeap* heap) {
     Heap = heap;
diff --git a/src/SSystem/SComponent/c_sxyz.cpp b/src/SSystem/SComponent/c_sxyz.cpp
index 1679155a20..6204f5f272 100644
--- a/src/SSystem/SComponent/c_sxyz.cpp
+++ b/src/SSystem/SComponent/c_sxyz.cpp
@@ -5,7 +5,7 @@
 
 #include "SSystem/SComponent/c_sxyz.h"
 
-const csXyz csXyz::Zero = csXyz(0, 0, 0);
+DUSK_GAME_DATA const csXyz csXyz::Zero = csXyz(0, 0, 0);
 
 csXyz::csXyz(s16 x, s16 y, s16 z) {
     this->x = x;
diff --git a/src/SSystem/SComponent/c_xyz.cpp b/src/SSystem/SComponent/c_xyz.cpp
index be4214a874..f5b6480e62 100644
--- a/src/SSystem/SComponent/c_xyz.cpp
+++ b/src/SSystem/SComponent/c_xyz.cpp
@@ -137,11 +137,11 @@ s16 cXyz::atan2sY_XZ() const {
     return cM_atan2s(-this->y, absXZ());
 }
 
-const cXyz cXyz::Zero(0, 0, 0);
-const cXyz cXyz::BaseX(1, 0, 0);
-const cXyz cXyz::BaseY(0, 1, 0);
-const cXyz cXyz::BaseZ(0, 0, 1);
-const cXyz cXyz::BaseXY(1, 1, 0);
-const cXyz cXyz::BaseXZ(1, 0, 1);
-const cXyz cXyz::BaseYZ(0, 1, 1);
-const cXyz cXyz::BaseXYZ(1, 1, 1);
+DUSK_GAME_DATA const cXyz cXyz::Zero(0, 0, 0);
+DUSK_GAME_DATA const cXyz cXyz::BaseX(1, 0, 0);
+DUSK_GAME_DATA const cXyz cXyz::BaseY(0, 1, 0);
+DUSK_GAME_DATA const cXyz cXyz::BaseZ(0, 0, 1);
+DUSK_GAME_DATA const cXyz cXyz::BaseXY(1, 1, 0);
+DUSK_GAME_DATA const cXyz cXyz::BaseXZ(1, 0, 1);
+DUSK_GAME_DATA const cXyz cXyz::BaseYZ(0, 1, 1);
+DUSK_GAME_DATA const cXyz cXyz::BaseXYZ(1, 1, 1);
diff --git a/src/Z2AudioCS/SpkSystem.cpp b/src/Z2AudioCS/SpkSystem.cpp
index ebe8c0a88c..0e91ca599c 100644
--- a/src/Z2AudioCS/SpkSystem.cpp
+++ b/src/Z2AudioCS/SpkSystem.cpp
@@ -1,6 +1,5 @@
 #include "Z2AudioCS/SpkSystem.h"
 
-#include "../../libs/JSystem/include/JSystem/JKernel/JKRHeap.h"
 #include "JSystem/JAudio2/JASGadget.h"
 #include "JSystem/JAudio2/JASHeapCtrl.h"
 #include "JSystem/JKernel/JKRHeap.h"
diff --git a/src/Z2AudioLib/Z2Audience.cpp b/src/Z2AudioLib/Z2Audience.cpp
index dda1a4b2d0..e5f9bfebf4 100644
--- a/src/Z2AudioLib/Z2Audience.cpp
+++ b/src/Z2AudioLib/Z2Audience.cpp
@@ -745,16 +745,26 @@ f32 Z2Audience::calcRelPosPan(const Vec& param_0, int camID) {
 f32 Z2Audience::calcRelPosDolby(const Vec& param_0, int camID) {
     f32 fVar1 = param_0.z + mAudioCamera[camID].getDolbyCenterZ();
 #if TARGET_PC
-    if (dusk::audio::EnableHrtf) {
+    const auto mode = dusk::getSettings().audio.outputMode.getValue();
+    if (mode >= dusk::AudioOutputMode::StereoHeadphones) {
         // Normalize the direction so result is purely front/back orientation,
         // independent of how far away the sound is
-        f32 lenSq = param_0.x * param_0.x + param_0.y * param_0.y + param_0.z * param_0.z;
+        f32 lenSq = param_0.x * param_0.x + param_0.z * param_0.z;
+        if (mode == dusk::AudioOutputMode::StereoHeadphones) {
+            // original HRTF math
+            lenSq += param_0.y * param_0.y;
+        }
         if (lenSq < 0.0001f) {
             return 0.5f;
         }
         f32 zNorm = param_0.z / sqrtf(lenSq);
         f32 t = (zNorm + 1.0f) * 0.5f;
-        return 0.5f - 0.5f * cosf(t * static_cast<f32>(M_PI));
+        if (mode == dusk::AudioOutputMode::StereoHeadphones) {
+            // original HRTF math
+            return 0.5f - 0.5f * cosf(t * static_cast<f32>(M_PI));
+        } else {
+            return t;
+        }
     }
 #endif
     if (fVar1 > mSetting.field_0x48) {
diff --git a/src/Z2AudioLib/Z2AudioMgr.cpp b/src/Z2AudioLib/Z2AudioMgr.cpp
index d6d78fb4b7..96d49af096 100644
--- a/src/Z2AudioLib/Z2AudioMgr.cpp
+++ b/src/Z2AudioLib/Z2AudioMgr.cpp
@@ -19,8 +19,8 @@
 #include "Z2AudioCS/Z2AudioCS.h"
 #endif
 
-Z2AudioMgr* Z2AudioMgr::mAudioMgrPtr;
-u8 gMuffleOutOfRangeMic = false;
+DUSK_GAME_DATA Z2AudioMgr* Z2AudioMgr::mAudioMgrPtr;
+DUSK_GAME_DATA u8 gMuffleOutOfRangeMic = false;
 
 Z2AudioMgr::Z2AudioMgr() : mSoundStarter(true) {
     mAudioMgrPtr = this;
diff --git a/src/Z2AudioLib/Z2Calc.cpp b/src/Z2AudioLib/Z2Calc.cpp
index 0082ca0e9b..529bd7afd0 100644
--- a/src/Z2AudioLib/Z2Calc.cpp
+++ b/src/Z2AudioLib/Z2Calc.cpp
@@ -19,9 +19,9 @@ f32 Z2Calc::linearTransform(f32 inValue, f32 inMin, f32 inMax, f32 outMin, f32 o
     }
 }
 
-const f32 Z2Calc::cEqualCSlope = 1.0f;
+DUSK_GAME_DATA const f32 Z2Calc::cEqualCSlope = 1.0f;
 
-const f32 Z2Calc::cEqualPSlope = 0.5f;
+DUSK_GAME_DATA const f32 Z2Calc::cEqualPSlope = 0.5f;
 
 f32 Z2Calc::getParamByExp(f32 value, f32 inMin, f32 inMax, f32 exponent, f32 outMin, f32 outMax, Z2Calc::CurveSign curveSign) {
     if (curveSign == Z2Calc::CURVE_POSITIVE) {
diff --git a/src/Z2AudioLib/Z2Creature.cpp b/src/Z2AudioLib/Z2Creature.cpp
index 7a27e9e9c4..f7d7a2924a 100644
--- a/src/Z2AudioLib/Z2Creature.cpp
+++ b/src/Z2AudioLib/Z2Creature.cpp
@@ -10,8 +10,8 @@ static void Z2_E_ms_modVol(Z2SoundHandlePool*, u32);
 static void Z2_E_mm_modPitch(Z2SoundHandlePool*, u32);
 static void Z2_B_zan_modPitch(Z2SoundHandlePool*, u32);
 
-s8 data_80451358;
-s8 data_80451359;
+DUSK_GAME_DATA s8 data_80451358;
+DUSK_GAME_DATA s8 data_80451359;
 
 static Z2EnemyArea const sAreaDefault = {true, 700, 1100, 1500};
 
diff --git a/src/Z2AudioLib/Z2DebugSys.cpp b/src/Z2AudioLib/Z2DebugSys.cpp
index 2764365bc4..5082ff1b3a 100644
--- a/src/Z2AudioLib/Z2DebugSys.cpp
+++ b/src/Z2AudioLib/Z2DebugSys.cpp
@@ -121,7 +121,7 @@ JAISeqDataMgr* Z2DebugSys::initSeSeqDataMgr(const void* param_1) {
 
 u8 gMicOn = true;
 u8 gMicOffWhenOutOfSight = true;
-extern u8 gMuffleOutOfRangeMic;
+DUSK_GAME_EXTERN u8 gMuffleOutOfRangeMic;
 
 void Z2ParamNode::message(JAHControl& ctrl) {
     ctrl.makeComment("**** 各種パラメータ編集用ノード ****", 0, 5, 0);
diff --git a/src/Z2AudioLib/Z2LinkMgr.cpp b/src/Z2AudioLib/Z2LinkMgr.cpp
index 818dfe099e..c759950f0d 100644
--- a/src/Z2AudioLib/Z2LinkMgr.cpp
+++ b/src/Z2AudioLib/Z2LinkMgr.cpp
@@ -47,7 +47,7 @@ void Z2CreatureLink::setLinkBootsType(s32 bootsType) {
     }
 }
 
-Z2CreatureLink* Z2CreatureLink::mLinkPtr;
+DUSK_GAME_DATA Z2CreatureLink* Z2CreatureLink::mLinkPtr;
 
 Z2CreatureLink::Z2CreatureLink() {
     mLinkState = 0;
diff --git a/src/Z2AudioLib/Z2Param.cpp b/src/Z2AudioLib/Z2Param.cpp
index d081c73b07..e1915eb426 100644
--- a/src/Z2AudioLib/Z2Param.cpp
+++ b/src/Z2AudioLib/Z2Param.cpp
@@ -5,81 +5,81 @@
 
 #include "Z2AudioLib/Z2Param.h"
 
-f32 Z2Param::DISTANCE_MAX = 2000.0f;
+DUSK_GAME_DATA f32 Z2Param::DISTANCE_MAX = 2000.0f;
 
-f32 Z2Param::MAX_VOLUME_DISTANCE = 300.0f;
+DUSK_GAME_DATA f32 Z2Param::MAX_VOLUME_DISTANCE = 300.0f;
 
-f32 Z2Param::DOLBY_CENTER_VALUE = 0.3f;
+DUSK_GAME_DATA f32 Z2Param::DOLBY_CENTER_VALUE = 0.3f;
 
-f32 Z2Param::DOLBY_FLONT_DISTANCE_MAX = -300.0f;
+DUSK_GAME_DATA f32 Z2Param::DOLBY_FLONT_DISTANCE_MAX = -300.0f;
 
-f32 Z2Param::DOLBY_BEHIND_DISTANCE_MAX = 600.0f;
+DUSK_GAME_DATA f32 Z2Param::DOLBY_BEHIND_DISTANCE_MAX = 600.0f;
 
-f32 Z2Param::DISTANCE_FX_PARAM = 10.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::DISTANCE_FX_PARAM = 10.0f / 127.0f;
 
-f32 Z2Param::SONIC_SPEED = 360.0f;
+DUSK_GAME_DATA f32 Z2Param::SONIC_SPEED = 360.0f;
 
-f32 Z2Param::VOL_BGM_DEFAULT = 1.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_BGM_DEFAULT = 1.0f;
 
-f32 Z2Param::VOL_SE_SYSTEM_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_SYSTEM_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_VOICE_DEFAULT = 1.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_VOICE_DEFAULT = 1.0f;
 
-f32 Z2Param::VOL_SE_LINK_MOTION_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_MOTION_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_FOOTNOTE_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_FOOTNOTE_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_CHAR_VOICE_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_CHAR_VOICE_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_CHAR_MOVE_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_CHAR_MOVE_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_OBJECT_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_OBJECT_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_ATMOSPHERE_DEFAULT = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_ATMOSPHERE_DEFAULT = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_BGM_TALKING = 0.5f;
+DUSK_GAME_DATA f32 Z2Param::VOL_BGM_TALKING = 0.5f;
 
-f32 Z2Param::VOL_SE_SYSTEM_TALKING = 112.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_SYSTEM_TALKING = 112.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_VOICE_TALKING = 104.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_VOICE_TALKING = 104.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_MOTION_TALKING = 96.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_MOTION_TALKING = 96.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_FOOTNOTE_TALKING = 96.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_FOOTNOTE_TALKING = 96.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_CHAR_VOICE_TALKING = 120.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_CHAR_VOICE_TALKING = 120.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_CHAR_MOVE_TALKING = 119.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_CHAR_MOVE_TALKING = 119.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_OBJECT_TALKING = 96.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_OBJECT_TALKING = 96.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_ATMOSPHERE_TALKING = 96.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_ATMOSPHERE_TALKING = 96.0f / 127.0f;
 
-f32 Z2Param::VOL_BGM_PAUSING = 0.3f;
+DUSK_GAME_DATA f32 Z2Param::VOL_BGM_PAUSING = 0.3f;
 
-f32 Z2Param::VOL_SE_SYSTEM_PAUSING = 112.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_SYSTEM_PAUSING = 112.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_VOICE_PAUSING = 80.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_VOICE_PAUSING = 80.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_MOTION_PAUSING = 72.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_MOTION_PAUSING = 72.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_LINK_FOOTNOTE_PAUSING = 72.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_LINK_FOOTNOTE_PAUSING = 72.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_CHAR_VOICE_PAUSING = 72.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_CHAR_VOICE_PAUSING = 72.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_CHAR_MOVE_PAUSING = 72.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_CHAR_MOVE_PAUSING = 72.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_OBJECT_PAUSING = 72.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_OBJECT_PAUSING = 72.0f / 127.0f;
 
-f32 Z2Param::VOL_SE_ATMOSPHERE_PAUSING = 72.0f / 127.0f;
+DUSK_GAME_DATA f32 Z2Param::VOL_SE_ATMOSPHERE_PAUSING = 72.0f / 127.0f;
 
-u8 Z2Param::SCENE_CHANGE_BGM_FADEOUT_TIME = 33;
+DUSK_GAME_DATA u8 Z2Param::SCENE_CHANGE_BGM_FADEOUT_TIME = 33;
 
-u8 Z2Param::BGM_CROSS_FADEIN_TIME = 60;
+DUSK_GAME_DATA u8 Z2Param::BGM_CROSS_FADEIN_TIME = 60;
 
-u8 Z2Param::BGM_CROSS_FADEOUT_TIME = 60;
+DUSK_GAME_DATA u8 Z2Param::BGM_CROSS_FADEOUT_TIME = 60;
 
-u8 Z2Param::BATTLE_BGM_WAIT_TIME = 30;
+DUSK_GAME_DATA u8 Z2Param::BATTLE_BGM_WAIT_TIME = 30;
 #if DEBUG
 f32 Z2Param::ENEMY_NEARBY_DIST = 700.0f;
 
@@ -87,23 +87,23 @@ f32 Z2Param::BATTLE_FADEIN_DIST = 1100.0f;
 
 f32 Z2Param::BATTLE_FADEOUT_DIST = 1500.0f;
 #endif
-u8 Z2Param::FOUND_TRACK_FI_TIME = 20;
+DUSK_GAME_DATA u8 Z2Param::FOUND_TRACK_FI_TIME = 20;
 
-u8 Z2Param::FOUND_TRACK_FO_TIME = 30;
+DUSK_GAME_DATA u8 Z2Param::FOUND_TRACK_FO_TIME = 30;
 
-u8 Z2Param::CLOSE_BATTLE_TRACK_FI_TIME = 10;
+DUSK_GAME_DATA u8 Z2Param::CLOSE_BATTLE_TRACK_FI_TIME = 10;
 
-u8 Z2Param::CLOSE_BATTLE_TRACK_FO_TIME = 30;
+DUSK_GAME_DATA u8 Z2Param::CLOSE_BATTLE_TRACK_FO_TIME = 30;
 
-u8 Z2Param::ENDING_BLOW_VOL_DOWN_TIME = 1;
+DUSK_GAME_DATA u8 Z2Param::ENDING_BLOW_VOL_DOWN_TIME = 1;
 
-u8 Z2Param::ENDING_BLOW_VOL_LOWER_TIME = 10;
+DUSK_GAME_DATA u8 Z2Param::ENDING_BLOW_VOL_LOWER_TIME = 10;
 
-u8 Z2Param::ENDING_BLOW_VOL_LOWER_RECOVER_TIME = 30;
+DUSK_GAME_DATA u8 Z2Param::ENDING_BLOW_VOL_LOWER_RECOVER_TIME = 30;
 
-u8 Z2Param::ENDING_BLOW_MIN_FINISH_TIME = 20;
+DUSK_GAME_DATA u8 Z2Param::ENDING_BLOW_MIN_FINISH_TIME = 20;
 
-u8 data_8045086C = 1;
+DUSK_GAME_DATA u8 data_8045086C = 1;
 #if DEBUG
 f32 Z2Param::AUDIBLE_DELTA_RANGE_VOLUME = 0.25f;
 
@@ -111,12 +111,12 @@ f32 Z2Param::AUDIBLE_DELTA_RANGE_PAN = 0.15f;
 
 f32 Z2Param::AUDIBLE_DELTA_RANGE_DOLBY = 0.15f;
 #endif
-f32 Z2Param::MIN_DISTANCE_VOLUME;
+DUSK_GAME_DATA f32 Z2Param::MIN_DISTANCE_VOLUME;
 
-f32 Z2Param::ENEMY_LASTHIT_MUTE_VOLUME;
+DUSK_GAME_DATA f32 Z2Param::ENEMY_LASTHIT_MUTE_VOLUME;
 
-u8 Z2Param::DARK_SE_FILTER_ON;
+DUSK_GAME_DATA u8 Z2Param::DARK_SE_FILTER_ON;
 
-u8 Z2Param::DARK_SE_LOW_PASS_FILTER_SETTING;
+DUSK_GAME_DATA u8 Z2Param::DARK_SE_LOW_PASS_FILTER_SETTING;
 
-u8 Z2Param::SYSTEM_SE_USE_DARK_SE_SETTING;
+DUSK_GAME_DATA u8 Z2Param::SYSTEM_SE_USE_DARK_SE_SETTING;
diff --git a/src/Z2AudioLib/Z2SeqMgr.cpp b/src/Z2AudioLib/Z2SeqMgr.cpp
index a3e45d8acd..0658f7eb54 100644
--- a/src/Z2AudioLib/Z2SeqMgr.cpp
+++ b/src/Z2AudioLib/Z2SeqMgr.cpp
@@ -11,7 +11,10 @@
 #include "Z2AudioLib/SpotName.h"
 #include "os_report.h"
 
+#if TARGET_PC
 #include "dusk/audio.h"
+#include "dusk/version.hpp"
+#endif
 
 Z2SeqMgr::Z2SeqMgr() : JASGlobalInstance<Z2SeqMgr>(true) {
     mMainBgmMaster.forceIn();
@@ -584,7 +587,7 @@ void Z2SeqMgr::bgmStreamPlay() {
     }
 
     #if !PLATFORM_SHIELD
-    else if (getStreamBgmID() == 0x2000000) {
+    else if (getStreamBgmID() == 0x2000000 IF_DUSK(&& dusk::version::isGcn())) {
         if (mStreamBgmHandle) {
             mStreamBgmHandle->stop();
         }
diff --git a/src/Z2AudioLib/Z2SoundInfo.cpp b/src/Z2AudioLib/Z2SoundInfo.cpp
index a298213dca..cb67b4c805 100644
--- a/src/Z2AudioLib/Z2SoundInfo.cpp
+++ b/src/Z2AudioLib/Z2SoundInfo.cpp
@@ -8,7 +8,7 @@
 #include "Z2AudioLib/Z2Calc.h"
 
 struct JAUStdSoundTableType {
-    static const u32 STRM_CH_SHIFT;
+    static DUSK_GAME_DATA const u32 STRM_CH_SHIFT;
     struct StringOffset {
         static inline const char* getString(const void* addr, u32 offset) {
             return (const char*)addr + offset;
@@ -230,7 +230,7 @@ void Z2SoundInfo::getSeqInfo(JAISoundID soundID, JAISeq* seqPtr) const {
     getSoundInfo_(soundID, seqPtr);
 }
 
-const u32 JAUStdSoundTableType::STRM_CH_SHIFT = 2;
+DUSK_GAME_DATA const u32 JAUStdSoundTableType::STRM_CH_SHIFT = 2;
 
 void Z2SoundInfo::getStreamInfo(JAISoundID soundID, JAIStream* streamPtr) const {
     int numChild;
diff --git a/src/Z2AudioLib/Z2SoundObjMgr.cpp b/src/Z2AudioLib/Z2SoundObjMgr.cpp
index 19099c7675..013dbd1c54 100644
--- a/src/Z2AudioLib/Z2SoundObjMgr.cpp
+++ b/src/Z2AudioLib/Z2SoundObjMgr.cpp
@@ -6,6 +6,8 @@
 #include "Z2AudioLib/Z2LinkMgr.h"
 #include <cstring>
 
+#include "dusk/version.hpp"
+
 Z2SoundObjMgr::Z2SoundObjMgr() : JASGlobalInstance<Z2SoundObjMgr>(true) {
     ghostEnemyState_ = 0;
     twilightBattle_ = 0;
@@ -180,6 +182,13 @@ void Z2SoundObjMgr::searchEnemy() {
         case Z2_ENEMY_PO:
         case Z2_ENEMY_HP:
             isGhostEnemy = true;
+#if TARGET_PC
+            if (enemyId == Z2_ENEMY_HP && dusk::version::isRegionJpn() &&
+                Z2GetLink()->isRiding() && Z2GetLink()->getMoveSpeed() > 38)
+            {
+                continue;
+            }
+#endif
             break;
         case Z2_ENEMY_RDB:
             if (subBgmType == 0)
@@ -207,6 +216,10 @@ void Z2SoundObjMgr::searchEnemy() {
         case Z2_ENEMY_RD:
         case Z2_ENEMY_SH:
         case Z2_ENEMY_HP:
+#elif TARGET_PC
+        case Z2_ENEMY_SH:
+            if (enemyId == Z2_ENEMY_SH && !dusk::version::isRegionJpn())
+                break;
 #endif
             if (!Z2GetLink()->isRiding())
                 break;
diff --git a/src/Z2AudioLib/Z2SpeechMgr2.cpp b/src/Z2AudioLib/Z2SpeechMgr2.cpp
index 8b1402ff5b..914098fa36 100644
--- a/src/Z2AudioLib/Z2SpeechMgr2.cpp
+++ b/src/Z2AudioLib/Z2SpeechMgr2.cpp
@@ -19,61 +19,61 @@ struct Z2MdnPrm {
         u8 tailNum2;
     };
 
-    static Unit const sReply[50];
-    static u8 const sReplyTail[10];
+    static DUSK_GAME_DATA Unit const sReply[50];
+    static DUSK_GAME_DATA u8 const sReplyTail[10];
 
-    static Unit const sJoke[50];
-    static u8 const sJokeTail[10];
+    static DUSK_GAME_DATA Unit const sJoke[50];
+    static DUSK_GAME_DATA u8 const sJokeTail[10];
 
-    static Unit const sSexy[50];
-    static u8 const sSexyTail[10];
+    static DUSK_GAME_DATA Unit const sSexy[50];
+    static DUSK_GAME_DATA u8 const sSexyTail[10];
 
-    static Unit const sRidicule[50];
-    static u8 const sRidiculeTail[10];
+    static DUSK_GAME_DATA Unit const sRidicule[50];
+    static DUSK_GAME_DATA u8 const sRidiculeTail[10];
 
-    static Unit const sBoring[54];
-    static u8 const sBoringTail[6];
+    static DUSK_GAME_DATA Unit const sBoring[54];
+    static DUSK_GAME_DATA u8 const sBoringTail[6];
 
-    static Unit const sIrritated[47];
-    static u8 const sIrritatedTail[10];
+    static DUSK_GAME_DATA Unit const sIrritated[47];
+    static DUSK_GAME_DATA u8 const sIrritatedTail[10];
 
-    static Unit const sOrder[57];
-    static u8 const sOrderTail[6];
+    static DUSK_GAME_DATA Unit const sOrder[57];
+    static DUSK_GAME_DATA u8 const sOrderTail[6];
 
-    static Unit const sResent[53];
-    static u8 const sResentTail[5];
+    static DUSK_GAME_DATA Unit const sResent[53];
+    static DUSK_GAME_DATA u8 const sResentTail[5];
 
-    static Unit const sCheerful[53];
-    static u8 const sCheerfulTail[8];
+    static DUSK_GAME_DATA Unit const sCheerful[53];
+    static DUSK_GAME_DATA u8 const sCheerfulTail[8];
 
-    static Unit const sConfused[53];
-    static u8 const sConfusedTail[5];
+    static DUSK_GAME_DATA Unit const sConfused[53];
+    static DUSK_GAME_DATA u8 const sConfusedTail[5];
 
-    static Unit const sHostility[52];
-    static u8 const sHostilityTail[7];
+    static DUSK_GAME_DATA Unit const sHostility[52];
+    static DUSK_GAME_DATA u8 const sHostilityTail[7];
 
-    static Unit const sTired[53];
-    static u8 const sTiredTail[8];
+    static DUSK_GAME_DATA Unit const sTired[53];
+    static DUSK_GAME_DATA u8 const sTiredTail[8];
 
-    static Unit const sSerious[53];
-    static u8 const sSeriousTail[7];
+    static DUSK_GAME_DATA Unit const sSerious[53];
+    static DUSK_GAME_DATA u8 const sSeriousTail[7];
 
-    static Unit const sReplyb[42];
-    static u8 const sReplybTail[7];
+    static DUSK_GAME_DATA Unit const sReplyb[42];
+    static DUSK_GAME_DATA u8 const sReplybTail[7];
 
-    static Unit const sApologize[50];
-    static u8 const sApologizeTail[9];
+    static DUSK_GAME_DATA Unit const sApologize[50];
+    static DUSK_GAME_DATA u8 const sApologizeTail[9];
 
-    static Unit const sDeside[50];
-    static u8 const sDesideTail[8];
+    static DUSK_GAME_DATA Unit const sDeside[50];
+    static DUSK_GAME_DATA u8 const sDesideTail[8];
 
-    static Unit const sAfford[52];
-    static u8 const sAffordTail[12];
+    static DUSK_GAME_DATA Unit const sAfford[52];
+    static DUSK_GAME_DATA u8 const sAffordTail[12];
 
-    static Prm const sPrm[17];
+    static DUSK_GAME_DATA Prm const sPrm[17];
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sReply[50] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sReply[50] = {
     0x6A, 0x8A, 0x50, 0x5F, 0x53, 0x37, 0x37, 0x4F, 0x4F, 0x5E, 0xAA, 0x46, 0x52, 0x5A, 0x5A,
     0x4F, 0x4F, 0x45, 0x45, 0x56, 0x64, 0x79, 0x79, 0x79, 0x87, 0x95, 0x95, 0x89, 0x89, 0x4C,
     0x4C, 0x4B, 0x52, 0x41, 0x41, 0x5B, 0x5F, 0x71, 0x53, 0x47, 0x89, 0x7D, 0x77, 0x88, 0x88,
@@ -83,11 +83,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sReply[50] = {
     0x71, 0x85, 0x85, 0xA2, 0xA2, 0x52, 0x52, 0x5C, 0x5C, 0x75,
 };
 
-u8 const Z2MdnPrm::sReplyTail[10] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sReplyTail[10] = {
     0x5E, 0x7F, 0x68, 0x39, 0x56, 0x75, 0x47, 0x71, 0x7D, 0x33,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sJoke[50] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sJoke[50] = {
     0x68, 0x57, 0x57, 0x55, 0x55, 0x51, 0x5B, 0x64, 0x6B, 0x7B, 0x7B, 0x5C, 0x77, 0x97, 0x8D,
     0x97, 0x97, 0x8D, 0x66, 0x69, 0xA2, 0x5C, 0x87, 0x4F, 0x69, 0x5F, 0x5F, 0x83, 0x83, 0x82,
     0x7F, 0x96, 0x96, 0xB0, 0x70, 0xA1, 0x6D, 0x6D, 0x6D, 0x59, 0x4C, 0x4B, 0x5A, 0x40, 0x4A,
@@ -97,11 +97,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sJoke[50] = {
     0x45, 0x45, 0x29, 0x4C, 0x4B, 0x64, 0x64, 0x60, 0x5C, 0xB1,
 };
 
-u8 const Z2MdnPrm::sJokeTail[10] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sJokeTail[10] = {
     0x51, 0x97, 0x60, 0xB0, 0x6F, 0x5E, 0x5A, 0xA6, 0x4F, 0x4F,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sSexy[50] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sSexy[50] = {
     0x5E, 0x60, 0x5F, 0x63, 0x63, 0x72, 0x72, 0x78, 0x4D, 0x7A, 0x6E, 0x6E, 0x6E, 0x6E, 0x6E,
     0x59, 0x59, 0x7A, 0x7A, 0xA5, 0x90, 0x8D, 0x86, 0x62, 0x72, 0x79, 0x79, 0x86, 0x7F, 0x8B,
     0x85, 0x7B, 0x7B, 0x5E, 0x5E, 0x6D, 0x6D, 0x88, 0x5F, 0xA3, 0xA3, 0x95, 0x95, 0x7F, 0x79,
@@ -111,11 +111,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sSexy[50] = {
     0x79, 0x65, 0x65, 0x4A, 0x5C, 0x78, 0x78, 0x8B, 0x8D, 0x7C,
 };
 
-u8 const Z2MdnPrm::sSexyTail[10] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sSexyTail[10] = {
     0x52, 0x79, 0x82, 0xA5, 0x62, 0x86, 0x3F, 0x7D, 0x57, 0x7C,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sRidicule[50] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sRidicule[50] = {
     0xA7, 0x5A, 0x5A, 0x52, 0x52, 0x85, 0x85, 0x8C, 0x63, 0x73, 0x73, 0x90, 0x50, 0x46, 0x74,
     0x74, 0xA3, 0xA7, 0x41, 0x51, 0x58, 0x34, 0x34, 0x2A, 0x5A, 0x81, 0x5D, 0x42, 0x4B, 0x70,
     0x70, 0xB1, 0xB1, 0xB1, 0xB1, 0x65, 0x6A, 0xB1, 0x54, 0xA8, 0xA8, 0x6B, 0x6C, 0x55, 0x55,
@@ -125,11 +125,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sRidicule[50] = {
     0x2D, 0x2D, 0x2D, 0x8C, 0x8C, 0x8B, 0x8B, 0x93, 0x93, 0x6E,
 };
 
-u8 const Z2MdnPrm::sRidiculeTail[10] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sRidiculeTail[10] = {
     0x81, 0x67, 0x6D, 0x8C, 0x90, 0x85, 0xB1, 0x4D, 0x4F, 0x6E,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sBoring[54] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sBoring[54] = {
     0x8E, 0x9C, 0x9C, 0x5A, 0x5A, 0x52, 0x52, 0x5B, 0x5C, 0x56, 0x5C, 0x52, 0x52, 0x2D, 0x2D, 0x5B,
     0x59, 0x56, 0x56, 0x56, 0x56, 0x6B, 0x6B, 0x58, 0x4C, 0x8E, 0x8E, 0x59, 0x61, 0x54, 0xA0, 0x4D,
     0x5D, 0x59, 0x48, 0x30, 0x30, 0x5B, 0x5B, 0x5B, 0x4A, 0x64, 0x64, 0x7A, 0x7A, 0x92, 0x62, 0x62,
@@ -139,11 +139,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sBoring[54] = {
     0x5B, 0x5E, 0x70, 0x56, 0x56, 0x4C, 0x4C, 0x59, 0x59, 0x5B, 0x5B, 0x71,
 };
 
-u8 const Z2MdnPrm::sBoringTail[6] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sBoringTail[6] = {
     0x92, 0x58, 0x59, 0x5B, 0x70, 0x71,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sIrritated[47] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sIrritated[47] = {
     0x6C, 0x91, 0x67, 0x8B, 0x8B, 0xA2, 0xA2, 0xAB, 0x48, 0x64, 0x73, 0x61, 0x61, 0x64, 0x64, 0x6D,
     0x60, 0x7E, 0x4A, 0x55, 0x6A, 0x63, 0x66, 0x78, 0x5C, 0x5A, 0x6E, 0x79, 0x75, 0x62, 0x62, 0x57,
     0x85, 0x3F, 0x3C, 0x83, 0x83, 0x9B, 0x78, 0x65, 0x65, 0x67, 0x65, 0x65, 0x87, 0x88, 0x88, 0x3D,
@@ -152,11 +152,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sIrritated[47] = {
     0xAD, 0x6E, 0x72, 0x82, 0x83, 0x87, 0x85, 0x85, 0x85, 0x8E, 0x60, 0x6D, 0x80, 0x80,
 };
 
-u8 const Z2MdnPrm::sIrritatedTail[10] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sIrritatedTail[10] = {
     0x64, 0x61, 0x4E, 0x91, 0xA0, 0x85, 0x9B, 0x67, 0x6F, 0x64,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sOrder[57] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sOrder[57] = {
     0x77, 0x5F, 0x5F, 0x73, 0x73, 0x66, 0x66, 0x6B, 0x6B, 0x7A, 0x7A, 0x60, 0x54, 0x5F, 0x5F,
     0x69, 0x69, 0x5A, 0x86, 0x84, 0x84, 0x96, 0x96, 0x94, 0x94, 0x8A, 0x87, 0x84, 0x5A, 0x2C,
     0x4E, 0x52, 0x52, 0x52, 0x52, 0x51, 0x51, 0x6E, 0x62, 0x5E, 0x6C, 0xA3, 0xA3, 0x5B, 0x62,
@@ -167,11 +167,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sOrder[57] = {
     0x48, 0x48, 0x69, 0x69, 0x6D, 0x6D, 0x94, 0x94, 0x97,
 };
 
-u8 const Z2MdnPrm::sOrderTail[6] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sOrderTail[6] = {
     0x60, 0xA8, 0x5B, 0x4E, 0x5D, 0x87,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sResent[53] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sResent[53] = {
     0x6F, 0x5F, 0x5F, 0x66, 0x66, 0x66, 0x66, 0x55, 0x55, 0x55, 0x55, 0x4B, 0x4B, 0x6B, 0x6B, 0x86,
     0x86, 0x4A, 0x4A, 0x6D, 0x6D, 0x6D, 0x6D, 0x8C, 0x8C, 0x84, 0x84, 0x64, 0x64, 0x6C, 0x6C, 0x92,
     0x92, 0x6A, 0x5F, 0x6F, 0x6F, 0x62, 0x62, 0x62, 0x75, 0x5A, 0x5A, 0x5A, 0x5A, 0x60, 0x60, 0x6A,
@@ -181,11 +181,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sResent[53] = {
     0x5E, 0xAA, 0xAA, 0x9E, 0x9E, 0x5A, 0x5A, 0x57, 0x57, 0x57,
 };
 
-u8 const Z2MdnPrm::sResentTail[5] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sResentTail[5] = {
     0x4A, 0x98, 0x8A, 0x7E, 0x57,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sCheerful[53] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sCheerful[53] = {
     0x64, 0x6D, 0x6D, 0x6D, 0x99, 0x6D, 0x40, 0x51, 0x51, 0x6F, 0x6F, 0x66, 0x66, 0x60, 0xA7, 0xAF,
     0xB3, 0x61, 0x61, 0xA7, 0xA7, 0x5E, 0x8B, 0x75, 0x77, 0x72, 0x72, 0x93, 0x93, 0x8B, 0x8B, 0x88,
     0x88, 0x77, 0x77, 0x80, 0x80, 0x80, 0x80, 0x67, 0x67, 0x4D, 0x4A, 0x69, 0x44, 0xA1, 0x64, 0xA8,
@@ -195,11 +195,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sCheerful[53] = {
     0x65, 0x70, 0x6B, 0x6B, 0x6B, 0x6D, 0x6D, 0x57, 0x57, 0x7B,
 };
 
-u8 const Z2MdnPrm::sCheerfulTail[8] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sCheerfulTail[8] = {
     0x60, 0x6D, 0x4D, 0x44, 0x9C, 0x54, 0x70, 0x7B,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sConfused[53] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sConfused[53] = {
     0x83, 0x80, 0x80, 0x82, 0x82, 0x82, 0x82, 0x5B, 0x75, 0x84, 0x84, 0x84, 0x84, 0x75, 0x75, 0x62,
     0x62, 0x62, 0x4D, 0x56, 0x56, 0x59, 0x59, 0x59, 0x59, 0x74, 0x74, 0x85, 0x7D, 0x8D, 0x8D, 0x70,
     0x70, 0x5A, 0x5A, 0x6B, 0x6B, 0x6B, 0x6B, 0x70, 0x79, 0x73, 0x73, 0x71, 0x71, 0x75, 0x75, 0x7B,
@@ -209,11 +209,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sConfused[53] = {
     0x38, 0x38, 0x38, 0x83, 0x83, 0x8E, 0x8E, 0x4C, 0x56, 0x56,
 };
 
-u8 const Z2MdnPrm::sConfusedTail[5] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sConfusedTail[5] = {
     0x2C, 0x42, 0x4C, 0x7C, 0x49,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sHostility[52] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sHostility[52] = {
     0x85, 0x71, 0x71, 0x73, 0x73, 0x3B, 0x62, 0x84, 0x94, 0x94, 0x94, 0xAF, 0x98, 0xAD, 0xAD,
     0x5A, 0x5A, 0x63, 0x63, 0x97, 0x90, 0x90, 0x7B, 0x73, 0x73, 0x63, 0x63, 0x55, 0x55, 0x65,
     0x66, 0x7F, 0x7F, 0x87, 0x87, 0x8A, 0x8A, 0x94, 0x5D, 0x5C, 0x5A, 0x67, 0x67, 0x68, 0x68,
@@ -223,11 +223,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sHostility[52] = {
     0x62, 0x6A, 0x5F, 0x72, 0x72, 0x62, 0x62, 0x65, 0x5E, 0x69, 0x69, 0x63, 0x63, 0x7F,
 };
 
-u8 const Z2MdnPrm::sHostilityTail[7] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sHostilityTail[7] = {
     0x97, 0x67, 0x94, 0x6A, 0x66, 0x4F, 0x6A,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sTired[53] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sTired[53] = {
     0x70, 0x70, 0x70, 0x5C, 0x5C, 0x5C, 0x6F, 0x6F, 0x6F, 0x93, 0x8C, 0x9A, 0x9D, 0x89, 0x99, 0x7A,
     0x91, 0x8D, 0x8D, 0x8D, 0x8D, 0x69, 0x69, 0x72, 0x72, 0x65, 0x65, 0x65, 0x9E, 0x98, 0x98, 0x2A,
     0x50, 0x54, 0x54, 0x49, 0x64, 0x59, 0x59, 0x62, 0x62, 0x62, 0x44, 0x5E, 0x9F, 0x91, 0x63, 0x63,
@@ -237,11 +237,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sTired[53] = {
     0x84, 0x6D, 0x6D, 0x6A, 0x6A, 0x8D, 0x8D, 0x8D, 0x8D, 0x3B,
 };
 
-u8 const Z2MdnPrm::sTiredTail[8] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sTiredTail[8] = {
     0x66, 0x6F, 0x3B, 0x7A, 0x49, 0x91, 0x5C, 0x6A,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sSerious[53] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sSerious[53] = {
     0x52, 0x65, 0x65, 0x72, 0x5A, 0x61, 0x61, 0x7B, 0x80, 0x92, 0x93, 0x9D, 0x9D, 0x70, 0x79, 0x76,
     0x62, 0x57, 0x5A, 0x53, 0x53, 0x59, 0x59, 0x65, 0x63, 0x60, 0x60, 0x6A, 0x83, 0x80, 0x7F, 0x5D,
     0x5C, 0x45, 0x5D, 0x71, 0x72, 0x65, 0x65, 0x65, 0x66, 0x4B, 0xB2, 0x60, 0x5C, 0x5C, 0x5C, 0x5B,
@@ -251,11 +251,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sSerious[53] = {
     0x70, 0x60, 0x3C, 0x81, 0x81, 0x92, 0x92, 0x8E, 0x98, 0x87,
 };
 
-u8 const Z2MdnPrm::sSeriousTail[7] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sSeriousTail[7] = {
     0x7B, 0x69, 0x4B, 0x61, 0x52, 0x59, 0x87,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sReplyb[42] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sReplyb[42] = {
     0x5C, 0x45, 0x45, 0x71, 0x9F, 0x57, 0xB4, 0xB4, 0x56, 0x62, 0x8E, 0x61, 0x61, 0xB0,
     0xB0, 0x3C, 0x59, 0x4A, 0x64, 0xA4, 0xA4, 0x5A, 0x5A, 0x5A, 0x5A, 0x72, 0x72, 0x4B,
     0x6B, 0x97, 0x97, 0x59, 0x60, 0x60, 0x60, 0x69, 0x3E, 0x3E, 0x57, 0x42, 0x5E, 0x76,
@@ -264,11 +264,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sReplyb[42] = {
     0x44, 0x4F, 0x52, 0x58, 0x5A, 0x6F, 0x6E, 0x8A, 0x8E, 0x8E, 0x8E, 0x8C, 0x8C, 0x9B,
 };
 
-u8 const Z2MdnPrm::sReplybTail[7] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sReplybTail[7] = {
     0x4F, 0x4A, 0xA2, 0x4F, 0x65, 0x98, 0x5C,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sApologize[50] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sApologize[50] = {
     0x6A, 0x6A, 0x6A, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x51, 0x57, 0x57, 0x57, 0x63, 0x61,
     0x54, 0x54, 0x54, 0x54, 0x58, 0x58, 0x58, 0x58, 0x45, 0x45, 0x56, 0x56, 0x5B, 0x5B, 0x37,
     0x53, 0x53, 0x53, 0x59, 0x59, 0x59, 0x49, 0x58, 0x58, 0x55, 0x56, 0x56, 0x83, 0x7F, 0x7F,
@@ -278,11 +278,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sApologize[50] = {
     0x64, 0x60, 0x61, 0x63, 0x6A, 0x62, 0x62, 0x64, 0x65, 0x71,
 };
 
-u8 const Z2MdnPrm::sApologizeTail[9] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sApologizeTail[9] = {
     0x7C, 0x6E, 0x63, 0x71, 0x51, 0x37, 0x75, 0x58, 0x5C,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sDeside[50] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sDeside[50] = {
     0x77, 0x77, 0x77, 0x58, 0x58, 0x6F, 0x78, 0x5F, 0x66, 0x5E, 0x6E, 0x62, 0x62, 0x2E, 0x5A,
     0x58, 0x54, 0x52, 0x52, 0x5C, 0x59, 0x56, 0x56, 0x4B, 0x4B, 0x63, 0x63, 0x4D, 0x4E, 0x4A,
     0x69, 0x71, 0x71, 0x76, 0x80, 0x80, 0x80, 0x73, 0x73, 0x5C, 0x7C, 0x64, 0x83, 0x89, 0x89,
@@ -292,11 +292,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sDeside[50] = {
     0x75, 0x6A, 0x66, 0x76, 0x69, 0x69, 0x69, 0x60, 0x60, 0x5F,
 };
 
-u8 const Z2MdnPrm::sDesideTail[8] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sDesideTail[8] = {
     0x64, 0x2E, 0x4A, 0x57, 0x80, 0x48, 0x7C, 0x5F,
 };
 
-Z2MdnPrm::Unit const Z2MdnPrm::sAfford[52] = {
+DUSK_GAME_DATA Z2MdnPrm::Unit const Z2MdnPrm::sAfford[52] = {
     0x4E, 0x45, 0x52, 0x5B, 0x56, 0x5B, 0x59, 0x52, 0x52, 0x57, 0x5C, 0x50, 0x50, 0x49, 0x80,
     0x6E, 0x6E, 0x5A, 0x5C, 0x60, 0x6A, 0x62, 0x62, 0x6A, 0x71, 0x48, 0x4C, 0x5B, 0x5A, 0x40,
     0x40, 0x49, 0x49, 0x50, 0x51, 0x51, 0x51, 0x3A, 0x5A, 0x5A, 0x5A, 0x5A, 0x5A, 0x57, 0x57,
@@ -306,11 +306,11 @@ Z2MdnPrm::Unit const Z2MdnPrm::sAfford[52] = {
     0x63, 0x5D, 0x69, 0x70, 0x56, 0x50, 0x4B, 0x92, 0x86, 0x8F, 0x4B, 0x4F, 0x57, 0x56,
 };
 
-u8 const Z2MdnPrm::sAffordTail[12] = {
+DUSK_GAME_DATA u8 const Z2MdnPrm::sAffordTail[12] = {
     0x63, 0x8E, 0x5B, 0x59, 0x4C, 0x3A, 0x69, 0x47, 0x41, 0x59, 0x50, 0x55,
 };
 
-const Z2MdnPrm::Prm Z2MdnPrm::sPrm[17] = {
+DUSK_GAME_DATA const Z2MdnPrm::Prm Z2MdnPrm::sPrm[17] = {
     {Z2MdnPrm::sReply,     Z2MdnPrm::sReplyTail,     ARRAY_SIZE(Z2MdnPrm::sReply),      6, 4},
     {Z2MdnPrm::sJoke,      Z2MdnPrm::sJokeTail,      ARRAY_SIZE(Z2MdnPrm::sJoke),       3, 7},
     {Z2MdnPrm::sSexy,      Z2MdnPrm::sSexyTail,      ARRAY_SIZE(Z2MdnPrm::sSexy),       3, 7},
diff --git a/src/c/c_damagereaction.cpp b/src/c/c_damagereaction.cpp
index b8da6e4535..7b6921ca3a 100644
--- a/src/c/c_damagereaction.cpp
+++ b/src/c/c_damagereaction.cpp
@@ -4,15 +4,15 @@
 #include "f_op/f_op_actor_mng.h"
 #include "d/d_s_play.h"
 
-u8 cDmr_SkipInfo;
-u8 data_80450C99;
-u8 data_80450C9A;
-u8 data_80450C9B;
+DUSK_GAME_DATA u8 cDmr_SkipInfo;
+DUSK_GAME_DATA u8 data_80450C99;
+DUSK_GAME_DATA u8 data_80450C9A;
+DUSK_GAME_DATA u8 data_80450C9B;
 
-u8 data_80450C9C;
-u8 data_80450C9D;
-u8 data_80450C9E;
-u8 cDmr_FishingWether;
+DUSK_GAME_DATA u8 data_80450C9C;
+DUSK_GAME_DATA u8 data_80450C9D;
+DUSK_GAME_DATA u8 data_80450C9E;
+DUSK_GAME_DATA u8 cDmr_FishingWether;
 
 #if DEBUG
 void debug_actor_create() {
@@ -60,8 +60,8 @@ BOOL cDmrNowMidnaTalk() {
     return 0;
 }
 
-u8 data_80450CA0;
+DUSK_GAME_DATA u8 data_80450CA0;
 
 extern "C" {
-    JPTraceParticleCallBack4 JPTracePCB4;
+    DUSK_GAME_DATA JPTraceParticleCallBack4 JPTracePCB4;
 }
diff --git a/src/d/actor/d_a_alink.cpp b/src/d/actor/d_a_alink.cpp
index e5e23600e5..02552022a8 100644
--- a/src/d/actor/d_a_alink.cpp
+++ b/src/d/actor/d_a_alink.cpp
@@ -53,11 +53,25 @@
 
 #if TARGET_PC
 #include "dusk/action_bindings.h"
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/dual_buffer.h"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/settings.h"
 #include "res/Object/Alink.h"
 #include <cstring>
-#include <dusk/string.hpp>
+#include <helpers/string.hpp>
+
+static const int IRON_BALL_CHAIN_COUNT = 102;
+static const int HS_CHAIN_ANCHOR_COUNT = 4;
+
+namespace {
+struct AlinkInterp {
+    dusk::interp::DualBuffer<cXyz, IRON_BALL_CHAIN_COUNT> ib_pos;
+    dusk::interp::DualBuffer<csXyz, IRON_BALL_CHAIN_COUNT> ib_angle;
+    dusk::interp::DualBuffer<cXyz, 1> ib_hand;
+    cXyz hs_draw[HS_CHAIN_ANCHOR_COUNT];
+    dusk::interp::DualBuffer<cXyz, HS_CHAIN_ANCHOR_COUNT> hs_chain{hs_draw};
+};
+}  // namespace
 #endif
 
 static int daAlink_Create(fopAc_ac_c* i_this);
@@ -217,7 +231,7 @@ static s16 const l_insectNameList[12] = {
 f32 l_jumpTop;
 #endif
 
-daAlink_BckData const daAlink_c::m_mainBckShield[20] = {
+DUSK_GAME_DATA daAlink_BckData const daAlink_c::m_mainBckShield[20] = {
     {dRes_ID_ALANM_BCK_ATRFWS_e, dRes_ID_ALANM_BCK_ATRFWS_e},
     {dRes_ID_ALANM_BCK_ATRFDS_e, dRes_ID_ALANM_BCK_ATRFDS_e},
     {dRes_ID_ALANM_BCK_ATBW_e, dRes_ID_ALANM_BCK_ATLS_e},
@@ -240,7 +254,7 @@ daAlink_BckData const daAlink_c::m_mainBckShield[20] = {
     {dRes_ID_ALANM_BCK_DASHS_e, dRes_ID_ALANM_BCK_ATLS_e},
 };
 
-daAlink_BckData const daAlink_c::m_mainBckSword[5] = {
+DUSK_GAME_DATA daAlink_BckData const daAlink_c::m_mainBckSword[5] = {
     {dRes_ID_ALANM_BCK_ATL_e, dRes_ID_ALANM_BCK_ATL_e},
     {dRes_ID_ALANM_BCK_ATR_e, dRes_ID_ALANM_BCK_ATR_e},
     {dRes_ID_ALANM_BCK_WALKS_e, dRes_ID_ALANM_BCK_WALKS_e},
@@ -248,7 +262,7 @@ daAlink_BckData const daAlink_c::m_mainBckSword[5] = {
     {dRes_ID_ALANM_BCK_SWIMWAIT_e, dRes_ID_ALANM_BCK_SWIMWAITS_e},
 };
 
-daAlink_BckData const daAlink_c::m_mainBckFishing[28] = {
+DUSK_GAME_DATA daAlink_BckData const daAlink_c::m_mainBckFishing[28] = {
     {dRes_ID_ALANM_BCK_ATRFWS_e, dRes_ID_ALANM_BCK_WALKFISHR_e},
     {dRes_ID_ALANM_BCK_ATRFDS_e, dRes_ID_ALANM_BCK_DASHFISHR_e},
     {dRes_ID_ALANM_BCK_ATBW_e, dRes_ID_ALANM_BCK_WALKFISHR_e},
@@ -279,7 +293,7 @@ daAlink_BckData const daAlink_c::m_mainBckFishing[28] = {
     {dRes_ID_ALANM_BCK_WAITBTOA_e, dRes_ID_ALANM_BCK_WALKFISHR_e},
 };
 
-daAlink_AnmData const daAlink_c::m_anmDataTable[daAlink_c::ANM_MAX] = {
+DUSK_GAME_DATA daAlink_AnmData const daAlink_c::m_anmDataTable[daAlink_c::ANM_MAX] = {
     {dRes_ID_ALANM_BCK_ATRFWS_e, dRes_ID_ALANM_BCK_ATRFW_e, 0xFE, 0xFE, FTANM_0, dRes_ID_ALANM_BCK_FAT_e, 0x0},
     {dRes_ID_ALANM_BCK_ATRFDS_e, dRes_ID_ALANM_BCK_ATRFD_e, 0xFE, 0xFE, FTANM_0, dRes_ID_ALANM_BCK_FAT_e, 0x0},
     {dRes_ID_ALANM_BCK_ATBW_e, dRes_ID_ALANM_BCK_ATBW_e, 0xFE, 0xFE, FTANM_0, dRes_ID_ALANM_BCK_FAT_e, 0x0},
@@ -696,7 +710,7 @@ daAlink_AnmData const daAlink_c::m_anmDataTable[daAlink_c::ANM_MAX] = {
     {dRes_ID_ALANM_BCK_ASHIMOTO_e, dRes_ID_ALANM_BCK_ASHIMOTO_e, 0xFE, 0xFE, FTANM_ASHIMOTO, dRes_ID_ALANM_BCK_FASHIMOTO_e, 0x0},
 };
 
-daAlink_WlAnmData const daAlink_c::m_wlAnmDataTable[daAlink_c::WANM_MAX] = {
+DUSK_GAME_DATA daAlink_WlAnmData const daAlink_c::m_wlAnmDataTable[daAlink_c::WANM_MAX] = {
     {dRes_ID_ALANM_BCK_WL_WAITA_e, 0x0, 0x1, 10, 40, -1, -1},
     {dRes_ID_ALANM_BCK_WL_WALKA_e, 0x0, 0x2, 1, 14, -1, -1},
     {dRes_ID_ALANM_BCK_WL_WALKB_e, 0x0, 0x2, 1, 14, -1, -1},
@@ -846,7 +860,7 @@ daAlink_WlAnmData const daAlink_c::m_wlAnmDataTable[daAlink_c::WANM_MAX] = {
     {0x802B, 0xC, 0xC, -1, -1, -1, -1},
 };
 
-daAlink_FaceTexData const daAlink_c::m_faceTexDataTable[] = {
+DUSK_GAME_DATA daAlink_FaceTexData const daAlink_c::m_faceTexDataTable[] = {
     {dRes_ID_ALANM_BTP_FMABA01_e, dRes_ID_ALANM_BTK_FMABA01_e},
     {dRes_ID_ALANM_BTP_FMABA02_e, dRes_ID_ALANM_BTK_FMABA02_e},
     {dRes_ID_ALANM_BTP_FMABA03_e, dRes_ID_ALANM_BTK_FMABA03_e},
@@ -1012,7 +1026,7 @@ daAlink_FaceTexData const daAlink_c::m_faceTexDataTable[] = {
     {dRes_ID_ALANM_BTP_WL_FC_e, dRes_ID_ALANM_BTK_WL_FA_e},
 };
 
-const daAlink_procInitTable daAlink_c::m_procInitTable[] = {
+DUSK_GAME_DATA const daAlink_procInitTable daAlink_c::m_procInitTable[] = {
     { &daAlink_c::procPreActionUnequip, 0x21 },
     { &daAlink_c::procServiceWait, 0x10000085 },
     { &daAlink_c::procTiredWait, 0x10001185 },
@@ -1367,7 +1381,7 @@ const daAlink_procInitTable daAlink_c::m_procInitTable[] = {
     { &daAlink_c::procDemoCommon, 0x1 },
 };
 
-daAlink_procFunc daAlink_c::m_demoInitTable[] = {
+DUSK_GAME_DATA daAlink_procFunc daAlink_c::m_demoInitTable[] = {
     NULL,
     NULL,
     NULL,
@@ -2003,9 +2017,9 @@ daAlinkHIO_cut_c::~daAlinkHIO_cut_c() {}
 
 daAlinkHIO_c::~daAlinkHIO_c() {}
 
-bool daAlink_matAnm_c::m_eye_move_flg;
+DUSK_GAME_DATA bool daAlink_matAnm_c::m_eye_move_flg;
 
-u8 daAlink_matAnm_c::m_morf_frame;
+DUSK_GAME_DATA u8 daAlink_matAnm_c::m_morf_frame;
 
 void daAlink_matAnm_c::init() {
     field_0xf4 = 0.0f;
@@ -4313,7 +4327,9 @@ int daAlink_c::createHeap() {
         return 0;
     }
 
-    JKRReadIdxResource(mFaceBckHeap.getBuffer(), 0xC00, dRes_ID_ALANM_BCK_FAT_e, dComIfGp_getAnmArchive());
+    IF_DUSK(mFaceBckHeap.reserveBuffer(dRes_ID_ALANM_BCK_FAT_e);)
+    JKRReadIdxResource(mFaceBckHeap.getBuffer(), DUSK_IF_ELSE(mFaceBckHeap.getBufferSize(), 0xC00),
+                       dRes_ID_ALANM_BCK_FAT_e, dComIfGp_getAnmArchive());
     J3DAnmTransform* bck = (J3DAnmTransform*)J3DAnmLoaderDataBase::load(mFaceBckHeap.getBuffer());
     if (!mFaceBck.init(bck, FALSE, J3DFrameCtrl::EMode_LOOP, 1.0f, 0, -1, false)) {
         return 0;
@@ -5991,7 +6007,7 @@ void daAlink_c::setItemMatrix(int param_0) {
 
         mDoMtx_stack_c::XrotS(-0x8000);
 #ifdef TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
+        if (dusk::interp::is_enabled()) {
             Mtx boot_mtx;
             mDoMtx_concat(mpLinkModel->getAnmMtx(0x18), mDoMtx_stack_c::get(), boot_mtx);
             mpLinkBootModels[1]->setAnmMtx(1, boot_mtx);
@@ -14307,7 +14323,11 @@ BOOL daAlink_c::checkMagicArmorWearAbility() const {
 
 J3DModelData* daAlink_c::loadAramBmd(u16 i_resIdx, u32 i_bufSize) {
     JKRArchive* anmArchive = dComIfGp_getAnmArchive();
+#if TARGET_PC
+    u8* tmpBuffer = (u8*)mItemHeap[field_0x2fa0].allocTempBuffer(i_resIdx, &i_bufSize);
+#else
     u8* tmpBuffer = JKR_NEW_ARRAY_ARGS(u8, i_bufSize, 0x20);
+#endif
 
     JKRReadIdxResource(tmpBuffer, i_bufSize, i_resIdx, anmArchive);
     #if DEBUG
@@ -14328,7 +14348,11 @@ J3DModelData* daAlink_c::loadAramBmd(u16 i_resIdx, u32 i_bufSize) {
 }
 
 void* daAlink_c::loadAram(u16 i_resIdx, u32 i_bufSize) {
+#if TARGET_PC
+    u8* tmpBuffer = (u8*)mItemHeap[field_0x2fa0].allocTempBuffer(i_resIdx, &i_bufSize);
+#else
     u8* tmpBuffer = JKR_NEW_ARRAY_ARGS(u8, i_bufSize, 0x20);
+#endif
     JKRReadIdxResource(tmpBuffer, i_bufSize, i_resIdx, dComIfGp_getAnmArchive());
     #if DEBUG
     daPy_aramBufferCheck(tmpBuffer, i_bufSize);
@@ -14806,10 +14830,13 @@ void daAlink_c::deleteEquipItem(BOOL i_isPlaySound, BOOL i_isDeleteKantera) {
     mIronBallChainAngle = NULL;
     field_0x3848 = NULL;
 #if TARGET_PC
-    mIBChainInterpPrevValid = false;
-    mIBChainInterpCurrValid = false;
-    mHsChainInterpPrevValid = false;
-    mHsChainInterpCurrValid = false;
+    {
+        auto& interp = dusk::interp::get<AlinkInterp>(this);
+        interp.ib_pos.reset();
+        interp.ib_angle.reset();
+        interp.ib_hand.reset();
+        interp.hs_chain.reset();
+    }
 #endif
     field_0x0774 = NULL;
     field_0x0778 = NULL;
@@ -19782,36 +19809,21 @@ int daAlink_c::draw() {
                 dComIfGd_getOpaListDark()->entryImm(mpHookChain, 0);
 
 #if TARGET_PC
-                if (dusk::frame_interp::is_enabled()) {
+                if (dusk::interp::is_enabled()) {
+                    auto& interp = dusk::interp::get<AlinkInterp>(this);
                     if (mEquipItem == dItemNo_IRONBALL_e &&
                         mIronBallChainPos != NULL && mIronBallChainAngle != NULL)
                     {
-                        if (mIBChainInterpCurrValid) {
-                            memcpy(mIBChainInterpPrevPos, mIBChainInterpCurrPos, IRON_BALL_CHAIN_COUNT * sizeof(cXyz));
-                            memcpy(mIBChainInterpPrevAngle, mIBChainInterpCurrAngle, IRON_BALL_CHAIN_COUNT * sizeof(csXyz));
-                            mIBChainInterpPrevHandRoot = mIBChainInterpCurrHandRoot;
-                            mIBChainInterpPrevValid = true;
-                        }
-
-                        memcpy(mIBChainInterpCurrPos, mIronBallChainPos, IRON_BALL_CHAIN_COUNT * sizeof(cXyz));
-                        memcpy(mIBChainInterpCurrAngle, mIronBallChainAngle, IRON_BALL_CHAIN_COUNT * sizeof(csXyz));
-                        mIBChainInterpCurrHandRoot = mHookshotTopPos;
-                        mIBChainInterpCurrValid = true;
-
-                        dusk::frame_interp::add_interpolation_callback(&ironBallChainInterpCallback, this);
+                        interp.ib_pos.writeback(mIronBallChainPos, IRON_BALL_CHAIN_COUNT);
+                        interp.ib_angle.writeback(mIronBallChainAngle, IRON_BALL_CHAIN_COUNT);
+                        interp.ib_hand.writeback(&mHookshotTopPos, 1);
                     } else {
-                        if (mHsChainInterpCurrValid) {
-                            mHsChainInterpPrevTop = mHsChainInterpCurrTop;
-                            mHsChainInterpPrevRoot = mHsChainInterpCurrRoot;
-                            mHsChainInterpPrevSubRoot = mHsChainInterpCurrSubRoot;
-                            mHsChainInterpPrevSubTop = mHsChainInterpCurrSubTop;
-                            mHsChainInterpPrevValid = true;
-                        }
-                        mHsChainInterpCurrTop = mHookshotTopPos;
-                        mHsChainInterpCurrRoot = mHeldItemRootPos;
-                        mHsChainInterpCurrSubRoot = field_0x3810;
-                        mHsChainInterpCurrSubTop = mIronBallBgChkPos;
-                        mHsChainInterpCurrValid = true;
+                        cXyz hsAnchors[HS_CHAIN_ANCHOR_COUNT];
+                        hsAnchors[0] = mHookshotTopPos;
+                        hsAnchors[1] = mHeldItemRootPos;
+                        hsAnchors[2] = field_0x3810;
+                        hsAnchors[3] = mIronBallBgChkPos;
+                        interp.hs_chain.capture_and_schedule(hsAnchors, HS_CHAIN_ANCHOR_COUNT);
                     }
                 }
 #endif
diff --git a/src/d/actor/d_a_alink_HIO_data.inc b/src/d/actor/d_a_alink_HIO_data.inc
index feb49c6d3d..86b9519657 100644
--- a/src/d/actor/d_a_alink_HIO_data.inc
+++ b/src/d/actor/d_a_alink_HIO_data.inc
@@ -1,7 +1,7 @@
 #include "d/actor/d_a_alink.h"
 
 // clang-format off
-const daAlinkHIO_basic_c1 daAlinkHIO_basic_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_basic_c1 daAlinkHIO_basic_c0::m = {
     false,
 	20000,
 	-10000,
@@ -30,7 +30,7 @@ const daAlinkHIO_basic_c1 daAlinkHIO_basic_c0::m = {
 	5000.0f,
 };
 
-const daAlinkHIO_move_c1 daAlinkHIO_move_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_move_c1 daAlinkHIO_move_c0::m = {
 	{
         11,
 	    0.7f,
@@ -58,7 +58,7 @@ const daAlinkHIO_move_c1 daAlinkHIO_move_c0::m = {
     0.4f,
 };
 
-const daAlinkHIO_atnMove_c1 daAlinkHIO_atnMove_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_atnMove_c1 daAlinkHIO_atnMove_c0::m = {
     3000,
 	2000,
 	6,
@@ -83,7 +83,7 @@ const daAlinkHIO_atnMove_c1 daAlinkHIO_atnMove_c0::m = {
 	1.3f,
 };
 
-const daAlinkHIO_noActAtnMove_c1 daAlinkHIO_noActAtnMove_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_noActAtnMove_c1 daAlinkHIO_noActAtnMove_c0::m = {
     3000,
 	2000,
 	6,
@@ -108,7 +108,7 @@ const daAlinkHIO_noActAtnMove_c1 daAlinkHIO_noActAtnMove_c0::m = {
 	2.3f,
 };
 
-const daAlinkHIO_frontRoll_c1 daAlinkHIO_frontRoll_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_frontRoll_c1 daAlinkHIO_frontRoll_c0::m = {
 	{
         29,
 	    1.1f,
@@ -147,7 +147,7 @@ const daAlinkHIO_frontRoll_c1 daAlinkHIO_frontRoll_c0::m = {
     60.0f,
 };
 
-const daAlinkHIO_backJump_c1 daAlinkHIO_backJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_backJump_c1 daAlinkHIO_backJump_c0::m = {
 	{
 		9,
 	    0.7f,
@@ -168,7 +168,7 @@ const daAlinkHIO_backJump_c1 daAlinkHIO_backJump_c0::m = {
 	10.0f,
 };
 
-const daAlinkHIO_sideStep_c1 daAlinkHIO_sideStep_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_sideStep_c1 daAlinkHIO_sideStep_c0::m = {
 	{
 		5,
         1.1f,
@@ -205,7 +205,7 @@ const daAlinkHIO_sideStep_c1 daAlinkHIO_sideStep_c0::m = {
     10.0f,
 };
 
-const daAlinkHIO_slide_c1 daAlinkHIO_slide_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_slide_c1 daAlinkHIO_slide_c0::m = {
 	{
 		14,
         0.75f,
@@ -248,7 +248,7 @@ const daAlinkHIO_slide_c1 daAlinkHIO_slide_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmV_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmV_c0::m = {
 	{
 		27,
         1.2f,
@@ -264,7 +264,7 @@ const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmV_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmL_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmL_c0::m = {
 	{
 		27,
         1.2f,
@@ -280,7 +280,7 @@ const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmL_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmR_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmR_c0::m = {
 	{
 		27,
         1.2f,
@@ -296,7 +296,7 @@ const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmR_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSL_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSL_c0::m = {
 	{
 		31,
         1.1f,
@@ -312,7 +312,7 @@ const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSL_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSR_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSR_c0::m = {
 	{
 		27,
         1.1f,
@@ -328,7 +328,7 @@ const daAlinkHIO_cutNormal_c1 daAlinkHIO_cutNmSR_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnL_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnL_c0::m = {
 	{
 		29,
         1.0f,
@@ -348,7 +348,7 @@ const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnL_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnV_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnV_c0::m = {
 	{
 		33,
         1.0f,
@@ -368,7 +368,7 @@ const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnV_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnS_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnS_c0::m = {
 	{
 		31,
         1.1f,
@@ -388,7 +388,7 @@ const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnS_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSl_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSl_c0::m = {
 	{
 		33,
         0.9f,
@@ -408,7 +408,7 @@ const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSl_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSm_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSm_c0::m = {
 	{
 		31,
         0.9f,
@@ -427,7 +427,7 @@ const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnSm_c0::m = {
 #pragma pop
 
 #pragma push
-const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnR_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnR_c0::m = {
 	{
 		34,
         1.1f,
@@ -445,7 +445,7 @@ const daAlinkHIO_cutFinish_c1 daAlinkHIO_cutFnR_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_cutFnJU_c1 daAlinkHIO_cutFnJU_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutFnJU_c1 daAlinkHIO_cutFnJU_c0::m = {
 	{
 		19,
         1.0f,
@@ -474,7 +474,7 @@ const daAlinkHIO_cutFnJU_c1 daAlinkHIO_cutFnJU_c0::m = {
     80.0f,
 };
 
-const daAlinkHIO_cutJump_c1 daAlinkHIO_cutJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutJump_c1 daAlinkHIO_cutJump_c0::m = {
 	{
 		17,
         1.1f,
@@ -498,7 +498,7 @@ const daAlinkHIO_cutJump_c1 daAlinkHIO_cutJump_c0::m = {
     3.0f,
 };
 
-const daAlinkHIO_cutTurn_c1 daAlinkHIO_cutTurn_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutTurn_c1 daAlinkHIO_cutTurn_c0::m = {
 	{
 		47,
         1.0f,
@@ -548,7 +548,7 @@ const daAlinkHIO_cutTurn_c1 daAlinkHIO_cutTurn_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLA_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLA_c0::m = {
 	{
 		21,
         0.9f,
@@ -564,7 +564,7 @@ const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLA_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLB_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLB_c0::m = {
 	{
 		24,
         0.9f,
@@ -580,7 +580,7 @@ const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutLB_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRA_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRA_c0::m = {
 	{
 		24,
         0.95f,
@@ -596,7 +596,7 @@ const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRA_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRB_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRB_c0::m = {
 	{
 		11,
         0.9f,
@@ -610,7 +610,7 @@ const daAlinkHIO_hoCut_c1 daAlinkHIO_hoCutRB_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_hoCutCharge_c1 daAlinkHIO_hoCutCharge_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_hoCutCharge_c1 daAlinkHIO_hoCutCharge_c0::m = {
 	{
 		6,
         0.45f,
@@ -643,7 +643,7 @@ const daAlinkHIO_hoCutCharge_c1 daAlinkHIO_hoCutCharge_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaL_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaL_c0::m = {
 	{
 		12,
         0.8f,
@@ -658,7 +658,7 @@ const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaL_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaR_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaR_c0::m = {
 	{
 		14,
         1.0f,
@@ -673,7 +673,7 @@ const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaR_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaCharge_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaCharge_c0::m = {
 	{
 		14,
         1.0f,
@@ -686,7 +686,7 @@ const daAlinkHIO_cutDash_c1 daAlinkHIO_cutDaCharge_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_cutDown_c1 daAlinkHIO_cutDown_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutDown_c1 daAlinkHIO_cutDown_c0::m = {
 	{
 		8,
         1.0f,
@@ -729,7 +729,7 @@ const daAlinkHIO_cutDown_c1 daAlinkHIO_cutDown_c0::m = {
     10.0f,
 };
 
-const daAlinkHIO_cutHead_c1 daAlinkHIO_cutHead_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutHead_c1 daAlinkHIO_cutHead_c0::m = {
 	{
 		8,
         0.9f,
@@ -762,7 +762,7 @@ const daAlinkHIO_cutHead_c1 daAlinkHIO_cutHead_c0::m = {
     1.6f,
 };
 
-const daAlinkHIO_cutLargeJump_c1 daAlinkHIO_cutLargeJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cutLargeJump_c1 daAlinkHIO_cutLargeJump_c0::m = {
 	{
 		29,
         1.3f,
@@ -802,7 +802,7 @@ const daAlinkHIO_cutLargeJump_c1 daAlinkHIO_cutLargeJump_c0::m = {
     5.0f,
 };
 
-const daAlinkHIO_cut_c1 daAlinkHIO_cut_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_cut_c1 daAlinkHIO_cut_c0::m = {
 	{
 		18,
         -1.100f,
@@ -857,7 +857,7 @@ const daAlinkHIO_cut_c1 daAlinkHIO_cut_c0::m = {
     0.0f,
 };
 
-const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtPush_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtPush_c0::m = {
 	{
 		14,
         1.0f,
@@ -873,7 +873,7 @@ const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtPush_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtKick_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtKick_c0::m = {
 	{
 		21,
         1.2f,
@@ -888,7 +888,7 @@ const daAlinkHIO_guardAttack_c1 daAlinkHIO_gAtKick_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_turnMove_c1 daAlinkHIO_turnMove_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_turnMove_c1 daAlinkHIO_turnMove_c0::m = {
 	{
 		27,
         1.0f,
@@ -906,7 +906,7 @@ const daAlinkHIO_turnMove_c1 daAlinkHIO_turnMove_c0::m = {
 	25.0f,
 };
 
-const daAlinkHIO_guard_c1 daAlinkHIO_guard_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_guard_c1 daAlinkHIO_guard_c0::m = {
 	{
 		11,
         1.0f,
@@ -951,7 +951,7 @@ const daAlinkHIO_guard_c1 daAlinkHIO_guard_c0::m = {
     18.0f,
 };
 
-const daAlinkHIO_crouch_c1 daAlinkHIO_crouch_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_crouch_c1 daAlinkHIO_crouch_c0::m = {
 	{
 		9,
         1.0f,
@@ -978,7 +978,7 @@ const daAlinkHIO_crouch_c1 daAlinkHIO_crouch_c0::m = {
     5.0f,
 };
 
-const daAlinkHIO_autoJump_c1 daAlinkHIO_autoJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_autoJump_c1 daAlinkHIO_autoJump_c0::m = {
 	{
 		6,
         1.2f,
@@ -1036,7 +1036,7 @@ const daAlinkHIO_autoJump_c1 daAlinkHIO_autoJump_c0::m = {
     23.0f,
 };
 
-const daAlinkHIO_smallJump_c1 daAlinkHIO_smallJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_smallJump_c1 daAlinkHIO_smallJump_c0::m = {
 	{
 		8,
         0.6f,
@@ -1063,7 +1063,7 @@ const daAlinkHIO_smallJump_c1 daAlinkHIO_smallJump_c0::m = {
     7.0f,
 };
 
-const daAlinkHIO_wallCatch_c1 daAlinkHIO_wallCatch_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wallCatch_c1 daAlinkHIO_wallCatch_c0::m = {
 	{
 		19,
         1.0f,
@@ -1095,7 +1095,7 @@ const daAlinkHIO_wallCatch_c1 daAlinkHIO_wallCatch_c0::m = {
     4.0f,
 };
 
-const daAlinkHIO_wallFall_c1 daAlinkHIO_wallFall_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wallFall_c1 daAlinkHIO_wallFall_c0::m = {
 	{
 		22,
         0.8f,
@@ -1112,7 +1112,7 @@ const daAlinkHIO_wallFall_c1 daAlinkHIO_wallFall_c0::m = {
 	},
 };
 
-const daAlinkHIO_wallMove_c1 daAlinkHIO_wallMove_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wallMove_c1 daAlinkHIO_wallMove_c0::m = {
     0.8f,
 	1.1f,
 	3.0f,
@@ -1120,7 +1120,7 @@ const daAlinkHIO_wallMove_c1 daAlinkHIO_wallMove_c0::m = {
 	3.0f,
 };
 
-const daAlinkHIO_wallHang_c1 daAlinkHIO_wallHang_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wallHang_c1 daAlinkHIO_wallHang_c0::m = {
     2,
 	3,
 	50.0f,
@@ -1131,7 +1131,7 @@ const daAlinkHIO_wallHang_c1 daAlinkHIO_wallHang_c0::m = {
 	200.0f,
 };
 
-const daAlinkHIO_pushpull_c1 daAlinkHIO_pushpull_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_pushpull_c1 daAlinkHIO_pushpull_c0::m = {
     0,
 	120,
 	7,
@@ -1153,7 +1153,7 @@ const daAlinkHIO_pushpull_c1 daAlinkHIO_pushpull_c0::m = {
 	0.75f,
 };
 
-const daAlinkHIO_damNormal_c1 daAlinkHIO_damNormal_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damNormal_c1 daAlinkHIO_damNormal_c0::m = {
 	{
 		22,
         2.3f,
@@ -1190,7 +1190,7 @@ const daAlinkHIO_damNormal_c1 daAlinkHIO_damNormal_c0::m = {
     0.5f,
 };
 
-const daAlinkHIO_damLaHu_c1 daAlinkHIO_damLarge_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damLaHu_c1 daAlinkHIO_damLarge_c0::m = {
 	{
 		49,
         0.8f,
@@ -1256,7 +1256,7 @@ const daAlinkHIO_damLaHu_c1 daAlinkHIO_damLarge_c0::m = {
     0.5f,
 };
 
-const daAlinkHIO_damLaHu_c1 daAlinkHIO_damHuge_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damLaHu_c1 daAlinkHIO_damHuge_c0::m = {
 	{
 		49,
         0.8f,
@@ -1322,7 +1322,7 @@ const daAlinkHIO_damLaHu_c1 daAlinkHIO_damHuge_c0::m = {
     0.5f,
 };
 
-const daAlinkHIO_damHorse_c1 daAlinkHIO_damHorse_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damHorse_c1 daAlinkHIO_damHorse_c0::m = {
 	{
 		9,
         2.0f,
@@ -1341,7 +1341,7 @@ const daAlinkHIO_damHorse_c1 daAlinkHIO_damHorse_c0::m = {
     5000,
 };
 
-const daAlinkHIO_damFall_c1 daAlinkHIO_damFall_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damFall_c1 daAlinkHIO_damFall_c0::m = {
 	{
 		11,
         1.2f,
@@ -1367,7 +1367,7 @@ const daAlinkHIO_damFall_c1 daAlinkHIO_damFall_c0::m = {
     15.0f,
 };
 
-const daAlinkHIO_damCaught_c1 daAlinkHIO_damCaught_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damCaught_c1 daAlinkHIO_damCaught_c0::m = {
 	{
 		59,
         1.5f,
@@ -1382,7 +1382,7 @@ const daAlinkHIO_damCaught_c1 daAlinkHIO_damCaught_c0::m = {
 	1.3f,
 };
 
-const daAlinkHIO_damSwim_c1 daAlinkHIO_damSwim_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damSwim_c1 daAlinkHIO_damSwim_c0::m = {
 	{
 		22,
         1.2f,
@@ -1433,7 +1433,7 @@ const daAlinkHIO_damSwim_c1 daAlinkHIO_damSwim_c0::m = {
     15.0f,
 };
 
-const daAlinkHIO_damage_c1 daAlinkHIO_damage_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_damage_c1 daAlinkHIO_damage_c0::m = {
 	{
 		14,
         1.0f,
@@ -1471,7 +1471,7 @@ const daAlinkHIO_damage_c1 daAlinkHIO_damage_c0::m = {
     35.0f,
 };
 
-const daAlinkHIO_horse_c1 daAlinkHIO_horse_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_horse_c1 daAlinkHIO_horse_c0::m = {
 	{
 		18,
         1.2f,
@@ -1512,7 +1512,7 @@ const daAlinkHIO_horse_c1 daAlinkHIO_horse_c0::m = {
     5.0f,
 };
 
-const daAlinkHIO_canoe_c1 daAlinkHIO_canoe_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_canoe_c1 daAlinkHIO_canoe_c0::m = {
 	{
 		23,
         1.3f,
@@ -1536,7 +1536,7 @@ const daAlinkHIO_canoe_c1 daAlinkHIO_canoe_c0::m = {
     0.2f,
 };
 
-const daAlinkHIO_bow_c1 daAlinkHIO_bow_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_bow_c1 daAlinkHIO_bow_c0::m = {
 	{
 		9,
         1.0f,
@@ -1572,7 +1572,7 @@ const daAlinkHIO_bow_c1 daAlinkHIO_bow_c0::m = {
     800.0f,
 };
 
-const daAlinkHIO_boom_c1 daAlinkHIO_boom_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_boom_c1 daAlinkHIO_boom_c0::m = {
 	{
 		21,
         0.9f,
@@ -1599,7 +1599,7 @@ const daAlinkHIO_boom_c1 daAlinkHIO_boom_c0::m = {
     40.0f,
 };
 
-const daAlinkHIO_bomb_c1 daAlinkHIO_bomb_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_bomb_c1 daAlinkHIO_bomb_c0::m = {
     160,
 	50,
 	50,
@@ -1624,7 +1624,7 @@ const daAlinkHIO_bomb_c1 daAlinkHIO_bomb_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_huLight_c1 daAlinkHIO_huLight_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_huLight_c1 daAlinkHIO_huLight_c0::m = {
     0,
     3,
 	0,
@@ -1639,7 +1639,7 @@ const daAlinkHIO_huLight_c1 daAlinkHIO_huLight_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_kandelaar_c1 daAlinkHIO_kandelaar_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_kandelaar_c1 daAlinkHIO_kandelaar_c0::m = {
 	{
 		30,
         1.1f,
@@ -1672,7 +1672,7 @@ const daAlinkHIO_kandelaar_c1 daAlinkHIO_kandelaar_c0::m = {
     0.5f,
 };
 
-const daAlinkHIO_fmChain_c1 daAlinkHIO_fmChain_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_fmChain_c1 daAlinkHIO_fmChain_c0::m = {
 	{
 		20,
         1.2f,
@@ -1689,7 +1689,7 @@ const daAlinkHIO_fmChain_c1 daAlinkHIO_fmChain_c0::m = {
 	},
 };
 
-const daAlinkHIO_magneBoots_c1 daAlinkHIO_magneBoots_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_magneBoots_c1 daAlinkHIO_magneBoots_c0::m = {
 	{
 		29,
         1.1f,
@@ -1713,7 +1713,7 @@ const daAlinkHIO_magneBoots_c1 daAlinkHIO_magneBoots_c0::m = {
     0.7f,
 };
 
-const daAlinkHIO_pickUp_c1 daAlinkHIO_pickUp_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_pickUp_c1 daAlinkHIO_pickUp_c0::m = {
 	{
 		18,
         0.9f,
@@ -1732,7 +1732,7 @@ const daAlinkHIO_pickUp_c1 daAlinkHIO_pickUp_c0::m = {
     30.0f,
 };
 
-const daAlinkHIO_board_c1 daAlinkHIO_board_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_board_c1 daAlinkHIO_board_c0::m = {
 	{
 		9,
         2.5f,
@@ -1782,7 +1782,7 @@ const daAlinkHIO_board_c1 daAlinkHIO_board_c0::m = {
     50.0f,
 };
 
-const daAlinkHIO_bottle_c1 daAlinkHIO_bottle_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_bottle_c1 daAlinkHIO_bottle_c0::m = {
 	{
 		56,
         1.15f,
@@ -1848,7 +1848,7 @@ const daAlinkHIO_bottle_c1 daAlinkHIO_bottle_c0::m = {
 	},
 };
 
-const daAlinkHIO_hookshot_c1 daAlinkHIO_hookshot_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_hookshot_c1 daAlinkHIO_hookshot_c0::m = {
 	{
 		12,
         1.0f,
@@ -1885,7 +1885,7 @@ const daAlinkHIO_hookshot_c1 daAlinkHIO_hookshot_c0::m = {
     90.0f,
 };
 
-const daAlinkHIO_spinner_c1 daAlinkHIO_spinner_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_spinner_c1 daAlinkHIO_spinner_c0::m = {
 	{
 		21,
         0.8f,
@@ -1908,7 +1908,7 @@ const daAlinkHIO_spinner_c1 daAlinkHIO_spinner_c0::m = {
     60.0f,
 };
 
-const daAlinkHIO_ironBall_c1 daAlinkHIO_ironBall_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_ironBall_c1 daAlinkHIO_ironBall_c0::m = {
 	{
 		19,
         1.1f,
@@ -1949,7 +1949,7 @@ const daAlinkHIO_ironBall_c1 daAlinkHIO_ironBall_c0::m = {
     0.5f,
 };
 
-const daAlinkHIO_copyRod_c1 daAlinkHIO_copyRod_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_copyRod_c1 daAlinkHIO_copyRod_c0::m = {
     19,
 	1.0f,
 	0.0f,
@@ -1966,7 +1966,7 @@ const daAlinkHIO_copyRod_c1 daAlinkHIO_copyRod_c0::m = {
 	2000.0f,
 };
 
-const daAlinkHIO_zwLight_c1 daAlinkHIO_zwLight_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_zwLight_c1 daAlinkHIO_zwLight_c0::m = {
     771,
 	0,
 	182,
@@ -1979,7 +1979,7 @@ const daAlinkHIO_zwLight_c1 daAlinkHIO_zwLight_c0::m = {
 	0.0f,
 };
 
-const daAlinkHIO_item_c1 daAlinkHIO_item_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_item_c1 daAlinkHIO_item_c0::m = {
 	{
 		12,
         1.0f,
@@ -2003,7 +2003,7 @@ const daAlinkHIO_item_c1 daAlinkHIO_item_c0::m = {
     1.3f,
 };
 
-const daAlinkHIO_ladder_c1 daAlinkHIO_ladder_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_ladder_c1 daAlinkHIO_ladder_c0::m = {
 	{
 		13,
         0.8f,
@@ -2038,7 +2038,7 @@ const daAlinkHIO_ladder_c1 daAlinkHIO_ladder_c0::m = {
     80.0f,
 };
 
-const daAlinkHIO_roofHang_c1 daAlinkHIO_roofHang_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_roofHang_c1 daAlinkHIO_roofHang_c0::m = {
 	{
 		34,
         1.0f,
@@ -2063,7 +2063,7 @@ const daAlinkHIO_roofHang_c1 daAlinkHIO_roofHang_c0::m = {
     3.0f,
 };
 
-const daAlinkHIO_grab_c1 daAlinkHIO_grab_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_grab_c1 daAlinkHIO_grab_c0::m = {
 	{
 		4,
         0.9f,
@@ -2146,7 +2146,7 @@ const daAlinkHIO_grab_c1 daAlinkHIO_grab_c0::m = {
     0.55f,
 };
 
-const daAlinkHIO_swim_c1 daAlinkHIO_swim_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_swim_c1 daAlinkHIO_swim_c0::m = {
 	{
 		25,
         1.0f,
@@ -2224,7 +2224,7 @@ const daAlinkHIO_swim_c1 daAlinkHIO_swim_c0::m = {
     1.3f,
 };
 
-const daAlinkHIO_wlMove_c1 daAlinkHIO_wlMove_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlMove_c1 daAlinkHIO_wlMove_c0::m = {
 	{
 		14,
         1.0f,
@@ -2303,7 +2303,7 @@ const daAlinkHIO_wlMove_c1 daAlinkHIO_wlMove_c0::m = {
     0.5f,
 };
 
-const daAlinkHIO_wlMoveNoP_c1 daAlinkHIO_wlMoveNoP_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlMoveNoP_c1 daAlinkHIO_wlMoveNoP_c0::m = {
     9000,
 	100,
 	5,
@@ -2325,7 +2325,7 @@ const daAlinkHIO_wlMoveNoP_c1 daAlinkHIO_wlMoveNoP_c0::m = {
 	30.0f,
 };
 
-const daAlinkHIO_wlAtnMove_c1 daAlinkHIO_wlAtnMove_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtnMove_c1 daAlinkHIO_wlAtnMove_c0::m = {
     9000,
 	100,
 	3,
@@ -2343,7 +2343,7 @@ const daAlinkHIO_wlAtnMove_c1 daAlinkHIO_wlAtnMove_c0::m = {
 	2.0f,
 };
 
-const daAlinkHIO_wlSideStep_c1 daAlinkHIO_wlSideStep_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlSideStep_c1 daAlinkHIO_wlSideStep_c0::m = {
 	{
 		5,
         1.0f,
@@ -2380,7 +2380,7 @@ const daAlinkHIO_wlSideStep_c1 daAlinkHIO_wlSideStep_c0::m = {
     10.0f,
 };
 
-const daAlinkHIO_wlBackJump_c1 daAlinkHIO_wlBackJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlBackJump_c1 daAlinkHIO_wlBackJump_c0::m = {
 	{
 		11,
         0.8f,
@@ -2401,7 +2401,7 @@ const daAlinkHIO_wlBackJump_c1 daAlinkHIO_wlBackJump_c0::m = {
 	10.0f,
 };
 
-const daAlinkHIO_wlHowl_c1 daAlinkHIO_wlHowl_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlHowl_c1 daAlinkHIO_wlHowl_c0::m = {
 	{
 		49,
         1.0f,
@@ -2436,7 +2436,7 @@ const daAlinkHIO_wlHowl_c1 daAlinkHIO_wlHowl_c0::m = {
     0.7f,
 };
 
-const daAlinkHIO_wlAutoJump_c1 daAlinkHIO_wlAutoJump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAutoJump_c1 daAlinkHIO_wlAutoJump_c0::m = {
 	{
 		3,
         1.2f,
@@ -2478,7 +2478,7 @@ const daAlinkHIO_wlAutoJump_c1 daAlinkHIO_wlAutoJump_c0::m = {
     100.0f,
 };
 
-const daAlinkHIO_wlPush_c1 daAlinkHIO_wlPush_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlPush_c1 daAlinkHIO_wlPush_c0::m = {
     1.0f,
 	3.0f,
 	1.0f,
@@ -2486,7 +2486,7 @@ const daAlinkHIO_wlPush_c1 daAlinkHIO_wlPush_c0::m = {
 	0.75f,
 };
 
-const daAlinkHIO_wlLie_c1 daAlinkHIO_wlLie_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlLie_c1 daAlinkHIO_wlLie_c0::m = {
 	{
 		14,
         1.5f,
@@ -2515,7 +2515,7 @@ const daAlinkHIO_wlLie_c1 daAlinkHIO_wlLie_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_wlLight_c1 daAlinkHIO_wlLight_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlLight_c1 daAlinkHIO_wlLight_c0::m = {
     515,
 	0,
 	120,
@@ -2529,7 +2529,7 @@ const daAlinkHIO_wlLight_c1 daAlinkHIO_wlLight_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_wlWallHang_c1 daAlinkHIO_wlWallHang_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlWallHang_c1 daAlinkHIO_wlWallHang_c0::m = {
 	{
 		13,
         1.2f,
@@ -2583,7 +2583,7 @@ const daAlinkHIO_wlWallHang_c1 daAlinkHIO_wlWallHang_c0::m = {
     10.0f,
 };
 
-const daAlinkHIO_wlDamNormal_c1 daAlinkHIO_wlDamNormal_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlDamNormal_c1 daAlinkHIO_wlDamNormal_c0::m = {
 	{
 		9,
         1.0f,
@@ -2618,7 +2618,7 @@ const daAlinkHIO_wlDamNormal_c1 daAlinkHIO_wlDamNormal_c0::m = {
     0.25f,
 };
 
-const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamLarge_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamLarge_c0::m = {
 	{
 		49,
         1.0f,
@@ -2658,7 +2658,7 @@ const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamLarge_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamHuge_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamHuge_c0::m = {
 	{
 		49,
         1.1f,
@@ -2697,7 +2697,7 @@ const daAlinkHIO_wlDamLaHu_c1 daAlinkHIO_wlDamHuge_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_wlDamFall_c1 daAlinkHIO_wlDamFall_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlDamFall_c1 daAlinkHIO_wlDamFall_c0::m = {
 	{
 		11,
         1.0f,
@@ -2721,7 +2721,7 @@ const daAlinkHIO_wlDamFall_c1 daAlinkHIO_wlDamFall_c0::m = {
     15.0f,
 };
 
-const daAlinkHIO_wlDamCaught_c1 daAlinkHIO_wlDamCaught_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlDamCaught_c1 daAlinkHIO_wlDamCaught_c0::m = {
     300,
 	5,
 	1.2f,
@@ -2729,7 +2729,7 @@ const daAlinkHIO_wlDamCaught_c1 daAlinkHIO_wlDamCaught_c0::m = {
 	1.5f,
 };
 
-const daAlinkHIO_wlDamage_c1 daAlinkHIO_wlDamage_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlDamage_c1 daAlinkHIO_wlDamage_c0::m = {
 	{
 		9,
         1.1f,
@@ -2747,7 +2747,7 @@ const daAlinkHIO_wlDamage_c1 daAlinkHIO_wlDamage_c0::m = {
     0.7f,
 };
 
-const daAlinkHIO_wlSlide_c1 daAlinkHIO_wlSlide_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlSlide_c1 daAlinkHIO_wlSlide_c0::m = {
 	{
 		20,
         1.25f,
@@ -2790,7 +2790,7 @@ const daAlinkHIO_wlSlide_c1 daAlinkHIO_wlSlide_c0::m = {
     30.0f,
 };
 
-const daAlinkHIO_wlRope_c1 daAlinkHIO_wlRope_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlRope_c1 daAlinkHIO_wlRope_c0::m = {
 	{
 		16,
         1.0f,
@@ -2812,7 +2812,7 @@ const daAlinkHIO_wlRope_c1 daAlinkHIO_wlRope_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaLr_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaLr_c0::m = {
 	{
 		41,
         0.9f,
@@ -2836,7 +2836,7 @@ const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaLr_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaSc_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaSc_c0::m = {
 	{
 		15,
         0.9f,
@@ -2860,7 +2860,7 @@ const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaSc_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaTl_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaTl_c0::m = {
 	{
 		42,
         1.05f,
@@ -2882,7 +2882,7 @@ const daAlinkHIO_wlAtWait_c1 daAlinkHIO_wlAtWaTl_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_wlAtRoll_c1 daAlinkHIO_wlAtRoll_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtRoll_c1 daAlinkHIO_wlAtRoll_c0::m = {
 	{
 		40,
         1.0f,
@@ -2895,7 +2895,7 @@ const daAlinkHIO_wlAtRoll_c1 daAlinkHIO_wlAtRoll_c0::m = {
     0.0f,
 };
 
-const daAlinkHIO_wlAtNjump_c1 daAlinkHIO_wlAtNjump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtNjump_c1 daAlinkHIO_wlAtNjump_c0::m = {
 	{
 		6,
         1.0f,
@@ -2915,7 +2915,7 @@ const daAlinkHIO_wlAtNjump_c1 daAlinkHIO_wlAtNjump_c0::m = {
     10.0f,
 };
 
-const daAlinkHIO_wlAtCjump_c1 daAlinkHIO_wlAtCjump_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtCjump_c1 daAlinkHIO_wlAtCjump_c0::m = {
 	{
 		3,
         2.0f,
@@ -2947,7 +2947,7 @@ const daAlinkHIO_wlAtCjump_c1 daAlinkHIO_wlAtCjump_c0::m = {
     0.1f,
 };
 
-const daAlinkHIO_wlAtLand_c1 daAlinkHIO_wlAtLand_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtLand_c1 daAlinkHIO_wlAtLand_c0::m = {
 	{
 		19,
         0.9f,
@@ -2972,7 +2972,7 @@ const daAlinkHIO_wlAtLand_c1 daAlinkHIO_wlAtLand_c0::m = {
     2.0f,
 };
 
-const daAlinkHIO_wlAtDown_c1 daAlinkHIO_wlAtDown_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtDown_c1 daAlinkHIO_wlAtDown_c0::m = {
 	{
 		3,
         1.0f,
@@ -3029,7 +3029,7 @@ const daAlinkHIO_wlAtDown_c1 daAlinkHIO_wlAtDown_c0::m = {
     13.0f,
 };
 
-const daAlinkHIO_wlAtLock_c1 daAlinkHIO_wlAtLock_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtLock_c1 daAlinkHIO_wlAtLock_c0::m = {
 	{
 		6,
         3.0f,
@@ -3057,7 +3057,7 @@ const daAlinkHIO_wlAtLock_c1 daAlinkHIO_wlAtLock_c0::m = {
     1000.0f,
 };
 
-const daAlinkHIO_wlAtBite_c1 daAlinkHIO_wlAtBite_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAtBite_c1 daAlinkHIO_wlAtBite_c0::m = {
 	{
 		5,
         1.0f,
@@ -3088,7 +3088,7 @@ const daAlinkHIO_wlAtBite_c1 daAlinkHIO_wlAtBite_c0::m = {
     0.02f,
 };
 
-const daAlinkHIO_wlAttack_c1 daAlinkHIO_wlAttack_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlAttack_c1 daAlinkHIO_wlAttack_c0::m = {
 	{
 		59,
         1.2f,
@@ -3108,7 +3108,7 @@ const daAlinkHIO_wlAttack_c1 daAlinkHIO_wlAttack_c0::m = {
 	30.0f,
 };
 
-const daAlinkHIO_wlPoint_c1 daAlinkHIO_wlPoint_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlPoint_c1 daAlinkHIO_wlPoint_c0::m = {
 	{
 		6,
         0.9f,
@@ -3150,7 +3150,7 @@ const daAlinkHIO_wlPoint_c1 daAlinkHIO_wlPoint_c0::m = {
     0.2f,
 };
 
-const daAlinkHIO_wlChain_c1 daAlinkHIO_wlChain_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlChain_c1 daAlinkHIO_wlChain_c0::m = {
 	{
 		39,
         1.0f,
@@ -3183,7 +3183,7 @@ const daAlinkHIO_wlChain_c1 daAlinkHIO_wlChain_c0::m = {
     5.0f,
 };
 
-const daAlinkHIO_wlSwim_c1 daAlinkHIO_wlSwim_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlSwim_c1 daAlinkHIO_wlSwim_c0::m = {
 	{
 		25,
         0.9f,
@@ -3237,7 +3237,7 @@ const daAlinkHIO_wlSwim_c1 daAlinkHIO_wlSwim_c0::m = {
     7.0f,
 };
 
-const daAlinkHIO_wlGrab_c1 daAlinkHIO_wlGrab_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlGrab_c1 daAlinkHIO_wlGrab_c0::m = {
 	{
 		20,
         1.5f,
@@ -3277,7 +3277,7 @@ const daAlinkHIO_wlGrab_c1 daAlinkHIO_wlGrab_c0::m = {
 
 #pragma push
 #pragma force_active on
-const daAlinkHIO_wlBall_c1 daAlinkHIO_wlBall_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wlBall_c1 daAlinkHIO_wlBall_c0::m = {
 	{
 		64,
         1.0f,
@@ -3299,7 +3299,7 @@ const daAlinkHIO_wlBall_c1 daAlinkHIO_wlBall_c0::m = {
 };
 #pragma pop
 
-const daAlinkHIO_wolf_c1 daAlinkHIO_wolf_c0::m = {
+DUSK_GAME_DATA const daAlinkHIO_wolf_c1 daAlinkHIO_wolf_c0::m = {
     13000,
 	-10000,
 	8000,
diff --git a/src/d/actor/d_a_alink_bow.inc b/src/d/actor/d_a_alink_bow.inc
index 600dcae2f4..aae80e8b88 100644
--- a/src/d/actor/d_a_alink_bow.inc
+++ b/src/d/actor/d_a_alink_bow.inc
@@ -551,7 +551,7 @@ void daAlink_c::setBowSight() {
         getArrowFlyData(&dist, &speed, TRUE);
         checkSightLine(dist, &sight_pos);
         mSight.setPos(&sight_pos);
-        mSight.offDrawFlg();
+        DUSK_IF_ELSE(dusk::getSettings().game.aimingReticle ? mSight.onDrawFlg() : mSight.offDrawFlg(), mSight.offDrawFlg());
     } else {
         mSight.offDrawFlg();
     }
diff --git a/src/d/actor/d_a_alink_damage.inc b/src/d/actor/d_a_alink_damage.inc
index a57e71bcee..34701229c3 100644
--- a/src/d/actor/d_a_alink_damage.inc
+++ b/src/d/actor/d_a_alink_damage.inc
@@ -157,10 +157,11 @@ f32 daAlink_c::damageMagnification(BOOL i_checkZoraMag, int param_1) {
     }
 
     #if TARGET_PC
-    base_mag *= dusk::getSettings().game.damageMultiplier;
     if (dusk::getSettings().game.instantDeath) {
-        base_mag = 9999.0f;
+        return 9999.0f; // don't need to multiply this further, 9999 is plenty
     }
+
+    base_mag *= dusk::getSettings().game.damageMultiplier;
     #endif
 
     if (checkWolf() && !checkCargoCarry() && param_1 == 0) {
diff --git a/src/d/actor/d_a_alink_demo.inc b/src/d/actor/d_a_alink_demo.inc
index b1eb71a85d..aaa38f544e 100644
--- a/src/d/actor/d_a_alink_demo.inc
+++ b/src/d/actor/d_a_alink_demo.inc
@@ -23,9 +23,13 @@
 #include "d/actor/d_a_npc_tkc.h"
 #include <cstring>
 
+#ifdef TARGET_PC
+#include "dusk/game_mode.hpp"
 #include "dusk/imgui/ImGuiConsole.hpp"
 #include "dusk/settings.h"
 #include "dusk/speedrun.h"
+#include "dusk/version.hpp"
+#endif
 
 BOOL daAlink_c::checkEventRun() const {
     return dComIfGp_event_runCheck() || checkPlayerDemoMode();
@@ -1023,6 +1027,9 @@ void daAlink_c::setGetItemFace(u16 i_itemNo) {
         || i_itemNo == dItemNo_ANCIENT_DOCUMENT2_e
         || i_itemNo == dItemNo_DROP_CONTAINER_e
         || i_itemNo == dItemNo_DROP_CONTAINER02_e
+#if TARGET_PC
+        || i_itemNo == dItemNo_SHADOW_CRYSTAL_e
+#endif
         || i_itemNo == dItemNo_DROP_CONTAINER03_e)
     {
         setFaceBasicBck(dRes_ID_ALANM_BCK_FI_e);
@@ -2005,7 +2012,11 @@ void daAlink_c::setGetSubBgm(int i_itemNo) {
         /* dItemNo_WEAR_KOKIRI_e       */ SETYPE_NONE,
         /* dItemNo_ARMOR_e             */ SETYPE_ITEM_GET,
         /* dItemNo_WEAR_ZORA_e         */ SETYPE_ITEM_GET,
+#if TARGET_PC
+        /* dItemNo_SHADOW_CRYSTAL_e    */ SETYPE_ITEM_GET,
+#else
         /* dItemNo_MAGIC_LV1_e         */ SETYPE_NONE,
+#endif
         /* dItemNo_DUNGEON_EXIT_2_e    */ SETYPE_ITEM_GET_MINI,
         /* dItemNo_WALLET_LV1_e        */ SETYPE_NONE,
         /* dItemNo_WALLET_LV2_e        */ SETYPE_ITEM_GET,
@@ -2259,6 +2270,12 @@ int daAlink_c::procCoGetItemInit() {
     s16 var_r22 = 0;
     BOOL var_r31 = FALSE;
     BOOL var_r30 = FALSE;
+#if TARGET_PC
+    // Queued grants have no event partner, so create the demo item from the event's GtItm.
+    if (dusk::mods::item_give_queue_dispatching()) {
+        mDemo.setParam0(0x100);
+    }
+#endif
     if (mProcID == PROC_GET_ITEM || mProcID == PROC_INSECT_CATCH ||
         (mProcID == PROC_PREACTION_UNEQUIP && !checkNoUpperAnime()))
     {
@@ -2297,8 +2314,13 @@ int daAlink_c::procCoGetItemInit() {
             item_no = dComIfGp_event_getGtItm();
         }
 
+#if TARGET_PC
+        const u32 giveTag = mDemo.getParam0() != 0x100 && mDemo.getParam1() != 0 ?
+                                static_cast<u32>(mDemo.getParam1()) :
+                                dusk::mods::item_give_queue_take_tag();
+#endif
         fpc_ProcID item_partner_id = fopAcM_createItemForPresentDemo(&current.pos, item_no, 0, -1,
-                                                              fopAcM_GetRoomNo(this), NULL, NULL);
+            fopAcM_GetRoomNo(this), NULL, NULL IF_DUSK_ARG(giveTag));
         if (item_partner_id != fpcM_ERROR_PROCESS_ID_e) {
             dComIfGp_event_setItemPartnerId(item_partner_id);
         }
@@ -2365,7 +2387,7 @@ int daAlink_c::procCoGetItemInit() {
     if (var_r31 != 0) {
         mProcVar3.field_0x300e = -0x8000;
         mProcVar4.field_0x3010 = 1;
-    } else if (mDemo.getParam1() == 2) {
+    } else if (mDemo.getParam1() == DUSK_IF_ELSE(dusk::mods::item_give_tag("prayer_reward"), 2)) {
         mProcVar3.field_0x300e = 0;
     } else {
         mProcVar3.field_0x300e = shape_angle.y - (fopCamM_GetAngleY(dComIfGp_getCamera(field_0x317c)) + 0x8000);
@@ -2523,6 +2545,16 @@ int daAlink_c::procCoGetItem() {
                     } else if (mProcVar2.field_0x300c == 0x23 && checkStageName("D_MN11")) {
                         field_0x32cc = 0x5C0;
                     } else if (mProcVar2.field_0x300c == 0xE0) {
+#if TARGET_PC
+                        // Dusklight increments the Poe count when the displayed item is granted.
+                        if (dComIfGs_getPohSpiritNum() + 1 == 20) {
+                            field_0x32cc = 0x4CF;
+                        } else if (dComIfGs_getPohSpiritNum() + 1 == 60) {
+                            field_0x32cc = 0x4D0;
+                        } else {
+                            field_0x32cc = mProcVar2.field_0x300c + 0x65;
+                        }
+#else
                         if (dComIfGs_getPohSpiritNum() == 20) {
                             field_0x32cc = 0x4CF;
                         } else if (dComIfGs_getPohSpiritNum() == 60) {
@@ -2530,6 +2562,7 @@ int daAlink_c::procCoGetItem() {
                         } else {
                             field_0x32cc = mProcVar2.field_0x300c + 0x65;
                         }
+#endif
                     } else if (mProcVar2.field_0x300c == 0x21) {
                         static u32 const heartPieceMessage[5] = {0x86, 0x9C, 0x9D, 0x9E, 0x9F};
                         field_0x32cc = heartPieceMessage[dComIfGs_getMaxLife() % 5];
@@ -4009,9 +4042,9 @@ int daAlink_c::procGanonFinishInit() {
     onEndResetFlg1(ERFLG1_SHIELD_BACKBONE);
 
 #if TARGET_PC
-    if (dusk::getSettings().game.speedrunMode) {
-        if (dusk::m_speedrunInfo.m_isRunStarted) {
-            dusk::m_speedrunInfo.stopRun();
+    if (dusk::speedrun::isActive()) {
+        if (dusk::speedrun::g_speedrunInfo.m_isRunStarted) {
+            dusk::speedrun::g_speedrunInfo.stopRun();
         }
     }
 #endif
@@ -4399,8 +4432,10 @@ void daAlink_c::checkWarpStart() {
         if (dMeter2Info_getWarpStatus() == WARP_STATUS_DECIDED_e ||
             dComIfGp_event_compulsory(this, 0, 0xFFFF))
         {
-            #if VERSION != VERSION_GCN_JPN && VERSION != VERSION_SHIELD_DEBUG
+            #if TARGET_PC || (VERSION != VERSION_GCN_JPN && VERSION != VERSION_SHIELD_DEBUG)
+            IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
             onNoResetFlg0(FLG0_UNK_4000);
+            IF_DUSK_BLOCK_END
             #endif
 
             if (dMeter2Info_getWarpStatus() == WARP_STATUS_DECIDED_e) {
@@ -4428,8 +4463,10 @@ void daAlink_c::checkWarpStart() {
                 fopAcM_orderOtherEvent(this, portal, 0xFFFF, 1, 1);
             } else {
                 mDemo.setSpecialDemoType();
-                #if VERSION == VERSION_GCN_JPN || VERSION == VERSION_SHIELD_DEBUG
+                #if TARGET_PC || (VERSION == VERSION_GCN_JPN || VERSION == VERSION_SHIELD_DEBUG)
+                IF_DUSK_BLOCK(dusk::version::isRegionJpn())
                 onNoResetFlg0(FLG0_UNK_4000);
+                IF_DUSK_BLOCK_END
                 #endif
 
                 if (dMeter2Info_getWarpStatus() == 1) {
@@ -4513,10 +4550,12 @@ int daAlink_c::procCoWarpInit(int param_0, int param_1) {
                 soundId = Z2SE_WOLF_WARP_IN_TATE;
             }
 
-            #if VERSION == VERSION_GCN_JPN || VERSION == VERSION_SHIELD_DEBUG
+            #if TARGET_PC || (VERSION == VERSION_GCN_JPN || VERSION == VERSION_SHIELD_DEBUG)
+            IF_DUSK_BLOCK(dusk::version::isRegionJpn())
             if (param_1) {
                 onNoResetFlg0(FLG0_UNK_4000);
             }
+            IF_DUSK_BLOCK_END
             #endif
 
             if (param_1) {
diff --git a/src/d/actor/d_a_alink_dusk.cpp b/src/d/actor/d_a_alink_dusk.cpp
index 8a2bc0025b..4351f807aa 100644
--- a/src/d/actor/d_a_alink_dusk.cpp
+++ b/src/d/actor/d_a_alink_dusk.cpp
@@ -113,6 +113,12 @@ void daAlink_c::handleQuickTransform() {
         return;
     }
 
+    // Ensure Link is not underwater
+    if (!checkNoResetFlg0(FLG0_SWIM_UP)) {
+        Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
+        return;
+    }
+
     // Use the game's default checks for if the player can currently transform
     if (!m_midnaActor->checkMetamorphoseEnableBase()) {
         Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
diff --git a/src/d/actor/d_a_alink_effect.inc b/src/d/actor/d_a_alink_effect.inc
index 3461568f19..b3a9d7bdc4 100644
--- a/src/d/actor/d_a_alink_effect.inc
+++ b/src/d/actor/d_a_alink_effect.inc
@@ -8,9 +8,12 @@
 #include "d/actor/d_a_alink.h"
 #include "d/d_com_inf_game.h"
 #include "d/d_k_wmark.h"
-#include "dusk/gx_helper.h"
 
-const EffParamProc daAlink_c::m_fEffParamProc[] = {
+#if TARGET_PC
+#include "helpers/gx_helper.h"
+#endif
+
+DUSK_GAME_DATA const EffParamProc daAlink_c::m_fEffParamProc[] = {
     &daAlink_c::setEffectFrontRollParam,
     &daAlink_c::setEffectSlipParam,
     &daAlink_c::setEffectSmallLandParam,
diff --git a/src/d/actor/d_a_alink_hook.inc b/src/d/actor/d_a_alink_hook.inc
index 660cf3b2ce..9e4e7090f8 100644
--- a/src/d/actor/d_a_alink_hook.inc
+++ b/src/d/actor/d_a_alink_hook.inc
@@ -8,9 +8,15 @@
 #include "d/actor/d_a_obj_swhang.h"
 #include "d/actor/d_a_obj_chandelier.h"
 #include "JSystem/J3DGraphBase/J3DMaterial.h"
-#include "dusk/frame_interpolation.h"
+
+#if TARGET_PC
+#include "dusk/interp/dual_buffer.h"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/settings.h"
 
+static const int HS_CHAIN_MAX_LINKS = 600;
+#endif
+
 enum {
     HS_MODE_NONE_e,
     HS_MODE_READY_e,
@@ -19,10 +25,6 @@ enum {
     HS_MODE_RETURN_e = 6,
 };
 
-#if TARGET_PC
-static const int HS_CHAIN_MAX_LINKS = 600;
-#endif
-
 void daAlink_c::hsChainShape_c::draw() {
     static const int dummy = 0;
 
@@ -34,9 +36,7 @@ void daAlink_c::hsChainShape_c::draw() {
     j3dSys.setVtxPos(modelData->getVtxPosArray(), modelData->getVtxNum());
     j3dSys.setVtxNrm(modelData->getVtxNrmArray(), modelData->getNrmNum());
     j3dSys.setVtxCol(modelData->getVtxColorArray(0), modelData->getColNum());
-#if TARGET_PC
-    j3dSys.setTexture(modelData->getTexture());
-#endif
+    IF_DUSK(j3dSys.setTexture(modelData->getTexture()));
     J3DShape::resetVcdVatCache();
 
     material->loadSharedDL();
@@ -138,24 +138,21 @@ void daAlink_c::hsChainShape_c::draw() {
     } else {
 #if TARGET_PC
         cXyz hsInterpTop, hsInterpRoot, hsInterpSubRoot, hsInterpSubTop;
-        if (dusk::frame_interp::is_enabled() && alink->mHsChainInterpPrevValid && alink->mHsChainInterpCurrValid) {
-            const f32 alpha = dusk::frame_interp::get_interpolation_step();
-            hsInterpTop    = alink->mHsChainInterpPrevTop    + (alink->mHsChainInterpCurrTop    - alink->mHsChainInterpPrevTop)    * alpha;
-            hsInterpRoot   = alink->mHsChainInterpPrevRoot   + (alink->mHsChainInterpCurrRoot   - alink->mHsChainInterpPrevRoot)   * alpha;
-            hsInterpSubRoot = alink->mHsChainInterpPrevSubRoot + (alink->mHsChainInterpCurrSubRoot - alink->mHsChainInterpPrevSubRoot) * alpha;
-            hsInterpSubTop  = alink->mHsChainInterpPrevSubTop  + (alink->mHsChainInterpCurrSubTop  - alink->mHsChainInterpPrevSubTop)  * alpha;
+        auto& hsInterp = dusk::interp::get<AlinkInterp>(alink);
+        if (dusk::interp::is_enabled() && hsInterp.hs_chain.ready()) {
+            hsInterpTop     = hsInterp.hs_draw[0];
+            hsInterpRoot    = hsInterp.hs_draw[1];
+            hsInterpSubRoot = hsInterp.hs_draw[2];
+            hsInterpSubTop  = hsInterp.hs_draw[3];
         } else {
-            hsInterpTop    = alink->getHsChainTopPos();
-            hsInterpRoot   = alink->getHsChainRootPos();
+            hsInterpTop     = alink->getHsChainTopPos();
+            hsInterpRoot    = alink->getHsChainRootPos();
             hsInterpSubRoot = alink->getHsSubChainRootPos();
             hsInterpSubTop  = alink->getHsSubChainTopPos();
         }
-        const cXyz& chainRootPos = hsInterpRoot;
-        const cXyz& chainTopPos = hsInterpTop;
-#else
-        const cXyz& chainRootPos = alink->getHsChainRootPos();
-        const cXyz& chainTopPos = alink->getHsChainTopPos();
 #endif
+        const cXyz& chainRootPos = DUSK_IF_ELSE(hsInterpRoot, alink->getHsChainRootPos());
+        const cXyz& chainTopPos = DUSK_IF_ELSE(hsInterpTop, alink->getHsChainTopPos());
         cXyz maxDistance = chainRootPos - chainTopPos;
 
         f32 maxDistanceF = maxDistance.abs();
@@ -185,11 +182,9 @@ void daAlink_c::hsChainShape_c::draw() {
             }
             (void)0;
 
-#if TARGET_PC
-            int chainLinks = 0;
-#endif
+            IF_DUSK(int chainLinks = 0);
 
-            while (maxDistanceF > var_f30 IF_DUSK(&&chainLinks < HS_CHAIN_MAX_LINKS)) {
+            while (maxDistanceF > var_f30 IF_DUSK(&& chainLinks < HS_CHAIN_MAX_LINKS)) {
                 temp_f27 = var_f28 * cM_fsin(sp34 * var_f30);
                 s16 spC = cM_atan2s(temp_f27 - var_f26, 5.0f);
                 sp64.x = sp6C.x + spC;
@@ -212,19 +207,12 @@ void daAlink_c::hsChainShape_c::draw() {
                 var_f26 = temp_f27;
                 var_f30 += fabsf(cM_scos(spC)) * 5.0f;
 
-#if TARGET_PC
-                chainLinks++;
-#endif
+                IF_DUSK(chainLinks++);
             }
         }
 
-#if TARGET_PC
-        const cXyz& subChainRootPos = hsInterpSubRoot;
-        const cXyz& subChainTopPos = hsInterpSubTop;
-#else
-        const cXyz& subChainRootPos = alink->getHsSubChainRootPos();
-        const cXyz& subChainTopPos = alink->getHsSubChainTopPos();
-#endif
+        const cXyz& subChainRootPos = DUSK_IF_ELSE(hsInterpSubRoot, alink->getHsSubChainRootPos());
+        const cXyz& subChainTopPos = DUSK_IF_ELSE(hsInterpSubTop, alink->getHsSubChainTopPos());
         maxDistance = subChainRootPos - subChainTopPos;
 
         maxDistanceF = maxDistance.abs();
@@ -235,11 +223,9 @@ void daAlink_c::hsChainShape_c::draw() {
             sp98 = subChainTopPos;
             sp6C.set(maxDistance.atan2sY_XZ(), maxDistance.atan2sX_Z(), 0);
 
-#if TARGET_PC
-            int subChainLinks = 0;
-#endif
+            IF_DUSK(int subChainLinks = 0);
 
-            while (maxDistanceF > var_f30 IF_DUSK(&&subChainLinks < HS_CHAIN_MAX_LINKS)) {
+            while (maxDistanceF > var_f30 IF_DUSK(&& subChainLinks < HS_CHAIN_MAX_LINKS)) {
                 mDoMtx_stack_c::copy(j3dSys.getViewMtx());
                 mDoMtx_stack_c::transM(sp98);
                 mDoMtx_stack_c::ZXYrotM(sp6C);
@@ -252,39 +238,12 @@ void daAlink_c::hsChainShape_c::draw() {
                 sp98 += maxDistance * 5.0f;
                 ANGLE_ADD_2(sp6C.z, 0x3000);
                 var_f30 += 5.0f;
-#if TARGET_PC
-                subChainLinks++;
-#endif
+                IF_DUSK(subChainLinks++);
             }
         }
     }
 }
 
-#if TARGET_PC
-static void ironBallChainInterpCallback(bool isSimFrame, void* pUserWork) {
-    static_cast<daAlink_c*>(pUserWork)->onIronBallChainInterpCallback();
-}
-
-void daAlink_c::onIronBallChainInterpCallback() {
-    if (!mIBChainInterpPrevValid || !mIBChainInterpCurrValid) {
-        return;
-    }
-    if (mIronBallChainPos == NULL || mIronBallChainAngle == NULL) {
-        return;
-    }
-
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-
-    for (int i = 0; i < IRON_BALL_CHAIN_COUNT; i++) {
-        mIronBallChainPos[i] = mIBChainInterpPrevPos[i] + (mIBChainInterpCurrPos[i] - mIBChainInterpPrevPos[i]) * alpha;
-        mIronBallChainAngle[i].x = mIBChainInterpPrevAngle[i].x + (s16)((s16)(mIBChainInterpCurrAngle[i].x - mIBChainInterpPrevAngle[i].x) * alpha);
-        mIronBallChainAngle[i].y = mIBChainInterpPrevAngle[i].y + (s16)((s16)(mIBChainInterpCurrAngle[i].y - mIBChainInterpPrevAngle[i].y) * alpha);
-        mIronBallChainAngle[i].z = mIBChainInterpPrevAngle[i].z + (s16)((s16)(mIBChainInterpCurrAngle[i].z - mIBChainInterpPrevAngle[i].z) * alpha);
-    }
-    mHookshotTopPos = mIBChainInterpPrevHandRoot + (mIBChainInterpCurrHandRoot - mIBChainInterpPrevHandRoot) * alpha;
-}
-#endif
-
 void daAlink_c::hookshotAtHitCallBack(dCcD_GObjInf* i_atObjInf, fopAc_ac_c* i_tgActor,
                                       dCcD_GObjInf* i_tgObjInf) {
     if (i_tgActor != NULL && fopAcM_IsActor(i_tgActor) && !i_tgObjInf->ChkTgHookshotThrough()) {
diff --git a/src/d/actor/d_a_alink_horse.inc b/src/d/actor/d_a_alink_horse.inc
index cc2bf54121..f271ed401e 100644
--- a/src/d/actor/d_a_alink_horse.inc
+++ b/src/d/actor/d_a_alink_horse.inc
@@ -73,19 +73,19 @@ int daAlink_c::getReinRideDirection() {
     return DIR_RIGHT;
 }
 
-Vec const daAlink_c::m_handLeftOutSidePos = {
+DUSK_GAME_DATA Vec const daAlink_c::m_handLeftOutSidePos = {
     9.0f, -5.0f, 3.0f
 };
 
-Vec const daAlink_c::m_handRightOutSidePos = {
+DUSK_GAME_DATA Vec const daAlink_c::m_handRightOutSidePos = {
     9.0f, -5.0f, -3.0f
 };
 
-Vec const daAlink_c::m_handLeftInSidePos = {
+DUSK_GAME_DATA Vec const daAlink_c::m_handLeftInSidePos = {
     9.0f, 5.0f, 3.0f
 };
 
-Vec const daAlink_c::m_handRightInSidePos = {
+DUSK_GAME_DATA Vec const daAlink_c::m_handRightInSidePos = {
     9.0f, 5.0f, -3.0f
 };
 
@@ -340,18 +340,31 @@ void daAlink_c::setHorseStirrup() {
         mDoMtx_stack_c::copy(mpLinkModel->getAnmMtx(field_0x30bc));
         mDoMtx_stack_c::transM(-2.0f, -11.0f, 1.5f);       
         mDoMtx_stack_c::ZXYrotM(0, -0x8000, 0x4000);
+#if TARGET_PC
+        horse->m_model->setAnmMtx(0x17, mDoMtx_stack_c::get());
+#else
         mDoMtx_copy(mDoMtx_stack_c::get(), horse->getLeftStirrupMtx());
+#endif
     }
 
     if (field_0x2fab & 2) {
         mDoMtx_stack_c::copy(mpLinkModel->getAnmMtx(field_0x30be));
         mDoMtx_stack_c::transM(-2.0f, 11.0f, 1.5f);     
         mDoMtx_stack_c::ZrotM(-0x4000);
+#if TARGET_PC
+        horse->m_model->setAnmMtx(0x19, mDoMtx_stack_c::get());
+#else
         mDoMtx_copy(mDoMtx_stack_c::get(), horse->getRightStirrupMtx());
+#endif
     }
 
     if (field_0x2fab & 3) {
         horse->calcWeightEnvMtx();
+#if TARGET_PC
+        for (u16 i = 0; i < horse->m_model->getModelData()->getWEvlpMtxNum(); i++) {
+            dusk::interp::record_final_mtx(horse->m_model->getWeightAnmMtx(i));
+        }
+#endif
     }
 
     int hand_type = getReinHandType();
diff --git a/src/d/actor/d_a_alink_swindow.inc b/src/d/actor/d_a_alink_swindow.inc
index 33f1fee37b..0359bc99bb 100644
--- a/src/d/actor/d_a_alink_swindow.inc
+++ b/src/d/actor/d_a_alink_swindow.inc
@@ -11,6 +11,16 @@ static int daAlink_modelCallBack(J3DJoint* i_joint, int param_1);
 static int daAlink_headModelCallBack(J3DJoint* i_joint, int param_1);
 static int daAlink_wolfModelCallBack(J3DJoint* i_joint, int param_1);
 
+#if TARGET_PC
+static void* read_anm_resource(void** o_buffer, u16 i_resIdx, u32 i_fixedSize) {
+    u32 size = daPy_getAnmResourceSize(i_resIdx, i_fixedSize);
+    *o_buffer = JKRAllocFromSysHeap(size, 0x20);
+    JUT_ASSERT(__LINE__, *o_buffer);
+    JKRReadIdxResource(*o_buffer, size, i_resIdx, dComIfGp_getAnmArchive());
+    return *o_buffer;
+}
+#endif
+
 void daAlink_c::setArcName(BOOL i_isWolf) {
     if (i_isWolf) {
         mArcName = l_wArcName;
@@ -247,8 +257,10 @@ void daAlink_c::changeModelDataDirectWolf(int param_0) {
 void daAlink_c::initStatusWindow() {
     onNoResetFlg2(FLG2_STATUS_WINDOW_DRAW);
     
+#if !TARGET_PC
     void* tmpBuffer = JKR_NEW_ARRAY_ARGS(void*, 0x500, 0x20);
     JUT_ASSERT(394, tmpBuffer);
+#endif
 
     u16 bckResIdx, btpResIdx, btkResIdx;
     if (checkWolf()) {
@@ -268,7 +280,11 @@ void daAlink_c::initStatusWindow() {
         changeModelDataDirect(0);
     }
 
+#if TARGET_PC
+    void* tmpBuffer = read_anm_resource(&mAnmBuffers[0], bckResIdx, 0x1400);
+#else
     JKRReadIdxResource(tmpBuffer, 0x1400, bckResIdx, dComIfGp_getAnmArchive());
+#endif
     m_sWindowBck = JKR_NEW mDoExt_bckAnm();
     JUT_ASSERT(428, m_sWindowBck);
 
@@ -276,20 +292,28 @@ void daAlink_c::initStatusWindow() {
         JUT_ASSERT(433, FALSE);
     }
 
+#if TARGET_PC
+    tmpBuffer = read_anm_resource(&mAnmBuffers[1], btpResIdx, 0x400);
+#else
     tmpBuffer = JKR_NEW_ARRAY_ARGS(void*, 0x100, 0x20);
     JUT_ASSERT(437, tmpBuffer);
 
     JKRReadIdxResource(tmpBuffer, 0x400, btpResIdx, dComIfGp_getAnmArchive());
+#endif
     // this should call J3DAnmLoaderDataBase::load(const void*) but it breaks retail
     J3DAnmTexPattern* btp = (J3DAnmTexPattern*)J3DAnmLoaderDataBase::load(tmpBuffer, J3DLOADER_UNK_FLAG0);
     btp->setFrame(0.0f);
     btp->searchUpdateMaterialID(field_0x06c0);
     field_0x06c0->entryTexNoAnimator(btp);
 
+#if TARGET_PC
+    tmpBuffer = read_anm_resource(&mAnmBuffers[2], btkResIdx, 0x400);
+#else
     tmpBuffer = JKR_NEW_ARRAY_ARGS(void*, 0x100, 0x20);
     JUT_ASSERT(449, tmpBuffer);
 
     JKRReadIdxResource(tmpBuffer, 0x400, btkResIdx, dComIfGp_getAnmArchive());
+#endif
     // this should call J3DAnmLoaderDataBase::load(const void*) but it breaks retail
     J3DAnmTextureSRTKey* btk = (J3DAnmTextureSRTKey*)J3DAnmLoaderDataBase::load(tmpBuffer, J3DLOADER_UNK_FLAG0);
     btk->setFrame(0.0f);
@@ -387,4 +411,12 @@ void daAlink_c::resetStatusWindow() {
 
     offNoResetFlg2(FLG2_STATUS_WINDOW_DRAW);
     m_sWindowBck = NULL;
+#if TARGET_PC
+    for (int i = 0; i < 3; i++) {
+        if (mAnmBuffers[i] != NULL) {
+            JKRFreeToSysHeap(mAnmBuffers[i]);
+            mAnmBuffers[i] = NULL;
+        }
+    }
+#endif
 }
diff --git a/src/d/actor/d_a_b_ds.cpp b/src/d/actor/d_a_b_ds.cpp
index 17bdd9564b..efa1c289a9 100644
--- a/src/d/actor/d_a_b_ds.cpp
+++ b/src/d/actor/d_a_b_ds.cpp
@@ -19,6 +19,10 @@
 #include "f_op/f_op_actor_enemy.h"
 #include "Z2AudioLib/Z2Instances.h"
 
+#if TARGET_PC
+#include "mods/items.h"
+#endif
+
 enum daB_DS_Joint {
     DS_JNT_BACKBONE1,
     DS_JNT_BACKBONE2,
@@ -4084,6 +4088,11 @@ void daB_DS_c::executeBattle2Dead() {
             camera->mCamera.SetTrimSize(0);
             dComIfGp_event_reset();
             dComIfGs_onStageBossEnemy(0x13);
+#if TARGET_PC
+            // This reward has no original grant at this point in the cutscene.
+            dusk::mods::item_check_enqueue_deferred(
+                ITEM_CHECK_DUNGEON_REWARD_ARBITERS, dItemNo_NONE_e);
+#endif
             /* dSv_event_flag_c::F_0265 - Arbiter's Grounds - Arbiter's Grounds clear */
             dComIfGs_onEventBit(0x2010);
             fopAcM_delete(this);
diff --git a/src/d/actor/d_a_b_gnd.cpp b/src/d/actor/d_a_b_gnd.cpp
index 80cca37f6e..42eeac303a 100644
--- a/src/d/actor/d_a_b_gnd.cpp
+++ b/src/d/actor/d_a_b_gnd.cpp
@@ -17,10 +17,10 @@
 
 #include "Z2AudioLib/Z2Instances.h"
 
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
 #if TARGET_PC
 #include "dusk/achievements.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/settings.h"
 #endif
 
 class daB_GND_HIO_c : public JORReflexible {
@@ -285,30 +285,6 @@ static int h_nodeCallBack(J3DJoint* i_joint, int param_2) {
     return 1;
 }
 
-#if TARGET_PC
-static void b_gnd_rein_interp_callback(bool isSimFrame, void* pUserWork) {
-    b_gnd_class* i_this = (b_gnd_class*)pUserWork;
-    if (!i_this->mReinsInterpPrevValid || !i_this->mReinsInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    for (int r = 0; r < 2; r++) {
-        cXyz* dst = i_this->mHorseReins[r].getPos(0);
-        for (int i = 0; i < 16; i++) {
-            const cXyz& p0 = i_this->mReinsInterpPrev[r][i];
-            const cXyz& p1 = i_this->mReinsInterpCurr[r][i];
-            dst[i] = p0 + (p1 - p0) * alpha;
-        }
-    }
-    cXyz* dst = i_this->field_0x21e8.getPos(0);
-    for (int i = 0; i < 2; i++) {
-        const cXyz& p0 = i_this->mReinsTexInterpPrev[i];
-        const cXyz& p1 = i_this->mReinsTexInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static int daB_GND_Draw(b_gnd_class* i_this) {
     fopAc_ac_c* a_this = (fopAc_ac_c*)i_this;
     
@@ -396,21 +372,6 @@ static int daB_GND_Draw(b_gnd_class* i_this) {
 
         i_this->field_0x21e8.update(2, l_color, &a_this->tevStr);
         dComIfGd_set3DlineMat(&i_this->field_0x21e8);
-#if TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
-            if (i_this->mReinsInterpCurrValid) {
-                memcpy(i_this->mReinsInterpPrev, i_this->mReinsInterpCurr, sizeof(i_this->mReinsInterpCurr));
-                memcpy(i_this->mReinsTexInterpPrev, i_this->mReinsTexInterpCurr, sizeof(i_this->mReinsTexInterpCurr));
-                i_this->mReinsInterpPrevValid = true;
-            }
-            for (int r = 0; r < 2; r++) {
-                memcpy(i_this->mReinsInterpCurr[r], i_this->mHorseReins[r].getPos(0), 16 * sizeof(cXyz));
-            }
-            memcpy(i_this->mReinsTexInterpCurr, i_this->field_0x21e8.getPos(0), 2 * sizeof(cXyz));
-            i_this->mReinsInterpCurrValid = true;
-            dusk::frame_interp::add_interpolation_callback(&b_gnd_rein_interp_callback, i_this);
-        }
-#endif
     }
     
     return 1;
@@ -3791,7 +3752,7 @@ static void demo_camera(b_gnd_class* i_this) {
         i_this->mDemoCamSyncTicks = 2;
     }
     if (i_this->mDemoCamSyncTicks > 0) {
-        dusk::frame_interp::request_presentation_sync();
+        dusk::interp::request_presentation_sync();
         i_this->mDemoCamSyncTicks--;
     }
 #endif
diff --git a/src/d/actor/d_a_balloon_2D.cpp b/src/d/actor/d_a_balloon_2D.cpp
index ebd9396759..5d5923abc3 100644
--- a/src/d/actor/d_a_balloon_2D.cpp
+++ b/src/d/actor/d_a_balloon_2D.cpp
@@ -6,7 +6,6 @@
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
 #include "d/actor/d_a_balloon_2D.h"
-#include "dusk/frame_interpolation.h"
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
@@ -21,6 +20,10 @@
 #include "m_Do/m_Do_lib.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 class daBalloon2D_HIO_c : public mDoHIO_entry_c {
 public:
     inline daBalloon2D_HIO_c() {
@@ -229,9 +232,9 @@ int daBalloon2D_c::createHeap() {
     return 1;
 }
 
-daBalloon2D_HIO_c l_HOSTIO;
+DUSK_GAME_DATA daBalloon2D_HIO_c l_HOSTIO;
 
-daBalloon2D_c* daBalloon2D_c::myclass;
+DUSK_GAME_DATA daBalloon2D_c* daBalloon2D_c::myclass;
 
 int daBalloon2D_c::create() {
     int rv = dComIfG_resLoad(this, l_arcName);
@@ -439,12 +442,9 @@ void daBalloon2D_c::setComboAlpha() {
 void daBalloon2D_c::drawAddScore() {
     for (s32 i = 19; i >= 0; i--) {
         if (field_0x5f8[i].field_0xe != 0) {
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                field_0x5f8[i].field_0xe--;
-            }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            field_0x5f8[i].field_0xe--;
+            IF_DUSK_BLOCK_END
             s32 score3;
             s32 score2;
             s32 score = field_0x5f8[i].field_0xc;
@@ -452,13 +452,10 @@ void daBalloon2D_c::drawAddScore() {
             u8 local_88 = 0xff;
             f32 dVar11 = 30.0f;
             f32 dVar9 = 30.0f;
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                field_0x5f8[i].field_0x0.x += cM_ssin(temp0) * 0.3f;
-                field_0x5f8[i].field_0x0.y -= 1.0f;
-            }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            field_0x5f8[i].field_0x0.x += cM_ssin(temp0) * 0.3f;
+            field_0x5f8[i].field_0x0.y -= 1.0f;
+            IF_DUSK_BLOCK_END
             if (field_0x5f8[i].field_0xe < 10) {
                 f32 fVar5 = field_0x5f8[i].field_0xe / 10.0f;
                 local_88 = fVar5 * 255.0f;
diff --git a/src/d/actor/d_a_bg.cpp b/src/d/actor/d_a_bg.cpp
index 110e2aef15..051abc4172 100644
--- a/src/d/actor/d_a_bg.cpp
+++ b/src/d/actor/d_a_bg.cpp
@@ -624,9 +624,7 @@ int daBg_c::create() {
     dComIfGp_roomControl_onStatusFlag(roomNo, 0x10);
     OS_REPORT("<BG> room%d\n", roomNo);
 
-#if TARGET_PC
-    draw_interp_frame = true;
-#endif
+    IF_DUSK(draw_interp_frame = true);
 
     return cPhs_COMPLEATE_e;
 }
diff --git a/src/d/actor/d_a_bg_obj.cpp b/src/d/actor/d_a_bg_obj.cpp
index a2d4e3b1a6..84a8995cb8 100644
--- a/src/d/actor/d_a_bg_obj.cpp
+++ b/src/d/actor/d_a_bg_obj.cpp
@@ -5,15 +5,18 @@
 
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
-#include <cstdio>
-#include <cstring>
-#include <os.h>
-#include "JSystem/J3DGraphBase/J3DMaterial.h"
-#include "SSystem/SComponent/c_math.h"
 #include "d/actor/d_a_bg_obj.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include <cstdio>
+#include <os.h>
+#include <cstring>
 #include "d/actor/d_a_set_bgobj.h"
 #include "d/d_s_play.h"
-#include "dusk/string.hpp"
+#include "SSystem/SComponent/c_math.h"
+
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static const char* getBmdName(int param_0, int param_1) {
     static char l_bmdName[16];
@@ -501,14 +504,14 @@ static dCcD_SrcTri l_tri_src = {
 
 static DUSK_CONST char* l_specName = "spec.dat";
 
-createHeapFunc daBgObj_c::mCreateHeapFunc[] = {
+DUSK_GAME_DATA createHeapFunc daBgObj_c::mCreateHeapFunc[] = {
     &daBgObj_c::CreateHeapType0,
     &daBgObj_c::CreateHeapType1,
     &daBgObj_c::CreateHeapType1,
     &daBgObj_c::CreateHeapType1,
 };
 
-createInitFunc daBgObj_c::mCreateInitFunc[] = {
+DUSK_GAME_DATA createInitFunc daBgObj_c::mCreateInitFunc[] = {
     &daBgObj_c::CreateInitType0,
     &daBgObj_c::CreateInitType1,
     &daBgObj_c::CreateInitType1,
@@ -519,14 +522,14 @@ int daBgObj_c::Create() {
     return (this->*mCreateInitFunc[mSpecData.mSpecType])();
 }
 
-executeFunc daBgObj_c::mExecuteFunc[] = {
+DUSK_GAME_DATA executeFunc daBgObj_c::mExecuteFunc[] = {
     &daBgObj_c::ExecuteType0,
     &daBgObj_c::ExecuteType1,
     &daBgObj_c::ExecuteType1,
     &daBgObj_c::ExecuteType1,
 };
 
-tgSetFunc daBgObj_c::mTgSetFunc[] = {
+DUSK_GAME_DATA tgSetFunc daBgObj_c::mTgSetFunc[] = {
     &daBgObj_c::set_tri_0, &daBgObj_c::set_tri_1, &daBgObj_c::set_cyl_0,
     &daBgObj_c::set_tri_2, &daBgObj_c::set_tri_3,
 };
diff --git a/src/d/actor/d_a_boomerang.cpp b/src/d/actor/d_a_boomerang.cpp
index a745807ce4..9deb7b46b8 100644
--- a/src/d/actor/d_a_boomerang.cpp
+++ b/src/d/actor/d_a_boomerang.cpp
@@ -137,17 +137,17 @@ static const u8 lbl_46_rodata_24[6] = {
     0x1E,
 };
 
-const u16 daBoomerang_HIO_c0::m_lockWaitTime = 10;
+DUSK_GAME_DATA const u16 daBoomerang_HIO_c0::m_lockWaitTime = 10;
 
-const f32 daBoomerang_HIO_c0::m_minCircleR = 28.0f;
+DUSK_GAME_DATA const f32 daBoomerang_HIO_c0::m_minCircleR = 28.0f;
 
-const f32 daBoomerang_HIO_c0::m_middleCircleR = 35.0f;
+DUSK_GAME_DATA const f32 daBoomerang_HIO_c0::m_middleCircleR = 35.0f;
 
-const f32 daBoomerang_HIO_c0::m_maxCircleR = 80.0f;
+DUSK_GAME_DATA const f32 daBoomerang_HIO_c0::m_maxCircleR = 80.0f;
 
-const f32 daBoomerang_HIO_c0::m_scale = 3.0f / 5.0f;
+DUSK_GAME_DATA const f32 daBoomerang_HIO_c0::m_scale = 3.0f / 5.0f;
 
-const f32 daBoomerang_HIO_c0::m_lockWindScale = 2.0f;
+DUSK_GAME_DATA const f32 daBoomerang_HIO_c0::m_lockWindScale = 2.0f;
 
 static const u32 l_lockSeFlg[BOOMERANG_LOCK_MAX] = {
     Z2SE_SY_BOOM_LOCK_ON_1,
diff --git a/src/d/actor/d_a_bullet.cpp b/src/d/actor/d_a_bullet.cpp
index 2bdd114436..f6b873a67f 100644
--- a/src/d/actor/d_a_bullet.cpp
+++ b/src/d/actor/d_a_bullet.cpp
@@ -14,14 +14,14 @@ static DUSK_CONST char* l_bmdFileNameList[] = {"hanjo_stone.bmd"};
 
 static BULLET_HIO_CLASS l_HIO;
 
-const dCcD_SrcGObjInf daBullet_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daBullet_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0x0, 0x0}, {0x79}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {0},
 };
 
-dCcD_SrcSph daBullet_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daBullet_c::mCcDSph = {
     daBullet_c::mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
@@ -81,7 +81,7 @@ int daBullet_c::Delete() {
     return 1;
 }
 
-daBullet_HIOParam const daBullet_Param_c::m = {
+DUSK_GAME_DATA daBullet_HIOParam const daBullet_Param_c::m = {
     -3.0f,
     255.0f,
     3.0f,
diff --git a/src/d/actor/d_a_coach_fire.cpp b/src/d/actor/d_a_coach_fire.cpp
index d69fd63452..53e2e4de0f 100644
--- a/src/d/actor/d_a_coach_fire.cpp
+++ b/src/d/actor/d_a_coach_fire.cpp
@@ -7,7 +7,7 @@
 
 #include "d/actor/d_a_coach_fire.h"
 
-CoachFireAttr const daCoachFire_c::M_attr = {
+DUSK_GAME_DATA CoachFireAttr const daCoachFire_c::M_attr = {
     50.0f,  // radius
     4.0f,   // field_0x04
     36,     // field_0x08
diff --git a/src/d/actor/d_a_cstaF.cpp b/src/d/actor/d_a_cstaF.cpp
index d52f6c1389..e764d4c153 100644
--- a/src/d/actor/d_a_cstaF.cpp
+++ b/src/d/actor/d_a_cstaF.cpp
@@ -34,7 +34,7 @@ static const char l_arcNameFB[] = "CstaFB";
 
 static const char l_spStageName[8] = "R_SP209";
 
-const daCstaF_c::BckTbl daCstaF_c::m_bckIdxTable[] = {
+DUSK_GAME_DATA const daCstaF_c::BckTbl daCstaF_c::m_bckIdxTable[] = {
     {9, 9, 8, 7},
     {9, 9, 8, 7}
 };
diff --git a/src/d/actor/d_a_cstatue.cpp b/src/d/actor/d_a_cstatue.cpp
index d267d87611..906b1f7559 100644
--- a/src/d/actor/d_a_cstatue.cpp
+++ b/src/d/actor/d_a_cstatue.cpp
@@ -53,7 +53,7 @@ enum CStatueAnimIndex {
     CStatueAnimIndex_N,
 };
 
-u16 const daCstatue_c::m_bckIdxTable[daCstatueType_N][CStatueAnimIndex_N] = {
+DUSK_GAME_DATA u16 const daCstatue_c::m_bckIdxTable[daCstatueType_N][CStatueAnimIndex_N] = {
     // daCstatueType_NORMAL
     {CStatueAnimSwing, CStatueAnimWalk, CStatueAnimSwing, CStatueAnimFall, CStatueAnimStop,
      CStatueAnimStart, CStatueAnimSwingre},
diff --git a/src/d/actor/d_a_demo00.cpp b/src/d/actor/d_a_demo00.cpp
index b737083598..b89965a8ce 100644
--- a/src/d/actor/d_a_demo00.cpp
+++ b/src/d/actor/d_a_demo00.cpp
@@ -1090,20 +1090,21 @@ inline int daDemo00_c::execute() {
                             break;
                         }
                         case 1:
+#if TARGET_PC
+                            // Suppress demo22_01's M_077 write. On Dusklight, the transform flag
+                            // is set by the Shadow Crystal item.
+                            if (dSv_event_flag_c::saveBitLabels[sp0E] == dSv_event_flag_c::M_077) {
+                                break;
+                            }
+#endif
                             dComIfGs_onEventBit(dSv_event_flag_c::saveBitLabels[sp0E]);
                             break;
 
                         case 2: {
                             u16 sp0A = sp0E & 0x3FFF;
                             if ((sp0E & 0xC000) == 0) {
-#if !MOVIE_SUPPORT
-                                // If movie support isn't available, automatically reset.
-                                // TPHD-esque. Maybe not the best solution, but it works.
-                                dComIfGp_event_reset();
-#else
                                 fopAcM_create(fpcNm_MOVIE_PLAYER_e, sp0A, NULL, fopAcM_GetRoomNo(this), NULL, NULL, 0xFF);
                                 mDoGph_gInf_c::fadeOut(1.0f);
-#endif
                             } else {
                                 switch (sp0A) {
                                     case 0:
diff --git a/src/d/actor/d_a_demo_item.cpp b/src/d/actor/d_a_demo_item.cpp
index 209bd483c4..0c092cf59b 100644
--- a/src/d/actor/d_a_demo_item.cpp
+++ b/src/d/actor/d_a_demo_item.cpp
@@ -170,7 +170,7 @@ void daDitem_c::actionEvent() {
 
     if (chkDead()) {
         if (!chkArgFlag(0x1)) {
-            execItemGet(m_itemNo);
+            execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         }
 
         if (m_itemNo == dItemNo_KAKERA_HEART_e) {
@@ -449,7 +449,7 @@ int daDitem_c::Delete() {
 
     endInsectEffect();
     mSound.deleteObject();
-    return DeleteBase(dItem_data::getArcName(m_itemNo));
+    return DeleteBase(dItem_data::getArcName(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo)));
 }
 
 static int daDitem_Delete(daDitem_c* i_this) {
@@ -461,8 +461,16 @@ int daDitem_c::create() {
 
     m_itemNo = daDitem_prm::getNo(this);
 
+#if TARGET_PC
+    const auto [item, displayItem, _] = dusk::mods::item_check_resolve(mItemGiveTag, m_itemNo, this);
+    m_itemNo = item;
+    setDisplayItemNo(displayItem);
+    const char* arc_name = dItem_data::getArcName(displayItem);
+    s16 bmd_name = dItem_data::getBmdName(displayItem);
+#else
     const char* arc_name = dItem_data::getArcName(m_itemNo);
     s16 bmd_name = dItem_data::getBmdName(m_itemNo);
+#endif
 
     if (bmd_name < 0 || arc_name == NULL) {
         if (bmd_name == 0) {
@@ -476,9 +484,13 @@ int daDitem_c::create() {
         }
 
         m_itemNo = dItemNo_GREEN_RUPEE_e;
+#if TARGET_PC
+        setDisplayItemNo(dItemNo_NONE_e);
+#endif
     }
 
-    int phase_state = dComIfG_resLoad(&mPhase, dItem_data::getArcName(m_itemNo));
+    int phase_state = dComIfG_resLoad(
+        &mPhase, dItem_data::getArcName(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo)));
     if (phase_state == cPhs_COMPLEATE_e) {
         if (!fopAcM_entrySolidHeap(this, CheckItemCreateHeap, 0x80003390)) {
             return cPhs_ERROR_e;
@@ -538,7 +550,7 @@ static int daDitem_Execute(daDitem_c* i_this) {
 }
 
 int daDitem_c::draw() {
-    switch (m_itemNo) {
+    switch (DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo)) {
     case dItemNo_WOOD_STICK_e:
         draw_WOOD_STICK();
         break;
diff --git a/src/d/actor/d_a_door_shutter.cpp b/src/d/actor/d_a_door_shutter.cpp
index 3b7cdcc5f2..b7a7286903 100644
--- a/src/d/actor/d_a_door_shutter.cpp
+++ b/src/d/actor/d_a_door_shutter.cpp
@@ -18,8 +18,9 @@
 #include <cstring>
 
 #if TARGET_PC
-#include <f_ap/f_ap_game.h>
-#include <dusk/autosave.h>
+#include "dusk/autosave.h"
+
+#include "f_ap/f_ap_game.h"
 #endif
 
 char DUSK_CONST* daDoor20_c::getStopBmdName() {
diff --git a/src/d/actor/d_a_e_bee.cpp b/src/d/actor/d_a_e_bee.cpp
index 09909f9e0a..3cfadae812 100644
--- a/src/d/actor/d_a_e_bee.cpp
+++ b/src/d/actor/d_a_e_bee.cpp
@@ -15,6 +15,10 @@
 #include "SSystem/SComponent/c_math.h"
 #include "Z2AudioLib/Z2Instances.h"
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 static bool hio_set;
 
 static daE_Bee_HIO_c l_HIO;
@@ -50,6 +54,26 @@ static int daE_Bee_Draw(e_bee_class* i_this) {
     return 1;
 }
 
+#if TARGET_PC
+static void bee_interp(bee_s* i_bee) {
+    if (!dusk::interp::is_enabled()) {
+        return;
+    }
+
+    J3DModel* models[] = {
+        i_bee->mpModel1,
+        i_bee->mpModel2,
+        i_bee->mpModel3,
+        i_bee->mpModel4,
+    };
+    MtxP mtx = mDoMtx_stack_c::get();
+    for (int i = 0; i < 4; i++) {
+        models[i]->setBaseTRMtx(mtx);
+        models[i]->calc();
+    }
+}
+#endif
+
 static void bee_mtxset(bee_s* i_bee) {
     mDoMtx_stack_c::transS(i_bee->mPos.x, i_bee->mPos.y, i_bee->mPos.z);
     mDoMtx_stack_c::YrotM(i_bee->mAngle.y);
@@ -62,6 +86,7 @@ static void bee_mtxset(bee_s* i_bee) {
     } else {
         i_bee->mpModel2->setBaseTRMtx(mDoMtx_stack_c::get());
     }
+    IF_DUSK(bee_interp(i_bee));
 }
 
 static void bee_ground_ang_set(bee_s* i_bee) {
@@ -332,6 +357,7 @@ static void bee_nest_action(e_bee_class* i_this, bee_s* i_bee, s8 i_nestHealth)
             i_bee->mpModel4->setBaseTRMtx(mDoMtx_stack_c::get());
         }
     }
+    IF_DUSK(bee_interp(i_bee));
 
     if (i_nestHealth == 1) {
         i_bee->mAction = bee_s::ACT_FLY;
diff --git a/src/d/actor/d_a_e_db.cpp b/src/d/actor/d_a_e_db.cpp
index dcc3849756..65f91843a3 100644
--- a/src/d/actor/d_a_e_db.cpp
+++ b/src/d/actor/d_a_e_db.cpp
@@ -10,10 +10,6 @@
 #include "f_op/f_op_kankyo_mng.h"
 #include "f_op/f_op_actor_enemy.h"
 
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#endif
-
 class daE_DB_HIO_c : public JORReflexible {
 public:
     daE_DB_HIO_c();
@@ -70,22 +66,6 @@ static BOOL leaf_anm_init(e_db_class* i_this, int i_anm, f32 i_morf, u8 i_mode,
     return FALSE;
 }
 
-#if TARGET_PC
-static void daE_DB_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_db_class* i_this = (e_db_class*)pUserWork;
-    if (!i_this->mStalkLineInterpPrevValid || !i_this->mStalkLineInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    cXyz* dst = i_this->stalkLine.getPos(0);
-    for (int i = 0; i < 12; i++) {
-        const cXyz& p0 = i_this->mStalkLineInterpPrev[i];
-        const cXyz& p1 = i_this->mStalkLineInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static int daE_DB_Draw(e_db_class* i_this) {
     fopAc_ac_c* actor = &i_this->enemy;
 
@@ -115,17 +95,6 @@ static int daE_DB_Draw(e_db_class* i_this) {
     static GXColor l_color = {0x14, 0x0F, 0x00, 0xFF};
     i_this->stalkLine.update(12, l_color, &actor->tevStr);
     dComIfGd_set3DlineMat(&i_this->stalkLine);
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mStalkLineInterpCurrValid) {
-            memcpy(i_this->mStalkLineInterpPrev, i_this->mStalkLineInterpCurr, sizeof(i_this->mStalkLineInterpCurr));
-            i_this->mStalkLineInterpPrevValid = true;
-        }
-        memcpy(i_this->mStalkLineInterpCurr, i_this->stalkLine.getPos(0), 12 * sizeof(cXyz));
-        i_this->mStalkLineInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&daE_DB_interp_callback, i_this);
-    }
-#endif
 
     for (int i = 1; i < 11; i++) {
         if (i_this->thornModel[i] != NULL) {
diff --git a/src/d/actor/d_a_e_dd.cpp b/src/d/actor/d_a_e_dd.cpp
index 3c28489d36..76af1183b3 100644
--- a/src/d/actor/d_a_e_dd.cpp
+++ b/src/d/actor/d_a_e_dd.cpp
@@ -1775,7 +1775,7 @@ static cPhs_Step daE_DD_Create(fopAc_ac_c* a_this) {
     return phase;
 }
 
-actor_method_class l_daE_DD_Method = {
+DUSK_GAME_DATA actor_method_class l_daE_DD_Method = {
     (process_method_func)daE_DD_Create,
     (process_method_func)daE_DD_Delete,
     (process_method_func)daE_DD_Execute,
diff --git a/src/d/actor/d_a_e_dn.cpp b/src/d/actor/d_a_e_dn.cpp
index 954bf657eb..1386275ca0 100644
--- a/src/d/actor/d_a_e_dn.cpp
+++ b/src/d/actor/d_a_e_dn.cpp
@@ -1031,7 +1031,7 @@ static int way_check(e_dn_class* i_this) {
     return 2;
 }
 
-int learn_check;
+DUSK_GAME_DATA int learn_check;
 
 static void* shot_s_sub(void* i_actor, void* i_data) {
     UNUSED(i_data);
diff --git a/src/d/actor/d_a_e_dt.cpp b/src/d/actor/d_a_e_dt.cpp
index e52cadfd93..1078b89eb5 100644
--- a/src/d/actor/d_a_e_dt.cpp
+++ b/src/d/actor/d_a_e_dt.cpp
@@ -124,15 +124,15 @@ enum Joint {
     /* 0x2A */ JNT_TAIL_2,
 };
 
-f32 E_DT_n::eDt_ShakeFrame[10] = {
+DUSK_GAME_DATA f32 E_DT_n::eDt_ShakeFrame[10] = {
     20.0f, 22.0f, 24.0f, 26.0f, 28.0f, 30.0f, 32.0f, 34.0f, 36.0f, 38.0f,
 };
 
-f32 E_DT_n::eDt_ShakeFrameDemo[10] = {
+DUSK_GAME_DATA f32 E_DT_n::eDt_ShakeFrameDemo[10] = {
     310.0f, 312.0f, 314.0f, 316.0f, 318.0f, 320.0f, 322.0f, 324.0f, 326.0f, 328.0f,
 };
 
-dCcD_SrcSph E_DT_n::cc_dt_body_src = {
+DUSK_GAME_DATA dCcD_SrcSph E_DT_n::cc_dt_body_src = {
     {
         {0x0, {{AT_TYPE_CSTATUE_SWING, 0x1, 0x0}, {0xd8fbfdff, 0x43}, 0x75}}, // mObj
         {dCcD_SE_METAL, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
@@ -144,7 +144,7 @@ dCcD_SrcSph E_DT_n::cc_dt_body_src = {
     } // mSphAttr
 };
 
-dCcD_SrcSph E_DT_n::cc_dt_tongue_src = {
+DUSK_GAME_DATA dCcD_SrcSph E_DT_n::cc_dt_tongue_src = {
     {
         {0x0, {{AT_TYPE_CSTATUE_SWING, 0x1, 0x0}, {0xd8fbfdff, 0x43}, 0x75}}, // mObj
         {dCcD_SE_METAL, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
@@ -700,9 +700,9 @@ void daE_DT_c::setBoxTubaLandEffect() {
     }
 }
 
-int E_DT_n::mDt_OtamaNum;
+DUSK_GAME_DATA int E_DT_n::mDt_OtamaNum;
 
-int E_DT_n::mDt_OtamaNo[20];
+DUSK_GAME_DATA int E_DT_n::mDt_OtamaNo[20];
 
 static void* s_otama_todo(void* i_proc, void* i_this) {
     if (fopAcM_IsActor(i_proc) && !fpcM_IsCreating(fopAcM_GetID(i_proc))
@@ -726,7 +726,7 @@ int daE_DT_c::getNumberOfOtama() {
     return E_DT_n::mDt_OtamaNum;
 }
 
-int E_DT_n::m_fall_no;
+DUSK_GAME_DATA int E_DT_n::m_fall_no;
 
 static void* s_fall_otama(void* i_proc, void* i_this) {
     if (fopAcM_IsActor(i_proc) && !fpcM_IsCreating(fopAcM_GetID(i_proc))
@@ -772,7 +772,7 @@ static void* s_demo_otama(void* i_proc, void* i_this) {
     return NULL;
 }
 
-cXyz E_DT_n::m_tongue_pos;
+DUSK_GAME_DATA cXyz E_DT_n::m_tongue_pos;
 
 static void* s_bomb_search(void* i_proc, void* i_this) {
     if (fopAcM_IsActor(i_proc) && !fpcM_IsCreating(fopAcM_GetID(i_proc))) {
diff --git a/src/d/actor/d_a_e_ge.cpp b/src/d/actor/d_a_e_ge.cpp
index 20e7cd9cb2..cdf83bbed5 100644
--- a/src/d/actor/d_a_e_ge.cpp
+++ b/src/d/actor/d_a_e_ge.cpp
@@ -1081,7 +1081,7 @@ void daE_GE_c::executeShield() {
     }
 }
 
-daE_GE_c::actionFunc daE_GE_c::l_actionmenu[9] = {
+DUSK_GAME_DATA daE_GE_c::actionFunc daE_GE_c::l_actionmenu[9] = {
     (&daE_GE_c::executeWait), (&daE_GE_c::executeFly),  (&daE_GE_c::executeAttack),
     (&daE_GE_c::executeBack), (&daE_GE_c::executeDown), (&daE_GE_c::executeSurprise),
     (&daE_GE_c::executeCaw),  (&daE_GE_c::executeWind), (&daE_GE_c::executeShield),
diff --git a/src/d/actor/d_a_e_hb.cpp b/src/d/actor/d_a_e_hb.cpp
index f0dfbda3a6..b39f4750a1 100644
--- a/src/d/actor/d_a_e_hb.cpp
+++ b/src/d/actor/d_a_e_hb.cpp
@@ -9,10 +9,6 @@
 #include "d/actor/d_a_e_hb_leaf.h"
 #include "f_op/f_op_actor_enemy.h"
 
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#endif
-
 enum daE_HB_ACTION {
     ACTION_STAY,
     ACTION_APPEAR,
@@ -68,22 +64,6 @@ static BOOL leaf_anm_init(e_hb_class* i_this, int i_anm, f32 i_morf, u8 i_mode,
     return FALSE;
 }
 
-#if TARGET_PC
-static void daE_HB_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_hb_class* i_this = (e_hb_class*)pUserWork;
-    if (!i_this->mStalkLineInterpPrevValid || !i_this->mStalkLineInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    cXyz* dst = i_this->stalkLine.getPos(0);
-    for (int i = 0; i < 12; i++) {
-        const cXyz& p0 = i_this->mStalkLineInterpPrev[i];
-        const cXyz& p1 = i_this->mStalkLineInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static int daE_HB_Draw(e_hb_class* i_this) {
     fopAc_ac_c* actor = &i_this->enemy;
 
@@ -102,17 +82,6 @@ static int daE_HB_Draw(e_hb_class* i_this) {
     static GXColor l_color = {0x14, 0x0F, 0x00, 0xFF};
     i_this->stalkLine.update(12, l_color, &actor->tevStr);
     dComIfGd_set3DlineMat(&i_this->stalkLine);
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mStalkLineInterpCurrValid) {
-            memcpy(i_this->mStalkLineInterpPrev, i_this->mStalkLineInterpCurr, sizeof(i_this->mStalkLineInterpCurr));
-            i_this->mStalkLineInterpPrevValid = true;
-        }
-        memcpy(i_this->mStalkLineInterpCurr, i_this->stalkLine.getPos(0), 12 * sizeof(cXyz));
-        i_this->mStalkLineInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&daE_HB_interp_callback, i_this);
-    }
-#endif
 
     for (int i = 1; i < 11; i++) {
         if (i_this->thornModel[i] != NULL) {
diff --git a/src/d/actor/d_a_e_hp.cpp b/src/d/actor/d_a_e_hp.cpp
index 51ac16fcf3..29ae9d43f5 100644
--- a/src/d/actor/d_a_e_hp.cpp
+++ b/src/d/actor/d_a_e_hp.cpp
@@ -726,13 +726,27 @@ void daE_HP_c::executeDead() {
             fopAcM_onSwitch(this, bitSw);
         }
 
+#if TARGET_PC
+        const auto itemCheck = dusk::mods::item_check_commit(
+            dusk::mods::item_give_tag_poe(bitSw), dItemNo_POU_SPIRIT_e, this);
+        mItemCheckHandled = true;
+        if (itemCheck.itemNo == dItemNo_NONE_e) {
+            dusk::mods::item_check_complete(itemCheck, this);
+        } else {
+            daAlink_getAlinkActorClass()->procWolfAtnActorMoveInit();
+            dusk::mods::item_check_enqueue(itemCheck, dusk::mods::ItemGiveMode::ForcedDemo);
+        }
+#else
         dComIfGs_addPohSpiritNum();
+#endif
 
         field_0x784 = -1;
 
+#if !TARGET_PC
         if (dComIfGs_getPohSpiritNum() == 20) {
             dComIfGs_onEventBit(dSv_event_flag_c::saveBitLabels[0x1c9]);
         }
+#endif
 
         movemode++;
     }
@@ -752,13 +766,13 @@ void daE_HP_c::executeDead() {
                     field_0x788 = 1;
                 }
             }
-        } else if (field_0x788 != 0) {
+        } else if (field_0x788 != 0 IF_DUSK(|| mItemCheckHandled)) {
             fopAcM_createDisappear(this, &current.pos, 8, 3, 0xff);
             fopAcM_delete(this);
         } else {
             if (field_0x784 == -1) {
-                field_0x784 = fopAcM_createItemForPresentDemo(&current.pos, dItemNo_POU_SPIRIT_e, 0, -1,
-                                                              -1, 0, 0);
+                field_0x784 = fopAcM_createItemForPresentDemo(&current.pos, dItemNo_POU_SPIRIT_e, 0,
+                    -1, -1, 0, 0 IF_DUSK_ARG(dusk::mods::item_give_tag_poe(bitSw)));
             }
 
             if (fopAcM_IsExecuting(field_0x784) != FALSE) {
diff --git a/src/d/actor/d_a_e_mb.cpp b/src/d/actor/d_a_e_mb.cpp
index 1fff337b33..9eaef0cc1c 100644
--- a/src/d/actor/d_a_e_mb.cpp
+++ b/src/d/actor/d_a_e_mb.cpp
@@ -12,8 +12,6 @@
 #include "d/d_bomb.h"
 #include "c/c_damagereaction.h"
 #include "Z2AudioLib/Z2Instances.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
 
 #define ACTION_STANDBY    0
 #define ACTION_WALK1      1
@@ -65,22 +63,6 @@ static void anm_init(e_mb_class* i_this, int i_anmID, f32 i_morf, u8 i_attr, f32
     i_this->mAnm = i_anmID;
 }
 
-#if TARGET_PC
-static void e_mb_rope_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_mb_class* i_this = (e_mb_class*)pUserWork;
-    if (!i_this->mRopeInterpPrevValid || !i_this->mRopeInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    cXyz* dst = i_this->mRopeMat.getPos(0);
-    for (int i = 0; i < 16; i++) {
-        const cXyz& p0 = i_this->mRopeInterpPrev[i];
-        const cXyz& p1 = i_this->mRopeInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static int daE_MB_Draw(e_mb_class* i_this) {
     fopAc_ac_c* a_this = (fopAc_ac_c*)i_this;
 
@@ -104,17 +86,6 @@ static int daE_MB_Draw(e_mb_class* i_this) {
     static GXColor l_color = {0x14, 0x0F, 0x00, 0xFF};
     i_this->mRopeMat.update(16, l_color, &a_this->tevStr);
     dComIfGd_set3DlineMat(&i_this->mRopeMat);
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mRopeInterpCurrValid) {
-            memcpy(i_this->mRopeInterpPrev, i_this->mRopeInterpCurr, sizeof(i_this->mRopeInterpCurr));
-            i_this->mRopeInterpPrevValid = true;
-        }
-        memcpy(i_this->mRopeInterpCurr, i_this->mRopeMat.getPos(0), 16 * sizeof(cXyz));
-        i_this->mRopeInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&e_mb_rope_interp_callback, i_this);
-    }
-#endif
     return 1;
 }
 
diff --git a/src/d/actor/d_a_e_mf.cpp b/src/d/actor/d_a_e_mf.cpp
index dfc2363049..369c73b21e 100644
--- a/src/d/actor/d_a_e_mf.cpp
+++ b/src/d/actor/d_a_e_mf.cpp
@@ -3264,7 +3264,7 @@ e_mf_class::e_mf_class() {}
 
 AUDIO_INSTANCES;
 
-actor_method_class l_daE_MF_Method = {
+DUSK_GAME_DATA actor_method_class l_daE_MF_Method = {
     (process_method_func)daE_MF_Create,
     (process_method_func)daE_MF_Delete,
     (process_method_func)daE_MF_Execute,
diff --git a/src/d/actor/d_a_e_mk.cpp b/src/d/actor/d_a_e_mk.cpp
index f507177f1d..7484a4b22b 100644
--- a/src/d/actor/d_a_e_mk.cpp
+++ b/src/d/actor/d_a_e_mk.cpp
@@ -21,6 +21,8 @@
 #include "Z2AudioLib/Z2Instances.h"
 #include <cstring>
 
+#include "dusk/version.hpp"
+
 class daE_MK_HIO_c : public JORReflexible {
 public:
     virtual ~daE_MK_HIO_c() {}
@@ -612,8 +614,10 @@ static void e_mk_shoot(e_mk_class* i_this) {
                 i_this->sound.startCreatureVoice(Z2SE_EN_MK_V_CATCH_BOOM, -1);
                 i_this->sound.startCreatureSound(Z2SE_EN_MK_CATCH_BOOM, 0, -1);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+                IF_DUSK_BLOCK(dusk::version::isRegionJpn())
                 return;
+                IF_DUSK_BLOCK_END
 #endif
             }
         }
diff --git a/src/d/actor/d_a_e_mk_bo.cpp b/src/d/actor/d_a_e_mk_bo.cpp
index 950d6cdc56..c3b303cf6f 100644
--- a/src/d/actor/d_a_e_mk_bo.cpp
+++ b/src/d/actor/d_a_e_mk_bo.cpp
@@ -5,12 +5,13 @@
 
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
-#include "d/actor/d_a_e_mk_bo.h"
+#include "Z2AudioLib/Z2Instances.h"
+#include "c/c_damagereaction.h"
 #include "d/actor/d_a_e_mk.h"
+#include "d/actor/d_a_e_mk_bo.h"
 #include "d/actor/d_a_player.h"
 #include "d/d_s_play.h"
-#include "c/c_damagereaction.h"
-#include "Z2AudioLib/Z2Instances.h"
+#include "dusk/version.hpp"
 
 static int daE_MK_BO_Draw(e_mk_bo_class* i_this) {
     if (i_this->field_0x9b4 != 0) {
@@ -569,8 +570,10 @@ static int daE_MK_BO_Execute(e_mk_bo_class* i_this) {
 
     if (i_this->field_0x600 != 0) {
         fopAcM_delete(actor);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+        IF_DUSK_BLOCK(dusk::version::isRegionJpn())
         return 1;
+        IF_DUSK_BLOCK_END
 #endif
     }
 
diff --git a/src/d/actor/d_a_e_mm_mt.cpp b/src/d/actor/d_a_e_mm_mt.cpp
index a3f57ddcf1..782978d801 100644
--- a/src/d/actor/d_a_e_mm_mt.cpp
+++ b/src/d/actor/d_a_e_mm_mt.cpp
@@ -3,9 +3,10 @@
  *
 */
 
-#include "d/dolzel_rel.h" // IWYU pragma: keep
 #include "d/actor/d_a_e_mm_mt.h"
 #include "d/d_cc_d.h"
+#include "d/dolzel_rel.h"  // IWYU pragma: keep
+#include "dusk/version.hpp"
 #include "f_op/f_op_actor_enemy.h"
 
 static int daE_MM_MT_Draw(e_mm_mt_class* i_this) {
@@ -802,7 +803,9 @@ static int daE_MM_MT_Create(fopAc_ac_c* i_this) {
         if (i_this->argument == 1) {
             fopAcM_OffStatus(i_this, 0x80000);
             helmasaurShell->m_sphere.SetAtType(
-                #if VERSION == VERSION_GCN_JPN
+                #if TARGET_PC
+                dusk::version::isRegionJpn() ? AT_TYPE_CSTATUE_SWING : 0xD8FBBDFF
+                #elif VERSION == VERSION_GCN_JPN
                 AT_TYPE_CSTATUE_SWING
                 #else
                 0xD8FBBDFF
diff --git a/src/d/actor/d_a_e_oc.cpp b/src/d/actor/d_a_e_oc.cpp
index fe7aa4c970..57828ccb7c 100644
--- a/src/d/actor/d_a_e_oc.cpp
+++ b/src/d/actor/d_a_e_oc.cpp
@@ -58,17 +58,17 @@ public:
 #endif
 };
 
-f32 const E_OC_n::oc_attackb_trans[10] = {
+DUSK_GAME_DATA f32 const E_OC_n::oc_attackb_trans[10] = {
     0.0f, 0.0f, 0.0f, 0.0f, 15.3f, 
     38.4f, 63.3f, 86.2f, 103.3f, 112.0f
 };
 
-f32 const E_OC_n::oc_attackc_trans[10] = {
+DUSK_GAME_DATA f32 const E_OC_n::oc_attackc_trans[10] = {
     0.0f, 31.3f, 72.7f, 91.5f, 91.5f,
     91.5f, 91.5f, 91.5f, 91.5f, 91.5f
 };
 
-dCcD_SrcSph E_OC_n::cc_sph_src = {
+DUSK_GAME_DATA dCcD_SrcSph E_OC_n::cc_sph_src = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0xD8FBFDFF, 0x3}, 0x75}}, // mObj
         {0x9, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
@@ -80,7 +80,7 @@ dCcD_SrcSph E_OC_n::cc_sph_src = {
     } // mSphAttr
 };
 
-dCcD_SrcSph E_OC_n::at_sph_src = {
+DUSK_GAME_DATA dCcD_SrcSph E_OC_n::at_sph_src = {
     {
         {0x0, {{0x1000, 0x1, 0xD}, {0x0, 0x0}, 0x0}}, // mObj
         {0x9, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
@@ -193,13 +193,13 @@ static int daE_OC_Draw(daE_OC_c* i_this) {
     return i_this->draw();
 }
 
-daE_OC_c* E_OC_n::m_battle_oc;
+DUSK_GAME_DATA daE_OC_c* E_OC_n::m_battle_oc;
 
-daE_OC_c* E_OC_n::m_damage_oc;
+DUSK_GAME_DATA daE_OC_c* E_OC_n::m_damage_oc;
 
-daE_OC_c* E_OC_n::m_death_oc;
+DUSK_GAME_DATA daE_OC_c* E_OC_n::m_death_oc;
 
-daE_OC_c* E_OC_n::m_talk_oc;
+DUSK_GAME_DATA daE_OC_c* E_OC_n::m_talk_oc;
 
 static u8 lbl_216_bss_58;
 
diff --git a/src/d/actor/d_a_e_oct_bg.cpp b/src/d/actor/d_a_e_oct_bg.cpp
index 0a9cc280d4..df181dd23b 100644
--- a/src/d/actor/d_a_e_oct_bg.cpp
+++ b/src/d/actor/d_a_e_oct_bg.cpp
@@ -173,10 +173,10 @@ static int daE_OctBg_Delete(daE_OctBg_c* i_this) {
 
 static daE_OctBg_HIO_c l_HIO;
 
-u8 unk_bss_78;
-u8 unk_bss_79;
-u8 unk_bss_7A;
-u8 unk_bss_7B;
+DUSK_GAME_DATA u8 unk_bss_78;
+DUSK_GAME_DATA u8 unk_bss_79;
+DUSK_GAME_DATA u8 unk_bss_7A;
+DUSK_GAME_DATA u8 unk_bss_7B;
 
 void daE_OctBg_c::cc_set() {
     cXyz cStack_1c;
diff --git a/src/d/actor/d_a_e_pm.cpp b/src/d/actor/d_a_e_pm.cpp
index 8c68907f15..2cf0341172 100644
--- a/src/d/actor/d_a_e_pm.cpp
+++ b/src/d/actor/d_a_e_pm.cpp
@@ -19,6 +19,7 @@
 #include "d/actor/d_a_obj_smw_stone.h"
 #include "f_op/f_op_actor_enemy.h"
 #include "f_op/f_op_camera_mng.h"
+#include "dusk/version.hpp"
 
 class daE_PM_HIO_c {
 public:
@@ -816,10 +817,12 @@ void daE_PM_c::DemoBeforeEscape() {
             for (int i = 0; i < 4; i++) {
                 e_fs_class* puppet;
                 if (fopAcM_SearchByID(mPuppetID[i], (fopAc_ac_c**)&puppet)) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+                    IF_DUSK_BLOCK(dusk::version::isRegionJpn())
                     if (puppet == NULL) {
                         continue;
                     }
+                    IF_DUSK_BLOCK_END
 #endif
                     puppet->mAction = e_fs_class::ACT_END;
                     puppet->mMode = 0;
diff --git a/src/d/actor/d_a_e_po.cpp b/src/d/actor/d_a_e_po.cpp
index 1c4e95fa61..112ad2d56f 100644
--- a/src/d/actor/d_a_e_po.cpp
+++ b/src/d/actor/d_a_e_po.cpp
@@ -7,6 +7,9 @@
 
 #include "d/actor/d_a_e_po.h"
 #include "d/actor/d_a_obj_poFire.h"
+#if TARGET_PC
+#include "d/actor/d_a_alink.h"
+#endif
 #include "d/d_cc_d.h"
 #include "d/d_cc_uty.h"
 #include "f_op/f_op_actor_enemy.h"
@@ -1132,12 +1135,14 @@ static void e_po_dead(e_po_class* i_this) {
             camera_player->mCamera.Start();
             camera_player->mCamera.SetTrimSize(0);
             dComIfGp_event_reset();
+#if !TARGET_PC
             dComIfGs_addPohSpiritNum();
 #if !PLATFORM_SHIELD
             if (dComIfGs_getPohSpiritNum() == 0x14) {
                 /* dSv_event_flag_c::F_0457 - Castle Town - Revived cat */
                 dComIfGs_onEventBit(dSv_event_flag_c::saveBitLabels[457]);
             }
+#endif
 #endif
             daPy_getPlayerActorClass()->cancelOriginalDemo();
         } else if (mArg0Check(i_this, 0) != 0) {
@@ -1265,8 +1270,21 @@ static void e_po_dead(e_po_class* i_this) {
             }
         } else {
             if (i_this->field_0x75C == -1) {
+#if TARGET_PC
+                const auto itemCheck = dusk::mods::item_check_commit(
+                    dusk::mods::item_give_tag_poe(i_this->BitSW), dItemNo_POU_SPIRIT_e, a_this);
+                if (itemCheck.itemNo == dItemNo_NONE_e) {
+                    dusk::mods::item_check_complete(itemCheck, a_this);
+                    i_this->field_0x75B = 1;
+                } else {
+                    i_this->field_0x75C = fopAcM_createItemForPresentDemo(
+                        &a_this->current.pos, itemCheck.itemNo, 0, -1, -1, NULL, NULL,
+                        itemCheck.tag);
+                }
+#else
                 i_this->field_0x75C = fopAcM_createItemForPresentDemo(&a_this->current.pos, 0xE0, 0,
                                                                       -1, -1, NULL, NULL);
+#endif
             }
             if (fopAcM_IsExecuting(i_this->field_0x75C)) {
                 i_this->field_0x762 =
diff --git a/src/d/actor/d_a_e_rdb.cpp b/src/d/actor/d_a_e_rdb.cpp
index 7eccf34ef5..0e6fbbdafd 100644
--- a/src/d/actor/d_a_e_rdb.cpp
+++ b/src/d/actor/d_a_e_rdb.cpp
@@ -16,6 +16,10 @@
 #include "f_op/f_op_camera_mng.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "mods/items.h"
+#endif
+
 class daE_RDB_HIO_c : public JORReflexible {
 public:
     daE_RDB_HIO_c();
@@ -1250,7 +1254,18 @@ static void demo_camera(e_rdb_class* i_this) {
             }
 
             if (iVar1 != 0) {
-                daPy_getPlayerActorClass()->changeDemoMode(11, 32, 0, 0);
+#if TARGET_PC
+                const auto itemCheck = dusk::mods::item_check_commit(
+                    ITEM_CHECK_BULBLIN_KEY, dItemNo_SMALL_KEY_e, &i_this->enemy);
+                if (itemCheck.itemNo == dItemNo_NONE_e) {
+                    dusk::mods::item_check_complete(itemCheck, &i_this->enemy);
+                }
+                daPy_getPlayerActorClass()->changeDemoMode(
+                    11, itemCheck.itemNo == dItemNo_NONE_e ? 0 : itemCheck.itemNo,
+                    itemCheck.itemNo == dItemNo_NONE_e ? 0 : static_cast<int>(itemCheck.tag), 0);
+#else
+                daPy_getPlayerActorClass()->changeDemoMode(11, dItemNo_SMALL_KEY_e, 0, 0);
+#endif
                 i_this->mDemoMode = 12;
                 i_this->field_0x10aa = 0;
                 i_this->field_0xfe5 = 1;
diff --git a/src/d/actor/d_a_e_s1.cpp b/src/d/actor/d_a_e_s1.cpp
index cd48a103e1..3c7c6700e5 100644
--- a/src/d/actor/d_a_e_s1.cpp
+++ b/src/d/actor/d_a_e_s1.cpp
@@ -14,8 +14,6 @@
 #include "d/d_s_play.h"
 #include "f_op/f_op_actor_enemy.h"
 #include "f_op/f_op_camera_mng.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
 #include <cstring>
 
 class daE_S1_HIO_c {
@@ -101,32 +99,6 @@ static void anm_init(e_s1_class* i_this, int i_resNo, f32 i_morf, u8 i_attr, f32
     i_this->mAnm = i_resNo;
 }
 
-#if TARGET_PC
-static void daE_S1_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_s1_class* i_this = (e_s1_class*)pUserWork;
-    if (!i_this->mHairInterpPrevValid || !i_this->mHairInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    for (int s = 0; s < e_s1_class::HAIR_STRAND_COUNT; s++) {
-        cXyz* dst = i_this->mLineMat.getPos(s);
-        for (int i = 0; i < e_s1_class::HAIR_SEGMENT_COUNT; i++) {
-            int idx = s * e_s1_class::HAIR_SEGMENT_COUNT + i;
-            const cXyz& p0 = i_this->mHairInterpPrev[idx];
-            const cXyz& p1 = i_this->mHairInterpCurr[idx];
-            dst[i] = p0 + (p1 - p0) * alpha;
-        }
-    }
-    GXColor line_color;
-    line_color.r = JREG_S(0) + 5;
-    line_color.g = JREG_S(1) + 10;
-    line_color.b = JREG_S(2) + 10;
-    line_color.a = 0xFF;
-
-    i_this->mLineMat.update(16, line_color, &i_this->tevStr);
-}
-#endif
-
 static int daE_S1_Draw(e_s1_class* i_this) {
     if (i_this->field_0x306c != 0) {
         return 1;
@@ -160,22 +132,6 @@ static int daE_S1_Draw(e_s1_class* i_this) {
     i_this->mLineMat.update(16, line_color, &i_this->tevStr);
     dComIfGd_set3DlineMatDark(&i_this->mLineMat);
 
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mHairInterpCurrValid) {
-            memcpy(i_this->mHairInterpPrev, i_this->mHairInterpCurr, sizeof(i_this->mHairInterpCurr));
-            i_this->mHairInterpPrevValid = true;
-        }
-        for (int s = 0; s < e_s1_class::HAIR_STRAND_COUNT; s++) {
-            cXyz* src = i_this->mLineMat.getPos(s);
-            memcpy(&i_this->mHairInterpCurr[s * e_s1_class::HAIR_SEGMENT_COUNT], src,
-                   e_s1_class::HAIR_SEGMENT_COUNT * sizeof(cXyz));
-        }
-        i_this->mHairInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&daE_S1_interp_callback, i_this);
-    }
-#endif
-
     dComIfGd_setList();
     return 1;
 }
@@ -2193,11 +2149,6 @@ static int daE_S1_Create(fopAc_ac_c* i_this) {
             return cPhs_ERROR_e;
         }
 
-#if TARGET_PC
-        a_this->mHairInterpPrevValid = false;
-        a_this->mHairInterpCurrValid = false;
-#endif
-
         OS_REPORT("//////////////E_S1 SET 2 !!\n");
 
         if (path_no != 0xFF) {
diff --git a/src/d/actor/d_a_e_sm2.cpp b/src/d/actor/d_a_e_sm2.cpp
index 808301527e..96f718ce0b 100644
--- a/src/d/actor/d_a_e_sm2.cpp
+++ b/src/d/actor/d_a_e_sm2.cpp
@@ -15,7 +15,7 @@
 #include <cstring>
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 #endif
 
 class daE_SM2_HIO_c : public fOpAcm_HIO_entry_c {
@@ -81,7 +81,7 @@ static int nodeCallBack(J3DJoint* i_joint, int param_1) {
 }
 
 #if TARGET_PC
-static void daE_SM2_interp_callback(bool isSimFrame, void* pUserWork) {
+static void daE_SM2_interp_callback(void* pUserWork) {
     e_sm2_class* i_this = static_cast<e_sm2_class*>(pUserWork);
     if (i_this == NULL) {
         return;
@@ -133,7 +133,7 @@ static int daE_SM2_Draw(e_sm2_class* i_this) {
     fopAc_ac_c* actor = (fopAc_ac_c*)&i_this->enemy;
 
 #if TARGET_PC
-    dusk::frame_interp::add_interpolation_callback(&daE_SM2_interp_callback, i_this);
+    dusk::interp::add_interpolation_callback(&daE_SM2_interp_callback, i_this);
 #endif
 
     g_env_light.settingTevStruct(0, &actor->current.pos, &actor->tevStr);
diff --git a/src/d/actor/d_a_e_th_ball.cpp b/src/d/actor/d_a_e_th_ball.cpp
index e9be033af2..fcb87ada24 100644
--- a/src/d/actor/d_a_e_th_ball.cpp
+++ b/src/d/actor/d_a_e_th_ball.cpp
@@ -931,7 +931,9 @@ static void get_demo(e_th_ball_class* i_this) {
     case 0:
         break;
     case 1:
-        demo_id = fopAcM_createItemForTrBoxDemo(&i_this->current.pos, dItemNo_IRONBALL_e, -1, fopAcM_GetRoomNo(i_this), NULL, NULL);
+        demo_id = fopAcM_createItemForTrBoxDemo(&i_this->current.pos,
+            DUSK_ITEM_CHECK_EXPR("ball_and_chain:D_MN11", dItemNo_IRONBALL_e, i_this), -1,
+            fopAcM_GetRoomNo(i_this), NULL, NULL DUSK_GIVE_TAG("ball_and_chain:D_MN11"));
         JUT_ASSERT(1670, demo_id != fpcM_ERROR_PROCESS_ID_e);
         i_this->mDemoMode = 2;
         break;
diff --git a/src/d/actor/d_a_e_wb.cpp b/src/d/actor/d_a_e_wb.cpp
index b5a38eff65..cf9e4ccbf7 100644
--- a/src/d/actor/d_a_e_wb.cpp
+++ b/src/d/actor/d_a_e_wb.cpp
@@ -18,10 +18,12 @@
 #include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_graphic.h"
 #include "res/Object/Always.h"
-#include "dusk/dusk.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/dusk.h"
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 class daE_WB_HIO_c : public JORReflexible {
 public:
@@ -186,30 +188,6 @@ static bool hio_set;
 
 static daE_WB_HIO_c l_HIO;
 
-#if TARGET_PC
-static void e_wb_rein_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_wb_class* i_this = (e_wb_class*)pUserWork;
-    if (!i_this->himo_interp_prev_valid || !i_this->himo_interp_curr_valid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    for (int r = 0; r < 2; r++) {
-        cXyz* dst = i_this->himo_mat[r].getPos(0);
-        for (int i = 0; i < 16; i++) {
-            const cXyz& p0 = i_this->himo_mat_interp_prev[r][i];
-            const cXyz& p1 = i_this->himo_mat_interp_curr[r][i];
-            dst[i] = p0 + (p1 - p0) * alpha;
-        }
-    }
-    cXyz* dst = i_this->himo_tex.getPos(0);
-    for (int i = 0; i < 2; i++) {
-        const cXyz& p0 = i_this->himo_tex_interp_prev[i];
-        const cXyz& p1 = i_this->himo_tex_interp_curr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static void himo_control1(e_wb_class* i_this, cXyz* i_pos, int i_no, s8 param_3) {
     fopEn_enemy_c* enemy = &i_this->enemy;
     cXyz mae, ato;
@@ -534,21 +512,6 @@ static int daE_WB_Draw(e_wb_class* i_this) {
         dComIfGd_set3DlineMat(&i_this->himo_mat[1]);
         i_this->himo_tex.update(2, l_color, &actor->tevStr);
         dComIfGd_set3DlineMat(&i_this->himo_tex);
-#if TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
-            if (i_this->himo_interp_curr_valid) {
-                memcpy(i_this->himo_mat_interp_prev, i_this->himo_mat_interp_curr, sizeof(i_this->himo_mat_interp_curr));
-                memcpy(i_this->himo_tex_interp_prev, i_this->himo_tex_interp_curr, sizeof(i_this->himo_tex_interp_curr));
-                i_this->himo_interp_prev_valid = true;
-            }
-            for (int r = 0; r < 2; r++) {
-                memcpy(i_this->himo_mat_interp_curr[r], i_this->himo_mat[r].getPos(0), 16 * sizeof(cXyz));
-            }
-            memcpy(i_this->himo_tex_interp_curr, i_this->himo_tex.getPos(0), 2 * sizeof(cXyz));
-            i_this->himo_interp_curr_valid = true;
-            dusk::frame_interp::add_interpolation_callback(&e_wb_rein_interp_callback, i_this);
-        }
-#endif
     }
 
     return 1;
@@ -4542,9 +4505,7 @@ static void demo_camera(e_wb_class* i_this) {
             i_this->demo_cam_way_spd.z = fabsf(i_this->demo_cam_way.z - i_this->demo_cam_ctr.z);
             i_this->demo_cam_morf = 0;
             pla->setPlayerPosAndAngle(&pla->current.pos, pla->shape_angle.y - 4000, 0);
-#if TARGET_PC
-            dusk::frame_interp::request_presentation_sync();
-#endif
+            IF_DUSK(dusk::interp::request_presentation_sync());
         }
         if (i_this->demo_timer == 345) {
             daPy_getPlayerActorClass()->setThrowDamage(boss->enemy.shape_angle.y - 8000 + TREG_S(8),
@@ -4791,9 +4752,7 @@ static void demo_camera(e_wb_class* i_this) {
                     i_this->demo_cam_eye.x += 300.0f + VREG_F(8);
                     i_this->demo_cam_eye.y += 150.0f + VREG_F(9);
                     i_this->demo_cam_eye.z -= 1400.0f + VREG_F(10);
-#if TARGET_PC
-                    dusk::frame_interp::request_presentation_sync();
-#endif
+                    IF_DUSK(dusk::interp::request_presentation_sync());
                 }
             } else {
                 i_this->demo_cam_eye = enemy->current.pos;
@@ -5054,7 +5013,7 @@ static void demo_camera(e_wb_class* i_this) {
         i_this->demo_cam_sync_ticks = 2;
     }
     if (i_this->demo_cam_sync_ticks > 0) {
-        dusk::frame_interp::request_presentation_sync();
+        dusk::interp::request_presentation_sync();
         i_this->demo_cam_sync_ticks--;
     }
 #endif
diff --git a/src/d/actor/d_a_e_yd.cpp b/src/d/actor/d_a_e_yd.cpp
index 52a5be7fdc..bdc7c527e2 100644
--- a/src/d/actor/d_a_e_yd.cpp
+++ b/src/d/actor/d_a_e_yd.cpp
@@ -12,10 +12,6 @@
 #include "d/d_cc_uty.h"
 #include "f_op/f_op_actor_enemy.h"
 
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#endif
-
 class daE_YD_HIO_c {
 public:
     daE_YD_HIO_c();
@@ -77,22 +73,6 @@ static s32 leaf_anm_init(e_yd_class* i_this, int param_1, f32 param_2, u8 param_
     return false;
 }
 
-#if TARGET_PC
-static void daE_YD_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_yd_class* i_this = (e_yd_class*)pUserWork;
-    if (!i_this->mLineMatInterpPrevValid || !i_this->mLineMatInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    cXyz* dst = i_this->mLineMat.getPos(0);
-    for (int i = 0; i < 12; i++) {
-        const cXyz& p0 = i_this->mLineMatInterpPrev[i];
-        const cXyz& p1 = i_this->mLineMatInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static s32 daE_YD_Draw(e_yd_class* i_this) {
     static GXColor l_color = { 0x14, 0x0F, 0x00, 0xFF };
 
@@ -106,17 +86,6 @@ static s32 daE_YD_Draw(e_yd_class* i_this) {
     i_this->mpMorf->entryDL();
     i_this->mLineMat.update(12, l_color, &i_this->actor.tevStr);
     dComIfGd_set3DlineMat(&i_this->mLineMat);
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mLineMatInterpCurrValid) {
-            memcpy(i_this->mLineMatInterpPrev, i_this->mLineMatInterpCurr, sizeof(i_this->mLineMatInterpCurr));
-            i_this->mLineMatInterpPrevValid = true;
-        }
-        memcpy(i_this->mLineMatInterpCurr, i_this->mLineMat.getPos(0), 12 * sizeof(cXyz));
-        i_this->mLineMatInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&daE_YD_interp_callback, i_this);
-    }
-#endif
     for (s32 i = 1; i < 11; i++) {
         if (i_this->field_0x77c[i] != 0) {
             g_env_light.setLightTevColorType_MAJI(i_this->field_0x77c[i], &i_this->actor.tevStr);
diff --git a/src/d/actor/d_a_e_yg.cpp b/src/d/actor/d_a_e_yg.cpp
index 71756d6f57..e6bcd05098 100644
--- a/src/d/actor/d_a_e_yg.cpp
+++ b/src/d/actor/d_a_e_yg.cpp
@@ -10,8 +10,6 @@
 #include "f_op/f_op_kankyo_mng.h"
 #include "d/actor/d_a_obj_carry.h"
 #include "Z2AudioLib/Z2Instances.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
 #include "f_op/f_op_actor_enemy.h"
 
 enum E_yg_RES_File_ID {
@@ -136,33 +134,6 @@ static BOOL pl_check(e_yg_class* i_this, f32 i_dist) {
     return FALSE;
 }
 
-#if TARGET_PC
-static void daE_YG_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_yg_class* i_this = (e_yg_class*)pUserWork;
-    fopAc_ac_c* actor = (fopAc_ac_c*)&i_this->actor;
-    if (!i_this->mTentacleInterpPrevValid || !i_this->mTentacleInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    for (int s = 0; s < e_yg_class::TENTACLE_STRAND_COUNT; s++) {
-        cXyz* dst = i_this->mLineMat.getPos(s);
-        for (int i = 0; i < e_yg_class::TENTACLE_SEGMENT_COUNT; i++) {
-            int idx = s * e_yg_class::TENTACLE_SEGMENT_COUNT + i;
-            const cXyz& p0 = i_this->mTentacleInterpPrev[idx];
-            const cXyz& p1 = i_this->mTentacleInterpCurr[idx];
-            dst[i] = p0 + (p1 - p0) * alpha;
-        }
-    }
-    GXColor color;
-    color.r = JREG_S(0) + 20;
-    color.g = JREG_S(1) + 20;
-    color.b = JREG_S(2) + 20;
-    color.a = 0xFF;
-
-    i_this->mLineMat.update(10, color, &actor->tevStr);
-}
-#endif
-
 static int daE_YG_Draw(e_yg_class* i_this) {
     if (i_this->mDispFlag) {
         return 1;
@@ -190,22 +161,6 @@ static int daE_YG_Draw(e_yg_class* i_this) {
     i_this->mLineMat.update(10, color, &actor->tevStr);
     dComIfGd_set3DlineMatDark(&i_this->mLineMat);
 
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mTentacleInterpCurrValid) {
-            memcpy(i_this->mTentacleInterpPrev, i_this->mTentacleInterpCurr, sizeof(i_this->mTentacleInterpCurr));
-            i_this->mTentacleInterpPrevValid = true;
-        }
-        for (int s = 0; s < e_yg_class::TENTACLE_STRAND_COUNT; s++) {
-            cXyz* src = i_this->mLineMat.getPos(s);
-            memcpy(&i_this->mTentacleInterpCurr[s * e_yg_class::TENTACLE_SEGMENT_COUNT], src,
-                   e_yg_class::TENTACLE_SEGMENT_COUNT * sizeof(cXyz));
-        }
-        i_this->mTentacleInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&daE_YG_interp_callback, i_this);
-    }
-#endif
-
     dComIfGd_setList();
 
     return 1;
@@ -1424,11 +1379,6 @@ static cPhs_Step daE_YG_Create(fopAc_ac_c* actor) {
             return cPhs_ERROR_e;
         }
 
-#if TARGET_PC
-        i_this->mTentacleInterpPrevValid = false;
-        i_this->mTentacleInterpCurrValid = false;
-#endif
-
         if (!hio_set) {
             i_this->mIsFirstSpawn = 1;
             hio_set = true;
diff --git a/src/d/actor/d_a_e_yh.cpp b/src/d/actor/d_a_e_yh.cpp
index fb00a4bab1..55f175d78e 100644
--- a/src/d/actor/d_a_e_yh.cpp
+++ b/src/d/actor/d_a_e_yh.cpp
@@ -12,10 +12,6 @@
 #include "f_op/f_op_actor_enemy.h"
 #include "f_op/f_op_kankyo_mng.h"
 
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#endif
-
 class daE_YH_HIO_c : public JORReflexible {
 public:
     daE_YH_HIO_c();
@@ -89,22 +85,6 @@ static BOOL leaf_anm_init(e_yh_class* i_this, int param_2, f32 param_3, u8 param
     return FALSE;
 }
 
-#if TARGET_PC
-static void daE_YH_interp_callback(bool isSimFrame, void* pUserWork) {
-    e_yh_class* i_this = (e_yh_class*)pUserWork;
-    if (!i_this->mLineInterpPrevValid || !i_this->mLineInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    cXyz* dst = i_this->mLine.getPos(0);
-    for (int i = 0; i < 12; i++) {
-        const cXyz& p0 = i_this->mLineInterpPrev[i];
-        const cXyz& p1 = i_this->mLineInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 static int daE_YH_Draw(e_yh_class* i_this) {
     fopAc_ac_c* a_this = (fopAc_ac_c*)i_this;
 
@@ -134,17 +114,6 @@ static int daE_YH_Draw(e_yh_class* i_this) {
 
     i_this->mLine.update(12, l_color, &a_this->tevStr);
     dComIfGd_set3DlineMat(&i_this->mLine);
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mLineInterpCurrValid) {
-            memcpy(i_this->mLineInterpPrev, i_this->mLineInterpCurr, sizeof(i_this->mLineInterpCurr));
-            i_this->mLineInterpPrevValid = true;
-        }
-        memcpy(i_this->mLineInterpCurr, i_this->mLine.getPos(0), 12 * sizeof(cXyz));
-        i_this->mLineInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&daE_YH_interp_callback, i_this);
-    }
-#endif
 
     for (int i = 1; i < 11; i++) {
         if (i_this->mModels[i] != NULL) {
diff --git a/src/d/actor/d_a_e_ym.cpp b/src/d/actor/d_a_e_ym.cpp
index 39c1e0d360..7c96e289ee 100644
--- a/src/d/actor/d_a_e_ym.cpp
+++ b/src/d/actor/d_a_e_ym.cpp
@@ -35,7 +35,7 @@ public:
     /* 0x20 */ f32 mMoveRange;
 };
 
-dCcD_SrcSph E_YM_n::cc_sph_src = {
+DUSK_GAME_DATA dCcD_SrcSph E_YM_n::cc_sph_src = {
     {
         {0, {{0x400, 1, 13}, {0xD8FBFDFF, 3}, 0x75}},
         {dCcD_SE_METAL, 0, 0, 0, {0}},
diff --git a/src/d/actor/d_a_econt.cpp b/src/d/actor/d_a_econt.cpp
index 2bd075c123..7a242add0f 100644
--- a/src/d/actor/d_a_econt.cpp
+++ b/src/d/actor/d_a_econt.cpp
@@ -10,7 +10,7 @@
 #include "d/d_meter2_info.h"
 #include "f_pc/f_pc_executor.h"
 
-u8 data_805197E0[4];
+DUSK_GAME_DATA u8 data_805197E0[4];
 
 static int daEcont_Draw(econt_class* i_this) {
     return 1;
diff --git a/src/d/actor/d_a_formation_mng.cpp b/src/d/actor/d_a_formation_mng.cpp
index 3e625ebb07..4512826412 100644
--- a/src/d/actor/d_a_formation_mng.cpp
+++ b/src/d/actor/d_a_formation_mng.cpp
@@ -9,7 +9,7 @@
 #include "d/d_save.h"
 #include "f_op/f_op_actor_mng.h"
 
-FmtMngAttributes const daFmtMng_c::M_attr = {
+DUSK_GAME_DATA FmtMngAttributes const daFmtMng_c::M_attr = {
     0x14, 6.0f, 0.5f,
     120.0f, 150.0f, 10, 0x4000,
 };
@@ -62,7 +62,7 @@ void daFmtMng_c::initMemberPos() {
     }
 }
 
-daFmtMng_c::ActionFunc daFmtMng_c::ActionTable[10] = {
+DUSK_GAME_DATA daFmtMng_c::ActionFunc daFmtMng_c::ActionTable[10] = {
     &daFmtMng_c::initWait, &daFmtMng_c::executeWait,
     &daFmtMng_c::initWalk, &daFmtMng_c::executeWalk,
     &daFmtMng_c::initReverse, &daFmtMng_c::executeReverse,
diff --git a/src/d/actor/d_a_horse.cpp b/src/d/actor/d_a_horse.cpp
index dbbd7f0fba..b738460bb8 100644
--- a/src/d/actor/d_a_horse.cpp
+++ b/src/d/actor/d_a_horse.cpp
@@ -20,23 +20,6 @@
 #include <cmath>
 #include <cstring>
 
-#if TARGET_PC
-#include "dusk/dusk.h"
-#include "dusk/frame_interpolation.h"
-
-namespace {
-// FRAME INTERP NOTE: Sim tick control point snapshots for interpolation
-constexpr int kHorseReinSimMax = 75;
-cXyz s_horseReinSimPrev[kHorseReinSimMax];
-cXyz s_horseReinSimCurr[kHorseReinSimMax];
-int s_horseReinSimNumPrev;
-int s_horseReinSimNumCurr;
-bool s_horseReinSimPrevValid;
-bool s_horseReinSimCurrValid;
-uint64_t s_horseReinSimRolledSeq;
-}  // namespace
-#endif
-
 #define ANM_HS_BACK_WALK           6
 #define ANM_HS_WALK_START          7
 #define ANM_HS_EXCITEMENT          8
@@ -76,11 +59,11 @@ static void strippedFunc() {
 
 static char const l_arcName[] = "Horse";
 
-const u16 daHorse_c::m_footJointTable[] = {
+DUSK_GAME_DATA const u16 daHorse_c::m_footJointTable[] = {
     3, 7, 27, 31,
 };
 
-const f32 daHorse_c::m_callLimitDistance2 = 640000.0f;
+DUSK_GAME_DATA const f32 daHorse_c::m_callLimitDistance2 = 640000.0f;
 
 static f32 l_autoUpHeight = 50.0f;
 
@@ -170,7 +153,7 @@ void daHorse_hio_c::genMessage(JORMContext* ctx) {
 }
 #endif
 
-const daHorse_hio_c1 daHorse_hio_c0::m = {
+DUSK_GAME_DATA const daHorse_hio_c1 daHorse_hio_c0::m = {
     600,
     50,
     45,
@@ -3033,24 +3016,6 @@ void daHorse_c::copyReinPos() {
     for (i = rein->field_0x8[0] - 1; i >= 0; i--, pos_p++) {
         *pos_p = rein->field_0x0[0][i];
     }
-#if TARGET_PC
-    if (field_0x1204 > 0) {
-        const uint64_t simSeq = dusk::frame_interp::sim_tick_seq();
-        if (simSeq != s_horseReinSimRolledSeq) {
-            s_horseReinSimRolledSeq = simSeq;
-            if (s_horseReinSimCurrValid && s_horseReinSimNumCurr > 0) {
-                memcpy(s_horseReinSimPrev, s_horseReinSimCurr, s_horseReinSimNumCurr * sizeof(cXyz));
-                s_horseReinSimNumPrev = s_horseReinSimNumCurr;
-                s_horseReinSimPrevValid = true;
-            }
-        }
-        memcpy(s_horseReinSimCurr, m_reinLine.getPos(0), field_0x1204 * sizeof(cXyz));
-        s_horseReinSimNumCurr = field_0x1204;
-        s_horseReinSimCurrValid = true;
-    } else {
-        s_horseReinSimCurrValid = false;
-    }
-#endif
 }
 
 void daHorse_c::setReinPosHandSubstance(int param_0) {
@@ -3162,30 +3127,6 @@ void daHorse_c::setReinPosNormalSubstance() {
     copyReinPos();
 }
 
-#if TARGET_PC
-void daHorse_c::lerpControlPoints(f32 alpha) {
-    // FRAME INTERP NOTE: Currently only lerping points for Epona's reins. Need a more global solution.
-    if (!dusk::frame_interp::is_enabled() || !s_horseReinSimPrevValid || !s_horseReinSimCurrValid) {
-        return;
-    }
-    const int nCurr = s_horseReinSimNumCurr;
-    const int nPrev = s_horseReinSimNumPrev;
-    if (nCurr <= 0) {
-        return;
-    }
-    int n = nPrev < nCurr ? nPrev : nCurr;
-    if (n <= 0 || n > kHorseReinSimMax) {
-        return;
-    }
-    cXyz* dst = m_reinLine.getPos(0);
-    for (int i = 0; i < n; i++) {
-        const cXyz& p0 = s_horseReinSimPrev[i];
-        const cXyz& p1 = s_horseReinSimCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 void daHorse_c::bgCheck() {
     if (m_procID != PROC_LARGE_DAMAGE_e) {
         static DUSK_CONSTEXPR cXyz localCenterPos(0.0f, 100.0f, 0.0f);
diff --git a/src/d/actor/d_a_hozelda.cpp b/src/d/actor/d_a_hozelda.cpp
index 34f8f3c9c9..dfc9ba038c 100644
--- a/src/d/actor/d_a_hozelda.cpp
+++ b/src/d/actor/d_a_hozelda.cpp
@@ -31,7 +31,7 @@ static void* daHoZelda_searchGanon(fopAc_ac_c* i_actor, void* i_data) {
     return NULL;
 }
 
-const daHoZelda_hio_c1 daHoZelda_hio_c0::m = {
+DUSK_GAME_DATA const daHoZelda_hio_c1 daHoZelda_hio_c0::m = {
     0x38E,
     0x2AAA,
     0x4000,
@@ -40,8 +40,8 @@ const daHoZelda_hio_c1 daHoZelda_hio_c0::m = {
     4000.0f,
 };
 
-u8 daHoZelda_matAnm_c::mEyeMoveFlg;
-u8 daHoZelda_matAnm_c::mMorfFrame;
+DUSK_GAME_DATA u8 daHoZelda_matAnm_c::mEyeMoveFlg;
+DUSK_GAME_DATA u8 daHoZelda_matAnm_c::mMorfFrame;
 
 void daHoZelda_matAnm_c::init() {
     field_0xf4 = 0.0f;
diff --git a/src/d/actor/d_a_itembase.cpp b/src/d/actor/d_a_itembase.cpp
index 084fb5221f..474b03c784 100644
--- a/src/d/actor/d_a_itembase.cpp
+++ b/src/d/actor/d_a_itembase.cpp
@@ -242,21 +242,21 @@ BOOL daItemBase_c::chkFlag(int i_flag) {
 }
 
 s8 daItemBase_c::getTevFrm() {
-    return dItem_data::getTevFrm(m_itemNo);
+    return dItem_data::getTevFrm(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo));
 }
 
 s8 daItemBase_c::getBtpFrm() {
-    return dItem_data::getBtpFrm(m_itemNo);
+    return dItem_data::getBtpFrm(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo));
 }
 
 u8 daItemBase_c::getShadowSize() {
-    return dItem_data::getShadowSize(m_itemNo);
+    return dItem_data::getShadowSize(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo));
 }
 
 u8 daItemBase_c::getCollisionH() {
-    return dItem_data::getH(m_itemNo);
+    return dItem_data::getH(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo));
 }
 
 u8 daItemBase_c::getCollisionR() {
-    return dItem_data::getR(m_itemNo);
+    return dItem_data::getR(DUSK_IF_ELSE(getDisplayItemNo(), m_itemNo));
 }
diff --git a/src/d/actor/d_a_mant.cpp b/src/d/actor/d_a_mant.cpp
index 956bd6cc72..4f175e794f 100644
--- a/src/d/actor/d_a_mant.cpp
+++ b/src/d/actor/d_a_mant.cpp
@@ -11,16 +11,55 @@
 #include "d/d_com_inf_game.h"
 
 #if TARGET_PC
-#include <aurora/texture.hpp>
 #include "dusk/dvd_asset.hpp"
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 
-using GameVersion = dusk::version::GameVersion;
+#include <aurora/texture.hpp>
+
+#include <type_traits>
+
+using namespace dusk::version;
+
+#define MANT_REL_PATH platformSelect<const char*>("/rel/Final/Release/d_a_mant.rel", "/rel/Rfinal/Release/d_a_mant.rel")
+
+#define DEFINE_MANT_ASSET(name, type, count, ...)                                                  \
+    static type* name##_get() {                                                                    \
+        alignas(32) static std::remove_cv_t<type> buf[count];                                      \
+        static bool _ = (dusk::LoadRelAsset(buf, MANT_REL_PATH, __VA_ARGS__), true);               \
+        return buf;                                                                                \
+    }
 
 // keep the original version of the cape texture const so we don't need to reload the file
-static u8 const * l_Egnd_mantTEX_get()   { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x1C00}, {GameVersion::GcnPal, 0x1C00}}, 0x4000), true); return buf; }
-static u8* l_Egnd_mantTEX_U_get() { alignas(32) static u8 buf[0x4000]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x5C00}, {GameVersion::GcnPal, 0x5C00}}, 0x4000), true); return buf; }
-static u8* l_Egnd_mantPAL_get()   { alignas(32) static u8 buf[0x60];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x9C00}, {GameVersion::GcnPal, 0x9C00}}, 0x60),   true); return buf; }
+DEFINE_MANT_ASSET(l_Egnd_mantTEX, u8 const, 0x4000, {
+    {GameVersion::GcnUsa,     0x1C00},
+    {GameVersion::GcnPal,     0x1C00},
+    {GameVersion::GcnJpn,     0x1C00},
+    {GameVersion::WiiUsaRev0, 0x1B00},
+    {GameVersion::WiiUsa,     0x1900},
+    {GameVersion::WiiPal,     0x1900},
+    {GameVersion::WiiJpn,     0x1900},
+});
+
+DEFINE_MANT_ASSET(l_Egnd_mantTEX_U, u8, 0x4000, {
+    {GameVersion::GcnUsa,     0x5C00},
+    {GameVersion::GcnPal,     0x5C00},
+    {GameVersion::GcnJpn,     0x5C00},
+    {GameVersion::WiiUsaRev0, 0x5B00},
+    {GameVersion::WiiUsa,     0x5900},
+    {GameVersion::WiiPal,     0x5900},
+    {GameVersion::WiiJpn,     0x5900},
+});
+
+DEFINE_MANT_ASSET(l_Egnd_mantPAL, u8, 0x60, {
+    {GameVersion::GcnUsa,     0x9C00},
+    {GameVersion::GcnPal,     0x9C00},
+    {GameVersion::GcnJpn,     0x9C00},
+    {GameVersion::WiiUsaRev0, 0x9B00},
+    {GameVersion::WiiUsa,     0x9900},
+    {GameVersion::WiiPal,     0x9900},
+    {GameVersion::WiiJpn,     0x9900},
+});
+
 #define l_Egnd_mantTEX   (l_Egnd_mantTEX_get())
 #define l_Egnd_mantTEX_U (l_Egnd_mantTEX_U_get())
 #define l_Egnd_mantPAL   (l_Egnd_mantPAL_get())
@@ -35,14 +74,39 @@ static TGXTexObj mainTexObj;
 static TGXTexObj undersideTexObj;
 
 // l_pos is unused
-//static f32* l_pos_get()      { alignas(32) static f32 buf[507];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0xA44C}, {GameVersion::GcnPal, 0xA44C}}, sizeof(buf)),   true); return buf; }
-static f32* l_normal_get()   { alignas(32) static f32 buf[3];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0x9C60}, {GameVersion::GcnPal, 0x9C60}}, sizeof(buf)),   true); return buf; }
-static f32* l_texCoord_get() { alignas(32) static f32 buf[338];   static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0xA458}, {GameVersion::GcnPal, 0xA458}}, sizeof(buf)),   true); return buf; }
-//#define l_pos      (l_pos_get())
-#define l_normal   (l_normal_get())
+// DEFINE_MANT_ASSET(l_pos, f32, 507, {
+//     {GameVersion::GcnUsa, 0x9C60},
+//     {GameVersion::GcnPal, 0x9C60},
+// });
+
+alignas(32) static f32 const l_normal[3] = {0.0f, 1.0f, 0.0f};
+
+DEFINE_MANT_ASSET(l_texCoord, f32, 338, {
+    {GameVersion::GcnUsa,     0xA458},
+    {GameVersion::GcnPal,     0xA458},
+    {GameVersion::GcnJpn,     0xA458},
+    {GameVersion::WiiUsaRev0, 0x9B60},
+    {GameVersion::WiiUsa,     0x9960},
+    {GameVersion::WiiPal,     0x9960},
+    {GameVersion::WiiJpn,     0x9960},
+});
+
+// #define l_pos      (l_pos_get())
 #define l_texCoord (l_texCoord_get())
 
 static bool l_Egnd_mantTEX_hasReplacement = false;
+
+DEFINE_MANT_ASSET(l_Egnd_mantDL, u8, 0x3EC, {
+    {GameVersion::GcnUsa,     0xA9A0},
+    {GameVersion::GcnPal,     0xA9A0},
+    {GameVersion::GcnJpn,     0xA9A0},
+    {GameVersion::WiiUsaRev0, 0xA0C0},
+    {GameVersion::WiiUsa,     0x9EC0},
+    {GameVersion::WiiPal,     0x9EC0},
+    {GameVersion::WiiJpn,     0x9EC0},
+});
+
+#define l_Egnd_mantDL (l_Egnd_mantDL_get())
 #else
 #include "assets/l_Egnd_mantTEX.h"
 
@@ -52,16 +116,9 @@ static bool l_Egnd_mantTEX_hasReplacement = false;
 #endif
 #include "d/d_s_play.h"
 
-#if TARGET_PC
-using GameVersion = dusk::version::GameVersion;
-
-static u8* l_Egnd_mantDL_get() { alignas(32) static u8 buf[0x3EC]; static bool _ = (dusk::LoadRelAsset(buf, "/rel/Final/Release/d_a_mant.rel", {{GameVersion::GcnUsa, 0xA9A0}, {GameVersion::GcnPal, 0xA9A0}}, 0x3EC), true); return buf; }
-#define l_Egnd_mantDL (l_Egnd_mantDL_get())
-#else
-#include "assets/l_Egnd_mantDL.h"
-#endif
-
 #if !TARGET_PC
+#include "assets/l_Egnd_mantDL.h"
+
 static void* pal_d = (void*)&l_Egnd_mantPAL;
 
 static void* tex_d[2] = {
@@ -155,8 +212,8 @@ void daMant_packet_c::draw() {
                     MtxP src25 = model->getAnmMtx(25);
                     Mtx joint_34_scratch;
                     Mtx joint_25_scratch;
-                    MtxP joint_34 = dusk::frame_interp::lookup_replacement(src34, joint_34_scratch) ? joint_34_scratch : src34;
-                    MtxP joint_25 = dusk::frame_interp::lookup_replacement(src25, joint_25_scratch) ? joint_25_scratch : src25;
+                    MtxP joint_34 = dusk::interp::lookup_replacement(src34, joint_34_scratch) ? joint_34_scratch : src34;
+                    MtxP joint_25 = dusk::interp::lookup_replacement(src25, joint_25_scratch) ? joint_25_scratch : src25;
 
                     cXyz presented_anchor_a;
                     cXyz presented_anchor_b;
@@ -175,7 +232,7 @@ void daMant_packet_c::draw() {
             }
         }
 
-        const f32 step = dusk::frame_interp::get_interpolation_step();
+        const f32 step = dusk::interp::get_interpolation_step();
         for (int i = 0; i < 169; ++i) {
             cXyz curr_local;
             MTXMultVec(curr_frame_inverse, &curr_pos[i], &curr_local);
diff --git a/src/d/actor/d_a_mg_fshop.cpp b/src/d/actor/d_a_mg_fshop.cpp
index 9e8eb3f357..061fb5b7be 100644
--- a/src/d/actor/d_a_mg_fshop.cpp
+++ b/src/d/actor/d_a_mg_fshop.cpp
@@ -1783,7 +1783,13 @@ static int daFshop_Create(fopAc_ac_c* actor) {
             };
 
             if (sp10 == 1) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+                if (dusk::version::isRegionJpn()) {
+                    sp24 = dComIfGs_getEventReg(check_kind[i]);
+                } else {
+                    sp24 = 2.54f * dComIfGs_getEventReg(check_kind[i]);
+                }
+#elif VERSION == VERSION_GCN_JPN
                 sp24 = dComIfGs_getEventReg(check_kind[i]);
 #else
                 sp24 = 2.54f * dComIfGs_getEventReg(check_kind[i]);
diff --git a/src/d/actor/d_a_mg_rod.cpp b/src/d/actor/d_a_mg_rod.cpp
index f6f3b8d6c6..53dba36b74 100644
--- a/src/d/actor/d_a_mg_rod.cpp
+++ b/src/d/actor/d_a_mg_rod.cpp
@@ -26,9 +26,10 @@
 #include <cstring>
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/mods/item.hpp"
 #include "dusk/settings.h"
 #include "dusk/version.hpp"
+#include "mods/items.h"
 #endif
 
 class dmg_rod_HIO_c : public JORReflexible {
@@ -181,25 +182,6 @@ static int Worm_nodeCallBack(J3DJoint* i_joint, int param_1) {
     return 1;
 }
 
-#if TARGET_PC
-static void dmg_rod_interp_callback(bool isSimFrame, void* pUserWork) {
-    dmg_rod_class* i_this = (dmg_rod_class*)pUserWork;
-    if (!i_this->mLineInterpPrevValid || !i_this->mLineInterpCurrValid) {
-        return;
-    }
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    const int count = i_this->kind == MG_ROD_KIND_LURE ? MG_ROD_LURE_LINE_LEN : MG_ROD_UKI_LINE_LEN;
-    cXyz* dst = i_this->linemat.getPos(0);
-    for (int i = 0; i < count; i++) {
-        const cXyz& p0 = i_this->mLineInterpPrev[i];
-        const cXyz& p1 = i_this->mLineInterpCurr[i];
-        dst[i] = p0 + (p1 - p0) * alpha;
-    }
-    static GXColor l_color = {0xFF, 0xFF, 0x96, 0xFF};
-    i_this->linemat.update(count, l_color, &i_this->actor.tevStr);
-}
-#endif
-
 static int dmg_rod_Draw(dmg_rod_class* i_this) {
     int unused;
     fopAc_ac_c* actor = &i_this->actor;
@@ -240,18 +222,6 @@ static int dmg_rod_Draw(dmg_rod_class* i_this) {
         i_this->linemat.update(MG_ROD_LURE_LINE_LEN, l_color, &i_this->actor.tevStr);
         dComIfGd_set3DlineMat(&i_this->linemat);
 
-#if TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
-            if (i_this->mLineInterpCurrValid) {
-                memcpy(i_this->mLineInterpPrev, i_this->mLineInterpCurr, MG_ROD_LURE_LINE_LEN * sizeof(cXyz));
-                i_this->mLineInterpPrevValid = true;
-            }
-            memcpy(i_this->mLineInterpCurr, i_this->linemat.getPos(0), MG_ROD_LURE_LINE_LEN * sizeof(cXyz));
-            i_this->mLineInterpCurrValid = true;
-            dusk::frame_interp::add_interpolation_callback(&dmg_rod_interp_callback, i_this);
-        }
-#endif
-
         model = i_this->rod_modelMorf->getModel();
         g_env_light.setLightTevColorType_MAJI(model, &i_this->actor.tevStr);
         i_this->rod_modelMorf->entryDL();
@@ -276,18 +246,6 @@ static int dmg_rod_Draw(dmg_rod_class* i_this) {
         i_this->linemat.update(MG_ROD_UKI_LINE_LEN, l_color, &i_this->actor.tevStr);
         dComIfGd_set3DlineMat(&i_this->linemat);
 
-#if TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
-            if (i_this->mLineInterpCurrValid) {
-                memcpy(i_this->mLineInterpPrev, i_this->mLineInterpCurr, MG_ROD_UKI_LINE_LEN * sizeof(cXyz));
-                i_this->mLineInterpPrevValid = true;
-            }
-            memcpy(i_this->mLineInterpCurr, i_this->linemat.getPos(0), MG_ROD_UKI_LINE_LEN * sizeof(cXyz));
-            i_this->mLineInterpCurrValid = true;
-            dusk::frame_interp::add_interpolation_callback(&dmg_rod_interp_callback, i_this);
-        }
-#endif
-
         for (int i = 0; i < 15; i++) {
             g_env_light.setLightTevColorType_MAJI(i_this->rod_uki_model[i], &actor->tevStr);
             mDoExt_modelUpdateDL(i_this->rod_uki_model[i]);
@@ -2955,7 +2913,17 @@ static void lure_heart(dmg_rod_class* i_this) {
             if (obj_life != NULL) {
                 fopAcM_delete(obj_life);
                 fopAcM_onItem(obj_life, 0x80);
+#if TARGET_PC
+                const auto itemCheck = dusk::mods::item_check_commit(
+                    ITEM_CHECK_FISHING_HEART_PIECE, dItemNo_KAKERA_HEART_e, actor);
+                if (itemCheck.itemNo == dItemNo_KAKERA_HEART_e) {
+                    execItemGet(dItemNo_KAKERA_HEART_e, itemCheck.tag, actor);
+                } else if (itemCheck.itemNo == dItemNo_NONE_e) {
+                    dusk::mods::item_check_complete(itemCheck, actor);
+                }
+#else
                 execItemGet(dItemNo_KAKERA_HEART_e);
+#endif
                 u8 eventReg = dComIfGs_getEventReg(0xECFF);
                 eventReg |= (u8)0x40;
                 dComIfGs_setEventReg(0xECFF, eventReg);
@@ -4090,7 +4058,15 @@ static void uki_catch(dmg_rod_class* i_this) {
             } else if (mgfish->mCaughtType == MG_CATCH_BIN) {
                 i_this->msgflow.init(actor, 0x139A, 0, NULL);
                 dComIfGs_onEventBit(dSv_event_flag_c::saveBitLabels[468]);
+#if TARGET_PC
+                const auto itemCheck = dusk::mods::item_check_commit(
+                    ITEM_CHECK_FISHING_BOTTLE, dItemNo_EMPTY_BOTTLE_e, actor);
+                if (itemCheck.itemNo == dItemNo_EMPTY_BOTTLE_e) {
+                    dComIfGs_setEmptyBottle();
+                }
+#else
                 dComIfGs_setEmptyBottle();
+#endif
             } else if (mgfish->mCaughtType == MG_CATCH_KN) {
                 i_this->msgflow.init(actor, 0x139C, 0, NULL);
             } else if (mgfish->mCaughtType == MG_CATCH_ED) {
@@ -4167,6 +4143,18 @@ static void uki_catch(dmg_rod_class* i_this) {
                 if (mgfish->mCaughtType == MG_CATCH_LH) {
                     dComIfGp_setItemRupeeCount(10.0f + cM_rndF(40.9f));
                 }
+#if TARGET_PC
+                else if (mgfish->mCaughtType == MG_CATCH_BIN)
+                {
+                    const auto itemCheck = dusk::mods::item_check_commit(
+                        ITEM_CHECK_FISHING_BOTTLE, dItemNo_EMPTY_BOTTLE_e, actor);
+                    if (itemCheck.itemNo == dItemNo_EMPTY_BOTTLE_e ||
+                        itemCheck.itemNo == dItemNo_NONE_e)
+                    {
+                        dusk::mods::item_check_complete(itemCheck, actor);
+                    }
+                }
+#endif
             } else {
                 dComIfGs_addFishNum(fish_kind);
                 if (i_this->field_0x14c0 != 0) {
@@ -5874,8 +5862,8 @@ static int dmg_rod_Execute(dmg_rod_class* i_this) {
     #if TARGET_PC
     if (dusk::getSettings().game.buttonFishing) {
         if ((item_any_fishing_rod(dComIfGp_getSelectItem(0)) && mDoCPd_c::getHoldX(PAD_1)) ||
-            (item_any_fishing_rod(dComIfGp_getSelectItem(1)) && mDoCPd_c::getHoldY(PAD_1)))
-        {
+            (item_any_fishing_rod(dComIfGp_getSelectItem(1)) && mDoCPd_c::getHoldY(PAD_1)) ||
+            (i_this->action == ACTION_LURE_STANDBY && mDoCPd_c::getTrigB(PAD_1))) {
             i_this->rod_stick_y = -1.0f;
             i_this->rod_substick_y = -1.0f;
         }
@@ -6449,11 +6437,6 @@ static int dmg_rod_Create(fopAc_ac_c* i_this) {
             return cPhs_ERROR_e;
         }
 
-#if TARGET_PC
-        rod->mLineInterpPrevValid = false;
-        rod->mLineInterpCurrValid = false;
-#endif
-
         OS_REPORT("//////////////MG_ROD SET 2 !!\n");
         if (!hio_set) {
             rod->HIOInit = TRUE;
diff --git a/src/d/actor/d_a_midna.cpp b/src/d/actor/d_a_midna.cpp
index 3082fc6a71..8517c6a7c0 100644
--- a/src/d/actor/d_a_midna.cpp
+++ b/src/d/actor/d_a_midna.cpp
@@ -14,7 +14,10 @@
 #include "d/d_msg_object.h"
 #include "d/d_s_play.h"
 #include "d/d_debug_viewer.h"
-#include "dusk/frame_interpolation.h"
+
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 static f32 dummy_lit_3777(int idx, u8 foo) {
     Vec dummy_vec = {0.0f, 0.0f, 0.0f};
@@ -109,7 +112,7 @@ void daMidna_hio_c::genMessage(JORMContext* ctx) {
 }
 #endif
 
-daMidna_hio_c1 const daMidna_hio_c0::m = {
+DUSK_GAME_DATA daMidna_hio_c1 const daMidna_hio_c0::m = {
     0,
     0,
     0,
@@ -126,8 +129,8 @@ daMidna_hio_c1 const daMidna_hio_c0::m = {
     25.0f,
 };
 
-bool daMidna_matAnm_c::sEyeMoveFlg;
-u8 daMidna_matAnm_c::sMorfFrame;
+DUSK_GAME_DATA bool daMidna_matAnm_c::sEyeMoveFlg;
+DUSK_GAME_DATA u8 daMidna_matAnm_c::sMorfFrame;
 
 void daMidna_matAnm_c::init() {
     mOldTransX = 0.0f;
@@ -173,7 +176,7 @@ int daMidna_McaMorfCB1_c::execute(u16 i_jointNo, J3DTransformInfo* transform) {
     return 1;
 }
 
-daMidna_texData_s const daMidna_c::m_texDataTable[21] = {
+DUSK_GAME_DATA daMidna_texData_s const daMidna_c::m_texDataTable[21] = {
     0x0405, 0x03A4,
     0x03F5, 0x0399,
     0x03F6, 0x0399,
@@ -197,7 +200,7 @@ daMidna_texData_s const daMidna_c::m_texDataTable[21] = {
     0x03FD, 0x0399,
 };
 
-daMidna_anmData_s const daMidna_c::m_anmDataTable[53] = {
+DUSK_GAME_DATA daMidna_anmData_s const daMidna_c::m_anmDataTable[53] = {
     0x01DC, 0x00, -1.0f, 0,
     0x01B7, 0x01, -1.0f, 0,
     0x01B8, 0x02, -1.0f, 0,
@@ -496,6 +499,7 @@ int daMidna_c::createHeap() {
         }
     }
 
+    IF_DUSK(mBckHeap[0].reserveBuffer(0x1DC);)
     JKRReadIdxResource(mBckHeap[0].getBuffer(), mBckHeap[0].getBufferSize(), 0x1DC, dComIfGp_getAnmArchive());
     J3DAnmTransform* md_anm = (J3DAnmTransform*)J3DAnmLoaderDataBase::load(mBckHeap[0].getBuffer());
     modelData = (J3DModelData*)dComIfG_getObjectRes(l_arcName, 14);
@@ -509,7 +513,7 @@ int daMidna_c::createHeap() {
             if (name != NULL && strcmp(name, "midona_eye") == 0) {
                 ResTIMG* timg = tex->getResTIMG(i);
                 timg->mipmapEnabled = false;
-                tex->loadGXTexObj(i);
+                tex->initGXTexObj(i);
                 break;
             }
         }
@@ -1106,10 +1110,10 @@ void daMidna_c::setBodyPartMatrix() {
             mpModel->setAnmMtx(i, mpShadowModel->getAnmMtx(i));
         }
         mpModel->calcWeightEnvelopeMtx();
-#ifdef TARGET_PC
+#if TARGET_PC
         // FRAME INTERP NOTE: Record weight envelopes for Midna here, as they are otherwise missed causing distortion
         for (u16 i = 0; i < mpModel->getModelData()->getWEvlpMtxNum(); i++) {
-            dusk::frame_interp::record_final_mtx(mpModel->getWeightAnmMtx(i));
+            dusk::interp::record_final_mtx(mpModel->getWeightAnmMtx(i));
         }
 #endif
     }
@@ -3300,7 +3304,7 @@ int daMidna_c::execute() {
             if (!checkStateFlg0(FLG0_UNK_8000)) {
                 offStateFlg0((daMidna_FLG0)(FLG0_NPC_NEAR | FLG0_NPC_FAR));
                 BOOL far_;
-                if (fopAcIt_Judge((fopAcIt_JudgeFunc)daMidna_searchNpc, &far_)) {
+                if (fopAcIt_Judge((fopAcIt_JudgeFunc)daMidna_searchNpc, &far_) IF_DUSK(&& !dusk::getSettings().game.canTransformAnywhere)) {
                     if (!far_) {
                         onStateFlg0(FLG0_NPC_NEAR);
                     } else {
diff --git a/src/d/actor/d_a_mirror.cpp b/src/d/actor/d_a_mirror.cpp
index c405645320..123279e8af 100644
--- a/src/d/actor/d_a_mirror.cpp
+++ b/src/d/actor/d_a_mirror.cpp
@@ -13,13 +13,6 @@
 #include <gf/GFGeometry.h>
 #include <gf/GFLight.h>
 #include "m_Do/m_Do_lib.h"
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#endif
-
-#ifndef __MWERKS__
-#include "dusk/math.h"
-#endif
 
 static BOOL daMirror_c_createHeap(fopAc_ac_c* i_this) {
     return ((daMirror_c*)i_this)->createHeap();
@@ -30,7 +23,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_arcName = "Mirror";
 static DUSK_CONSTEXPR char DUSK_CONST* l_arcName2 = "MR-Table";
 
 dMirror_packet_c::dMirror_packet_c() {
-#ifdef TARGET_PC
+#if TARGET_PC
     GXInitTexObj(&mTexObj, nullptr, 0, 0, static_cast<GXTexFmt>(-1), GX_MAX_TEXWRAPMODE,
                  GX_MAX_TEXWRAPMODE, GX_FALSE);
 #endif
diff --git a/src/d/actor/d_a_movie_player.cpp b/src/d/actor/d_a_movie_player.cpp
index 43117615e5..aabe220578 100644
--- a/src/d/actor/d_a_movie_player.cpp
+++ b/src/d/actor/d_a_movie_player.cpp
@@ -14,34 +14,21 @@
 #pragma optimization_level 4
 #pragma optimize_for_size off
 
-#include <cstring>
-#include <span>
+#include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JAudio2/JASAiCtrl.h"
 #include "JSystem/JAudio2/JASDriverIF.h"
-#include "JSystem/JKernel/JKRExpHeap.h"
-#include "Z2AudioLib/Z2Instances.h"
 #include "d/actor/d_a_movie_player.h"
-
-#include <cassert>
-
+#include "Z2AudioLib/Z2Instances.h"
 #include "f_op/f_op_overlap_mng.h"
+#include <cstring>
+
+#if TARGET_PC
+#include "dusk/layout.hpp"
+#include "dusk/os.h"
+#include "helpers/gx_helper.h"
 
 #include "JSystem/JAudio2/JASCriticalSection.h"
 
-#if TARGET_PC
-#include "dusk/gx_helper.h"
-#include "dusk/os.h"
-#include "dusk/layout.hpp"
-#if MOVIE_SUPPORT
-#include "turbojpeg.h"
-#endif
-#endif
-
-inline s32 daMP_NEXT_READ_SIZE(daMP_THPReadBuffer* readBuf) {
-    return *(BE(s32)*)readBuf->ptr;
-}
-
-#if TARGET_PC
 // idk what OS_THREAD_ATTR_DETACH does, and it stops OSThreadJoin()
 // probably the difference doesn't matter since we are using OS threads anyways.
 #define OS_THREAD_ATTR 0
@@ -49,7 +36,12 @@ inline s32 daMP_NEXT_READ_SIZE(daMP_THPReadBuffer* readBuf) {
 #define OS_THREAD_ATTR OS_THREAD_ATTR_DETACH
 #endif
 
-#if defined(__cplusplus) && !TARGET_PC
+inline s32 daMP_NEXT_READ_SIZE(daMP_THPReadBuffer* readBuf) {
+    return *(BE(s32)*)readBuf->ptr;
+}
+
+#if !TARGET_PC
+#if defined(__cplusplus)
 extern "C" {
 #endif
 
@@ -217,22 +209,21 @@ static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr) {
     info->encodeData++;
 }
 
-#if !TARGET_PC
-static u8 THPStatistics[1120] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 THPStatistics[1120];
 
-static THPHuffmanTab* Ydchuff ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPHuffmanTab* Ydchuff;
 
-static THPHuffmanTab* Udchuff ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPHuffmanTab* Udchuff;
 
-static THPHuffmanTab* Vdchuff ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPHuffmanTab* Vdchuff;
 
-static THPHuffmanTab* Yachuff ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPHuffmanTab* Yachuff;
 
-static THPHuffmanTab* Uachuff ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPHuffmanTab* Uachuff;
 
-static THPHuffmanTab* Vachuff ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPHuffmanTab* Vachuff;
 
-static f32 __THPIDCTWorkspace[64] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static f32 __THPIDCTWorkspace[64];
 
 static u8* __THPHuffmanBits;
 
@@ -240,11 +231,11 @@ static u8* __THPHuffmanSizeTab;
 
 static u16* __THPHuffmanCodeTab;
 
-static THPSample* Gbase ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static THPSample* Gbase;
 
-static u32 Gwid ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 Gwid;
 
-static f32* Gq ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static f32* Gq;
 
 static u8* __THPLCWork512[3];
 
@@ -2587,104 +2578,9 @@ static void __THPHuffDecodeDCTCompV(__REGISTER THPFileInfo* info, THPCoeff* bloc
 #else // !TARGET_PC
 
 static daMP_THPPlayer daMP_ActivePlayer;
-
-#if MOVIE_SUPPORT
-static std::vector<u8> FixedJpegData;
-static tjhandle JpegDecompressHandle;
-
-static const std::vector<u8>& FixJpeg(const std::span<u8> data) {
-    FixedJpegData.resize(0);
-    FixedJpegData.reserve(data.size());
-
-    size_t startOfScanLocation = 0;
-    for (; startOfScanLocation < data.size() - 1; startOfScanLocation++) {
-        if (data[startOfScanLocation] == 0xFF && data[startOfScanLocation + 1] == 0xDA) {
-            goto sosFound;
-        }
-    }
-
-    CRASH("Unable to find SOS marker!");
-
-    sosFound:
-
-    startOfScanLocation += 2; // TODO: Skip entire SOS header?
-
-    size_t endOfImage = data.size() - 1;
-    for (; endOfImage > startOfScanLocation; endOfImage--) {
-        if (data[endOfImage] == 0xFF && data[endOfImage + 1] == 0xD9) {
-            goto eoiFound;
-        }
-    }
-
-    CRASH("Unable to find EOI marker!");
-    eoiFound:
-
-    // Copy data before SOS
-    for (size_t i = 0; i < startOfScanLocation; i++) {
-        FixedJpegData.push_back(data[i]);
-    }
-
-    // Copy data inside SOS, fixing up lacking of "byte shuffling"
-    for (size_t i = startOfScanLocation; i < endOfImage; i++) {
-        u8 value = data[i];
-        FixedJpegData.push_back(value);
-        if (value == 0xFF) {
-            FixedJpegData.push_back(0x00);
-        }
-    }
-
-    // Copy data after SOS.
-    for (size_t i = endOfImage; i < data.size(); i++) {
-        FixedJpegData.push_back(data[i]);
-    }
-
-    return FixedJpegData;
-}
-
-static s32 THPVideoDecode(void* file, size_t fileSize, void* tileY, void* tileU, void* tileV, void*) {
-    assert(JpegDecompressHandle);
-
-    const auto handle = JpegDecompressHandle;
-    const auto fixedData = FixJpeg(std::span(static_cast<u8*>(file), fileSize));
-
-    auto ret = tj3DecompressHeader(handle, fixedData.data(), fixedData.size());
-    if (ret == -1) {
-        OSReport_Error("Parsing JPEG header failed: %s", tj3GetErrorStr(handle));
-        return 1;
-    }
-
-    if (tj3Get(handle, TJPARAM_JPEGWIDTH) != daMP_ActivePlayer.videoInfo.xSize) {
-        OSReport_Error("Invalid width in video frame!");
-        return 1;
-    }
-
-    if (tj3Get(handle, TJPARAM_JPEGHEIGHT) != daMP_ActivePlayer.videoInfo.ySize) {
-        OSReport_Error("Invalid height in video frame!");
-        return 1;
-    }
-
-    ret = tj3Set(handle, TJPARAM_SUBSAMP, TJSAMP_420);
-    if (ret != 0) {
-        OSReport_Error("Failed to set subsampling mode: %s", tj3GetErrorStr(handle));
-        return 1;
-    }
-
-    u8* planes[3] = {static_cast<u8*>(tileY), static_cast<u8*>(tileU), static_cast<u8*>(tileV)};
-    ret = tj3DecompressToYUVPlanes8(handle, fixedData.data(), fixedData.size(), planes, nullptr);
-    if (ret != 0) {
-        OSReport_Error("Image decompression failed: %s", tj3GetErrorStr(handle));
-        return 1;
-    }
-
-    return 0;
-}
-#else // MOVIE_SUPPORT
-static s32 THPVideoDecode(void*, size_t, void*, void*, void*, void*) {
-    return 1; // Immediate error.
-}
-#endif
 #endif
 
+#if !TARGET_PC
 static BOOL THPInit() {
 #if !TARGET_PC
     u8* base;
@@ -2712,9 +2608,10 @@ static BOOL THPInit() {
     return TRUE;
 }
 
-#if defined(__cplusplus) && !TARGET_PC
+#if defined(__cplusplus)
 }
 #endif
+#endif // !TARGET_PC
 
 #if !TARGET_PC // Defined earlier in file.
 static daMP_THPPlayer daMP_ActivePlayer;
@@ -2937,9 +2834,6 @@ static void daMP_VideoDecode(daMP_THPReadBuffer* readBuffer) {
 		case 0: {
 			if ((daMP_ActivePlayer.videoError = THPVideoDecode(
 			        tile,
-#if TARGET_PC
-	                *tileOffsets,
-#endif
 			         textureSet->ytexture, textureSet->utexture,
 			         textureSet->vtexture,
 			         daMP_ActivePlayer.thpWork))) {
@@ -3434,26 +3328,19 @@ static void daMP_THPGXYuv2RgbDraw(u8* y_data, u8* u_data, u8* v_data, s16 x,
     TGXTexObj tobj0;
     TGXTexObj tobj1;
     TGXTexObj tobj2;
-#if TARGET_PC
-#define FMT (GXTexFmt)GX_TF_R8_PC
-#else
-#define FMT GX_TF_I8
-#endif
 
-    GXInitTexObj(&tobj0, y_data, textureWidth, textureHeight, FMT, GX_CLAMP, GX_CLAMP, GX_FALSE);
+    GXInitTexObj(&tobj0, y_data, textureWidth, textureHeight, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(&tobj0, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
     GXLoadTexObj(&tobj0, GX_TEXMAP0);
 
-    GXInitTexObj(&tobj1, u_data, textureWidth >> 1, textureHeight >> 1, FMT, GX_CLAMP, GX_CLAMP, GX_FALSE);
+    GXInitTexObj(&tobj1, u_data, textureWidth >> 1, textureHeight >> 1, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(&tobj1, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
     GXLoadTexObj(&tobj1, GX_TEXMAP1);
 
-    GXInitTexObj(&tobj2, v_data, textureWidth >> 1, textureHeight >> 1, FMT, GX_CLAMP, GX_CLAMP, GX_FALSE);
+    GXInitTexObj(&tobj2, v_data, textureWidth >> 1, textureHeight >> 1, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
     GXInitTexObjLOD(&tobj2, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
     GXLoadTexObj(&tobj2, GX_TEXMAP2);
 
-#undef FMT
-
     GXBegin(GX_QUADS, GX_VTXFMT7, 4);
     GXPosition3s16(x, y, 0);
     GXTexCoord2u16(0, 0);
@@ -3582,7 +3469,7 @@ static void daMP_MixAudio(s16* destination, s16*, u32 sample) {
 
 static BOOL daMP_Initialized;
 
-static u32 daMP_WorkBuffer[16] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u32 daMP_WorkBuffer[16];
 
 static OSMessageQueue daMP_PrepareReadyQueue;
 
@@ -3604,7 +3491,7 @@ static void* daMP_CurAudioBuffer;
 
 static s32 daMP_AudioSystem;
 
-static u8 daMP_SoundBuffer[2][0x8C0] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 daMP_SoundBuffer[2][0x8C0];
 
 static s16* daMP_audioCallbackWithMSound(s32 sample) {
     if (daMP_ActivePlayer.open == 0 || daMP_ActivePlayer.internalState != 2 || daMP_ActivePlayer.audioExist == 0) {
@@ -3774,13 +3661,6 @@ static BOOL daMP_THPPlayerOpen(char const* filename, BOOL onMemory) {
 }
 
 static BOOL daMP_THPPlayerClose() {
-#if TARGET_PC && MOVIE_SUPPORT
-    tj3Destroy(JpegDecompressHandle);
-    JpegDecompressHandle = nullptr;
-
-    FixedJpegData.clear();
-#endif
-
     if (daMP_ActivePlayer.open && daMP_ActivePlayer.state == 0) {
         daMP_ActivePlayer.open = 0;
         DVDClose(&daMP_ActivePlayer.fileInfo);
@@ -3832,11 +3712,6 @@ static BOOL daMP_THPPlayerSetBuffer(u8* buffer) {
 
 		ysize = ALIGN_NEXT(daMP_ActivePlayer.videoInfo.xSize * daMP_ActivePlayer.videoInfo.ySize, 32);
 		uvsize = ALIGN_NEXT(daMP_ActivePlayer.videoInfo.xSize * daMP_ActivePlayer.videoInfo.ySize / 4, 32);
-#if TARGET_PC
-	    assert(ysize >= tj3YUVPlaneSize(0, daMP_ActivePlayer.videoInfo.xSize, 0, daMP_ActivePlayer.videoInfo.ySize, TJSAMP_420));
-	    assert(uvsize >= tj3YUVPlaneSize(1, daMP_ActivePlayer.videoInfo.xSize, 0, daMP_ActivePlayer.videoInfo.ySize, TJSAMP_420));
-	    assert(uvsize >= tj3YUVPlaneSize(2, daMP_ActivePlayer.videoInfo.xSize, 0, daMP_ActivePlayer.videoInfo.ySize, TJSAMP_420));
-#endif
 
 		for (i = 0; i < ARRAY_SIZE(daMP_ActivePlayer.textureSet); i++) {
 			daMP_ActivePlayer.textureSet[i].ytexture = ptr;
@@ -4329,15 +4204,6 @@ static BOOL daMP_ActivePlayer_Init(char const* moviePath) {
 
     daMP_THPPlayerSetBuffer((u8*)daMP_buffer);
 
-#if TARGET_PC && MOVIE_SUPPORT
-    assert(JpegDecompressHandle == nullptr);
-    JpegDecompressHandle = tj3Init(TJINIT_DECOMPRESS);
-    if (JpegDecompressHandle == nullptr) {
-        OSReport_Error("Failed to create turbojpeg handle: %s", tj3GetErrorStr(nullptr));
-        return 0;
-    }
-#endif
-
     if (!daMP_THPPlayerPrepare(0, 0, daMP_audioInfo.sndNumTracks != 1 ? OSGetTick() % daMP_audioInfo.sndNumTracks : 0)) {
         OSReport("Fail to prepare\n");
         #if DEBUG
@@ -4373,10 +4239,6 @@ static void daMP_ActivePlayer_Main() {
     }
 }
 
-#if TARGET_PC && 0
-#include "imgui.h"
-#endif
-
 static void daMP_ActivePlayer_Draw() {
 #if TARGET_PC
     u16 width = JUTVideo::getManager()->getFbWidth();
@@ -4592,12 +4454,3 @@ DUSK_PROFILE actor_process_profile_definition DUSK_CONST g_profile_MOVIE_PLAYER
 };
 
 AUDIO_INSTANCES;
-
-#if TARGET_PC
-void dusk::MoviePlayerShutdown() {
-    // We need to cleanly shut down the threads to avoid crashes on shutdown.
-    if (daMP_c::m_myObj) {
-        daMP_c::m_myObj->daMP_c_Finish();
-    }
-}
-#endif
\ No newline at end of file
diff --git a/src/d/actor/d_a_myna.cpp b/src/d/actor/d_a_myna.cpp
index 4b25ead19c..93409fdb65 100644
--- a/src/d/actor/d_a_myna.cpp
+++ b/src/d/actor/d_a_myna.cpp
@@ -254,7 +254,7 @@ static void* daMyna_searchEvtTag(void* i_evtTagActor, void* param_1) {
     return 0;
 }
 
-dCcD_SrcSph const daMyna_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph const daMyna_c::mCcDSph = {
     0, 0x400, 1, 0x1F, 0, 0, 0x79, 0xA, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0.0f, 0.0f, 0.0f, 15.0f,
 };
 
@@ -326,7 +326,7 @@ int daMyna_c::baseMotion06(int param_0) {
     return 1;
 }
 
-daMyna_c::BaseMotionFunc daMyna_c::mBaseMotionTBL[] = {
+DUSK_GAME_DATA daMyna_c::BaseMotionFunc daMyna_c::mBaseMotionTBL[] = {
     &daMyna_c::baseMotion00, &daMyna_c::baseMotion01, &daMyna_c::baseMotion02,
     &daMyna_c::baseMotion03, &daMyna_c::baseMotion04, &daMyna_c::baseMotion05,
     &daMyna_c::baseMotion06,
diff --git a/src/d/actor/d_a_nbomb.cpp b/src/d/actor/d_a_nbomb.cpp
index 00d27306f3..0626290433 100644
--- a/src/d/actor/d_a_nbomb.cpp
+++ b/src/d/actor/d_a_nbomb.cpp
@@ -117,7 +117,7 @@ static dCcD_SrcSph l_sphSrc = {
     }  // mSphAttr
 };
 
-const char* daNbomb_c::m_arcNameList[6] = {
+DUSK_GAME_DATA const char* daNbomb_c::m_arcNameList[6] = {
     daAlink_c::getAlinkArcName(), daAlink_c::getAlinkArcName(), daAlink_c::getAlinkArcName(),
     l_arcNameBombF, l_arcNameBombE, l_arcNameBombEW,
 };
diff --git a/src/d/actor/d_a_npc.cpp b/src/d/actor/d_a_npc.cpp
index 8fd99f2cb4..d093c51d70 100644
--- a/src/d/actor/d_a_npc.cpp
+++ b/src/d/actor/d_a_npc.cpp
@@ -1219,7 +1219,7 @@ void daNpcT_DmgStagger_c::calc(BOOL param_0) {
     }
 }
 
-dCcD_SrcCyl daNpcT_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daNpcT_c::mCcDCyl = {
     daNpcT_c::mCcDObjData,
     {
         {
@@ -1230,7 +1230,7 @@ dCcD_SrcCyl daNpcT_c::mCcDCyl = {
     }
 };
 
-dCcD_SrcSph daNpcT_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daNpcT_c::mCcDSph = {
     daNpcT_c::mCcDObjData,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
@@ -1252,13 +1252,13 @@ void daNpcT_c::tgHitCallBack(fopAc_ac_c* i_actor1, dCcD_GObjInf* i_obj1, fopAc_a
     static_cast<daNpcT_c*>(actor1)->setCutType(cut_type);
 }
 
-fopAc_ac_c* daNpcT_c::mFindActorPtrs[50];
+DUSK_GAME_DATA fopAc_ac_c* daNpcT_c::mFindActorPtrs[50];
 
-char l_fileNameBuf[0x15];
+DUSK_GAME_DATA char l_fileNameBuf[0x15];
 
-s16 daNpcT_c::mSrchName;
+DUSK_GAME_DATA s16 daNpcT_c::mSrchName;
 
-int daNpcT_c::mFindCount;
+DUSK_GAME_DATA int daNpcT_c::mFindCount;
 
 void* daNpcT_c::srchActor(void* i_actor1, void* i_actor2) {
     fopAc_ac_c* actor2 = (fopAc_ac_c*)i_actor2;
@@ -2901,7 +2901,7 @@ BOOL daNpcT_chkTmpBit(u32 i_no) {
     return dComIfGs_isTmpBit((u16)dSv_event_tmp_flag_c::tempBitLabels[i_no]);
 }
 
-const dCcD_SrcGObjInf daNpcT_c::mCcDObjData = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daNpcT_c::mCcDObjData = {
     {0, {{0, 0, 0}, {0, 0x00}, {0x79}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 0},
diff --git a/src/d/actor/d_a_npc2.cpp b/src/d/actor/d_a_npc2.cpp
index 6bc5e7f08d..6bf14418ae 100644
--- a/src/d/actor/d_a_npc2.cpp
+++ b/src/d/actor/d_a_npc2.cpp
@@ -7,7 +7,7 @@ static s32 daBaseNpc_chkPnt(cXyz param_0, dPnt* param_1, u16 param_2, u16 param_
 static u16 daBaseNpc_putNurbs(dPnt* i_CPnts, int i_CPntNum, int i_maxPntNum, dPnt* o_curve_p, BOOL i_isClosed);
 static s16 daBaseNpc_getGroundAngle(cBgS_PolyInfo* param_0, s16 param_1);
 
-dCcD_SrcCyl daBaseNpc_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daBaseNpc_c::mCcDCyl = {
     daBaseNpc_c::mCcDObj,
     {
         {
@@ -18,7 +18,7 @@ dCcD_SrcCyl daBaseNpc_c::mCcDCyl = {
     }
 };
 
-dCcD_SrcSph daBaseNpc_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daBaseNpc_c::mCcDSph = {
     daBaseNpc_c::mCcDObj,
     {
             {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
@@ -701,11 +701,11 @@ static int CheckCreateHeap(fopAc_ac_c* i_this) {
     return moveBgActor->MoveBGCreateHeap();
 }
 
-const char* daBaseNpc_moveBgActor_c::m_name;
+DUSK_GAME_DATA const char* daBaseNpc_moveBgActor_c::m_name;
 
-int daBaseNpc_moveBgActor_c::m_dzb_id;
+DUSK_GAME_DATA int daBaseNpc_moveBgActor_c::m_dzb_id;
 
-MoveBGActor_SetFunc daBaseNpc_moveBgActor_c::m_set_func;
+DUSK_GAME_DATA MoveBGActor_SetFunc daBaseNpc_moveBgActor_c::m_set_func;
 
 int daBaseNpc_moveBgActor_c::MoveBGCreateHeap() {
     if (!CreateHeap()) {
diff --git a/src/d/actor/d_a_npc4.cpp b/src/d/actor/d_a_npc4.cpp
index ef8b75fb19..b6e3092051 100644
--- a/src/d/actor/d_a_npc4.cpp
+++ b/src/d/actor/d_a_npc4.cpp
@@ -707,7 +707,7 @@ void daNpcF_c::tgHitCallBack(fopAc_ac_c* i_this, dCcD_GObjInf* param_1, fopAc_ac
     }
 }
 
-dCcD_SrcCyl daNpcF_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daNpcF_c::mCcDCyl = {
     daNpcF_c::mCcDObjInfo,
     {
         {
@@ -718,18 +718,18 @@ dCcD_SrcCyl daNpcF_c::mCcDCyl = {
     }
 };
 
-dCcD_SrcSph daNpcF_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daNpcF_c::mCcDSph = {
     daNpcF_c::mCcDObjInfo,
     {
                 {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
     }  // mSphAttr
 };
 
-char daNpcF_c::mFileNameBuf[0x15];
+DUSK_GAME_DATA char daNpcF_c::mFileNameBuf[0x15];
 
-fopAc_ac_c* daNpcF_c::mFindActorPList[100];
+DUSK_GAME_DATA fopAc_ac_c* daNpcF_c::mFindActorPList[100];
 
-s32 daNpcF_c::mFindCount;
+DUSK_GAME_DATA s32 daNpcF_c::mFindCount;
 
 void* daNpcF_c::srchAttnActor1(void* i_proc, void* param_1) {
     void* param_1_copy = param_1;
@@ -746,7 +746,7 @@ void* daNpcF_c::srchAttnActor1(void* i_proc, void* param_1) {
     return NULL;
 }
 
-s16 daNpcF_c::mSrchActorName;
+DUSK_GAME_DATA s16 daNpcF_c::mSrchActorName;
 
 void* daNpcF_c::srchActor(void* i_proc, void* i_this) {
     void* i_this_copy = i_this;
@@ -2159,14 +2159,14 @@ int daNpcF_MoveBgActor_c::MoveBGDraw() {
     return Draw();
 }
 
-dCcD_SrcGObjInf const daBaseNpc_c::mCcDObj = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daBaseNpc_c::mCcDObj = {
     {0, {{0, 0, 0}, {0x0, 0x0}, {0x79}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {0}
 };
 
-dCcD_SrcGObjInf const daNpcF_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daNpcF_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0x0, 0x0}, {0x79}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 0},
diff --git a/src/d/actor/d_a_npc_aru.cpp b/src/d/actor/d_a_npc_aru.cpp
index 8e6018873c..5b6444123c 100644
--- a/src/d/actor/d_a_npc_aru.cpp
+++ b/src/d/actor/d_a_npc_aru.cpp
@@ -141,7 +141,7 @@ enum Type {
     /* 0x4 */ TYPE_4,
 };
 
-const daNpc_Aru_HIOParam daNpc_Aru_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Aru_HIOParam daNpc_Aru_Param_c::m = {
     220.0f,
     -3.0f,
     1.0f,
@@ -345,7 +345,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {11, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Aru_c::mCutNameList[7] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Aru_c::mCutNameList[7] = {
     "",
     "RIDEON_HORSE",
     "GOTO_BULLRUNNING_STAGE",
@@ -355,7 +355,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Aru_c::mCutNameList[7] = {
     "NO_ENTRANCE",
 };
 
-daNpc_Aru_c::cutFunc DUSK_CONST daNpc_Aru_c::mCutList[7] = {
+DUSK_GAME_DATA daNpc_Aru_c::cutFunc DUSK_CONST daNpc_Aru_c::mCutList[7] = {
     NULL,
     &daNpc_Aru_c::cutRideOnHorse,
     &daNpc_Aru_c::cutGotoBullRunningStage,
@@ -1744,7 +1744,9 @@ int daNpc_Aru_c::cutSpeakTo(int i_staffID) {
                 switch (eventId) {
                     case 1:
                         if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                            mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL, NULL);
+                            DUSK_ITEM_CHECK("goats_reward", itemNo, this);
+                            mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, itemNo,
+                                0, -1, -1, NULL, NULL DUSK_GIVE_TAG("goats_reward"));
                         }
 
                         if (fopAcM_IsExecuting(mItemPartnerId)) {
diff --git a/src/d/actor/d_a_npc_ash.cpp b/src/d/actor/d_a_npc_ash.cpp
index e209fbf4ce..7bfde34700 100644
--- a/src/d/actor/d_a_npc_ash.cpp
+++ b/src/d/actor/d_a_npc_ash.cpp
@@ -12,7 +12,7 @@
 #include "SSystem/SComponent/c_math.h"
 #include <cstring>
 
-const daNpcAsh_HIOParam daNpcAsh_Param_c::m = {
+DUSK_GAME_DATA const daNpcAsh_HIOParam daNpcAsh_Param_c::m = {
     35.0f,    // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
@@ -198,7 +198,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[6] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Ash";
 
-daNpcAsh_c::EventFn daNpcAsh_c::mEvtSeqList[6] = {
+DUSK_GAME_DATA daNpcAsh_c::EventFn daNpcAsh_c::mEvtSeqList[6] = {
     NULL,
     &daNpcAsh_c::EvCut_Introduction,
     &daNpcAsh_c::EvCut_Meeting,
diff --git a/src/d/actor/d_a_npc_ashB.cpp b/src/d/actor/d_a_npc_ashB.cpp
index 216f2c10cb..f9c7df2cc2 100644
--- a/src/d/actor/d_a_npc_ashB.cpp
+++ b/src/d/actor/d_a_npc_ashB.cpp
@@ -10,7 +10,7 @@
 #include "JSystem/J3DGraphBase/J3DMaterial.h"
 #include <cstring>
 
-const daNpcAshB_HIOParam daNpcAshB_Param_c::m = {
+DUSK_GAME_DATA const daNpcAshB_HIOParam daNpcAshB_Param_c::m = {
     205.0f,   // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
@@ -93,7 +93,7 @@ void daNpcAshB_HIO_c::genMessage(JORMContext* ctext) {
 }
 #endif
 
-daNpcAshB_c::EventFn DUSK_CONST daNpcAshB_c::mEvtSeqList[2] = {
+DUSK_GAME_DATA daNpcAshB_c::EventFn DUSK_CONST daNpcAshB_c::mEvtSeqList[2] = {
     NULL,
     &daNpcAshB_c::EvCut_Appear,
 };
@@ -1001,8 +1001,9 @@ BOOL daNpcAshB_c::EvCut_Appear(int i_staffID) {
         case '0008':
             local_30[0] = 0;
             if (mFlow.getEventId(local_30) == 1) {
-                mItemPartnerId =
-                    fopAcM_createItemForPresentDemo(&current.pos, local_30[0], 0, -1, -1, 0, 0);
+                DUSK_ITEM_CHECK("ashei_sketch", local_30[0], this);
+                mItemPartnerId = fopAcM_createItemForPresentDemo(
+                    &current.pos, local_30[0], 0, -1, -1, 0, 0 DUSK_GIVE_TAG("ashei_sketch"));
                 dComIfGp_event_setItemPartnerId(mItemPartnerId);
                 mItemPartnerId = -1;
             }
diff --git a/src/d/actor/d_a_npc_bans.cpp b/src/d/actor/d_a_npc_bans.cpp
index 1755c46cfd..db08a19bde 100644
--- a/src/d/actor/d_a_npc_bans.cpp
+++ b/src/d/actor/d_a_npc_bans.cpp
@@ -138,7 +138,7 @@ enum Type {
     /* 0x5 */ TYPE_DEFAULT,
 };
 
-daNpc_Bans_HIOParam const daNpc_Bans_Param_c::m = {
+DUSK_GAME_DATA daNpc_Bans_HIOParam const daNpc_Bans_Param_c::m = {
     200.0f,
     -3.0f,
     1.0f,
@@ -335,14 +335,14 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {9, 0, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Bans_c::mCutNameList[4] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Bans_c::mCutNameList[4] = {
     "",
     "ANGER",
     "PURCHASE",
     "GO_BACK",
 };
 
-daNpc_Bans_c::cutFunc DUSK_CONST daNpc_Bans_c::mCutList[4] = {
+DUSK_GAME_DATA daNpc_Bans_c::cutFunc DUSK_CONST daNpc_Bans_c::mCutList[4] = {
     NULL,
     &daNpc_Bans_c::cutAnger,
     &daNpc_Bans_c::cutPurchase,
diff --git a/src/d/actor/d_a_npc_besu.cpp b/src/d/actor/d_a_npc_besu.cpp
index b3f5fef623..197f97dfb0 100644
--- a/src/d/actor/d_a_npc_besu.cpp
+++ b/src/d/actor/d_a_npc_besu.cpp
@@ -284,7 +284,7 @@ enum Event {
     /* 0xC */ EVENT_CONVERSATION_ABOUT_ZORA,
 };
 
-const daNpc_Besu_HIOParam daNpc_Besu_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Besu_HIOParam daNpc_Besu_Param_c::m = {
     160.0f,
     -3.0f,
     1.0f,
@@ -577,7 +577,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {9, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Besu_c::mCutNameList[15] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Besu_c::mCutNameList[15] = {
     "",
     "CONVERSATION_ABOUT_SARU",
     "CONVERSATION_ABOUT_PACHINKO",
@@ -595,7 +595,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Besu_c::mCutNameList[15] = {
     "THANK_YOU",
 };
 
-daNpc_Besu_c::cutFunc DUSK_CONST daNpc_Besu_c::mCutList[15] = {
+DUSK_GAME_DATA daNpc_Besu_c::cutFunc DUSK_CONST daNpc_Besu_c::mCutList[15] = {
     NULL,
     &daNpc_Besu_c::cutConversationAboutSaru,
     &daNpc_Besu_c::cutConversationAboutPachinko,
diff --git a/src/d/actor/d_a_npc_blue_ns.cpp b/src/d/actor/d_a_npc_blue_ns.cpp
index c2f1e2563d..9b8ccf41dd 100644
--- a/src/d/actor/d_a_npc_blue_ns.cpp
+++ b/src/d/actor/d_a_npc_blue_ns.cpp
@@ -39,7 +39,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Blue_NS";
 
 static NPC_BLUE_NS_HIO_CLASS l_HIO;
 
-daNpcBlueNS_c::EventFn DUSK_CONST daNpcBlueNS_c::mEvtSeqList[] = {
+DUSK_GAME_DATA daNpcBlueNS_c::EventFn DUSK_CONST daNpcBlueNS_c::mEvtSeqList[] = {
     NULL,
     &daNpcBlueNS_c::_Evt_ChgYami_Chibi,
     &daNpcBlueNS_c::_Evt_ChgYami_Debu,
@@ -93,7 +93,7 @@ const static dCcD_SrcCyl l_cyl_src = {
     }
 };
 
-const daNpcBlueNS_HIOParam daNpcBlueNS_Param_c::m = {
+DUSK_GAME_DATA const daNpcBlueNS_HIOParam daNpcBlueNS_Param_c::m = {
     55.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_bou.cpp b/src/d/actor/d_a_npc_bou.cpp
index 0d4d34b206..a8915773a7 100644
--- a/src/d/actor/d_a_npc_bou.cpp
+++ b/src/d/actor/d_a_npc_bou.cpp
@@ -119,7 +119,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {2, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {6, -1, 1}, {5, -1, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Bou_c::mCutNameList[9] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Bou_c::mCutNameList[9] = {
     "",
     "WILDGOAT",
     "WILDGOAT_SUCCESS",
@@ -131,7 +131,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Bou_c::mCutNameList[9] = {
     "MEETING_AGAIN"
 };
 
-daNpc_Bou_c::cutFunc DUSK_CONST daNpc_Bou_c::mCutList[9] = {
+DUSK_GAME_DATA daNpc_Bou_c::cutFunc DUSK_CONST daNpc_Bou_c::mCutList[9] = {
     NULL,
     &daNpc_Bou_c::cutWildGoat,
     &daNpc_Bou_c::cutWildGoatSuccess,
@@ -157,7 +157,7 @@ daNpc_Bou_c::~daNpc_Bou_c() {
     deleteRes(l_loadResPtrnList[mType], (char const**)l_resNameList);
 }
 
-daNpc_Bou_HIOParam const daNpc_Bou_Param_c::m = {
+DUSK_GAME_DATA daNpc_Bou_HIOParam const daNpc_Bou_Param_c::m = {
     {
         210.0f, -3.0f, 1.0f, 600.0f, 255.0f, 200.0f, 35.0f, 40.0f,
        0.0f, 0.0f, 10.0f, -10.0f, 30.0f, -10.0f, 45.0f, -45.0f,
diff --git a/src/d/actor/d_a_npc_bouS.cpp b/src/d/actor/d_a_npc_bouS.cpp
index 0180b100cc..ffd0156f9b 100644
--- a/src/d/actor/d_a_npc_bouS.cpp
+++ b/src/d/actor/d_a_npc_bouS.cpp
@@ -261,7 +261,7 @@ void daNpcBouS_HIO_c::genMessage(JORMContext* ctx) {
 }
 #endif
 
-daNpcBouS_c::eventFunc daNpcBouS_c::mEvtSeqList[4] = {
+DUSK_GAME_DATA daNpcBouS_c::eventFunc daNpcBouS_c::mEvtSeqList[4] = {
     NULL,
     &daNpcBouS_c::EvCut_BousIntroSumo1,
     &daNpcBouS_c::EvCut_BousIntroSumo2,
@@ -286,7 +286,7 @@ daNpcBouS_c::~daNpcBouS_c() {
     #endif
 }
 
-daNpcBouS_HIOParam const daNpcBouS_Param_c::m = {
+DUSK_GAME_DATA daNpcBouS_HIOParam const daNpcBouS_Param_c::m = {
     220.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_cd.cpp b/src/d/actor/d_a_npc_cd.cpp
index 29f5021fae..cc4ab6f967 100644
--- a/src/d/actor/d_a_npc_cd.cpp
+++ b/src/d/actor/d_a_npc_cd.cpp
@@ -160,7 +160,7 @@ static anmTblPrm const l_bckTbl_W[10] = {
     {"Wspcial_l", 7}, {"Wspcial_l", 8}, {"Wspcial_l", 3}, {"Wspcial_l", 4}, {"Wspcial_l", 5},
 };
 
-dCcD_SrcCyl const daNpcCd_c::m_cylDat = {
+DUSK_GAME_DATA dCcD_SrcCyl const daNpcCd_c::m_cylDat = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0, 0}, 0x79}},  // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0},      // mGObjAt
@@ -346,7 +346,7 @@ static anmTblPrm const l_bmdTWTbl[30] = {
     {l_resWGNa2[1], 3}, {l_resWANb2[1], 3},
 };
 
-daNpcCd_HIO_c l_Cd_HIO;
+DUSK_GAME_DATA daNpcCd_HIO_c l_Cd_HIO;
 
 int daNpcCd_c::setAttention(int i_idx) {
     static cXyz const a_eyeOfsTbl[30] = {
diff --git a/src/d/actor/d_a_npc_cd2.cpp b/src/d/actor/d_a_npc_cd2.cpp
index 87e5258901..c42f5f947c 100644
--- a/src/d/actor/d_a_npc_cd2.cpp
+++ b/src/d/actor/d_a_npc_cd2.cpp
@@ -179,7 +179,7 @@ static anmTblPrm const l_bckTbl_W[54] = {
     {"Wgeneral", 5},  {"Wgeneral", 6},  {"Wgeneral", 9},  {"Wgeneral", 15},
 };
 
-dCcD_SrcCyl const daNpcCd2_c::m_cylDat = {
+DUSK_GAME_DATA dCcD_SrcCyl const daNpcCd2_c::m_cylDat = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0, 0}, 0x79}}, // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
@@ -240,7 +240,7 @@ static anmTblPrm const l_btpTWTbl[30] = {
 
 #include "d/actor/d_a_npc_cd2_HIO.inc"
 
-daNpcCd2_HIO_c l_Cd2_HIO;
+DUSK_GAME_DATA daNpcCd2_HIO_c l_Cd2_HIO;
 
 int daNpcCd2_c::NpcCreate(int param_1) {
     J3DModelData* a_mdlData_p = getNpcMdlDataP(param_1);
diff --git a/src/d/actor/d_a_npc_cdn3.cpp b/src/d/actor/d_a_npc_cdn3.cpp
index e1767b1e50..1b9ee8c6f3 100644
--- a/src/d/actor/d_a_npc_cdn3.cpp
+++ b/src/d/actor/d_a_npc_cdn3.cpp
@@ -10,7 +10,7 @@
 #include "d/d_s_play.h"
 #include <cstring>
 
-const daNpcCdn3_c::ActionPair daNpcCdn3_c::ActionTable[8] = {
+DUSK_GAME_DATA const daNpcCdn3_c::ActionPair daNpcCdn3_c::ActionTable[8] = {
     {&daNpcCdn3_c::initWait, &daNpcCdn3_c::executeWait},
     {&daNpcCdn3_c::initPath, &daNpcCdn3_c::executePath},
     {&daNpcCdn3_c::initTalk, &daNpcCdn3_c::executeTalk},
@@ -1500,7 +1500,7 @@ inline int daNpcCdn3_c::draw() {
     return 1;
 }
 
-daNpcCdn3_c::seqFunc* daNpcCdn3_c::m_funcTbl[44] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc* daNpcCdn3_c::m_funcTbl[44] = {
     m_seq00_funcTbl, m_seq01_funcTbl,
     m_seq02_funcTbl, m_seq03_funcTbl,
     m_seq04_funcTbl, m_seq05_funcTbl,
@@ -1525,25 +1525,25 @@ daNpcCdn3_c::seqFunc* daNpcCdn3_c::m_funcTbl[44] = {
     m_seq42_funcTbl, m_seq43_funcTbl,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq00_funcTbl[2] = {&daNpcCdn3_c::walka, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq00_funcTbl[2] = {&daNpcCdn3_c::walka, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq01_funcTbl[2] = {&daNpcCdn3_c::runa, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq01_funcTbl[2] = {&daNpcCdn3_c::runa, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq02_funcTbl[2] = {&daNpcCdn3_c::waita, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq02_funcTbl[2] = {&daNpcCdn3_c::waita, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq03_funcTbl[2] = {&daNpcCdn3_c::talka, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq03_funcTbl[2] = {&daNpcCdn3_c::talka, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq04_funcTbl[2] = {&daNpcCdn3_c::runb, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq04_funcTbl[2] = {&daNpcCdn3_c::runb, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq05_funcTbl[4] = {&daNpcCdn3_c::turnr, &daNpcCdn3_c::waita,
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq05_funcTbl[4] = {&daNpcCdn3_c::turnr, &daNpcCdn3_c::waita,
                                                         &daNpcCdn3_c::talka, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq06_funcTbl[4] = {&daNpcCdn3_c::turnl, &daNpcCdn3_c::waita,
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq06_funcTbl[4] = {&daNpcCdn3_c::turnl, &daNpcCdn3_c::waita,
                                                         &daNpcCdn3_c::talka, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq07_funcTbl[2] = {&daNpcCdn3_c::waitwall, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq07_funcTbl[2] = {&daNpcCdn3_c::waitwall, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq08_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq08_funcTbl[7] = {
     &daNpcCdn3_c::talkwall,
     &daNpcCdn3_c::waitwall,
     &daNpcCdn3_c::talkbwall,
@@ -1553,25 +1553,25 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq08_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq09_funcTbl[2] = {&daNpcCdn3_c::talkb, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq09_funcTbl[2] = {&daNpcCdn3_c::talkb, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq10_funcTbl[2] = {&daNpcCdn3_c::talkc, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq10_funcTbl[2] = {&daNpcCdn3_c::talkc, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq11_funcTbl[6] = {&daNpcCdn3_c::talka, &daNpcCdn3_c::waita,
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq11_funcTbl[6] = {&daNpcCdn3_c::talka, &daNpcCdn3_c::waita,
                                                         &daNpcCdn3_c::talkb, &daNpcCdn3_c::waitb,
                                                         &daNpcCdn3_c::talkc, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq12_funcTbl[2] = {&daNpcCdn3_c::waitb, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq12_funcTbl[2] = {&daNpcCdn3_c::waitb, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq13_funcTbl[6] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq13_funcTbl[6] = {
     &daNpcCdn3_c::browsea, &daNpcCdn3_c::browseb, &daNpcCdn3_c::talka,
     &daNpcCdn3_c::talkb,   &daNpcCdn3_c::waita,   NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq14_funcTbl[2] = {&daNpcCdn3_c::walkb, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq14_funcTbl[2] = {&daNpcCdn3_c::walkb, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq15_funcTbl[2] = {&daNpcCdn3_c::sitwaita, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq15_funcTbl[2] = {&daNpcCdn3_c::sitwaita, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq16_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq16_funcTbl[7] = {
     &daNpcCdn3_c::sittalka,
     &daNpcCdn3_c::sitwaita,
     &daNpcCdn3_c::sittalkab,
@@ -1581,14 +1581,14 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq16_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq17_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq17_funcTbl[2] = {
     &daNpcCdn3_c::playm,
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq18_funcTbl[2] = {&daNpcCdn3_c::sitwaitb, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq18_funcTbl[2] = {&daNpcCdn3_c::sitwaitb, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq19_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq19_funcTbl[7] = {
     &daNpcCdn3_c::sittalkb,
     &daNpcCdn3_c::sitwaitb,
     &daNpcCdn3_c::sittalkbb,
@@ -1598,14 +1598,14 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq19_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq20_funcTbl[2] = {&daNpcCdn3_c::looka, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq20_funcTbl[2] = {&daNpcCdn3_c::looka, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq21_funcTbl[2] = {&daNpcCdn3_c::lookb, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq21_funcTbl[2] = {&daNpcCdn3_c::lookb, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq22_funcTbl[4] = {&daNpcCdn3_c::looka, &daNpcCdn3_c::lookb,
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq22_funcTbl[4] = {&daNpcCdn3_c::looka, &daNpcCdn3_c::lookb,
                                                         &daNpcCdn3_c::waita, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq23_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq23_funcTbl[7] = {
     &daNpcCdn3_c::talka,
     &daNpcCdn3_c::waita,
     &daNpcCdn3_c::talkb,
@@ -1615,11 +1615,11 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq23_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq24_funcTbl[5] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq24_funcTbl[5] = {
     &daNpcCdn3_c::talkb, &daNpcCdn3_c::talka, &daNpcCdn3_c::talkc, &daNpcCdn3_c::waita, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq25_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq25_funcTbl[7] = {
     &daNpcCdn3_c::browsea,
     &daNpcCdn3_c::browseb,
     &daNpcCdn3_c::talka,
@@ -1629,37 +1629,37 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq25_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq26_funcTbl[3] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq26_funcTbl[3] = {
     &daNpcCdn3_c::browsea,
     &daNpcCdn3_c::browseb,
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq27_funcTbl[2] = {&daNpcCdn3_c::dance, NULL};
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq27_funcTbl[2] = {&daNpcCdn3_c::dance, NULL};
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq28_funcTbl[3] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq28_funcTbl[3] = {
     &daNpcCdn3_c::ladytalka,
     &daNpcCdn3_c::normtalka,
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq29_funcTbl[3] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq29_funcTbl[3] = {
     &daNpcCdn3_c::ladytalkb,
     &daNpcCdn3_c::normtalkb,
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq30_funcTbl[6] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq30_funcTbl[6] = {
     &daNpcCdn3_c::talka, &daNpcCdn3_c::ladytalka, &daNpcCdn3_c::waita,
     &daNpcCdn3_c::talkb, &daNpcCdn3_c::waita,     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq31_funcTbl[6] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq31_funcTbl[6] = {
     &daNpcCdn3_c::waita, &daNpcCdn3_c::ladytalkb, &daNpcCdn3_c::talka,
     &daNpcCdn3_c::waita, &daNpcCdn3_c::talkb,     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq32_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq32_funcTbl[7] = {
     &daNpcCdn3_c::talka,
     &daNpcCdn3_c::ladytalka,
     &daNpcCdn3_c::waita,
@@ -1669,7 +1669,7 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq32_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq33_funcTbl[7] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq33_funcTbl[7] = {
     &daNpcCdn3_c::waita,
     &daNpcCdn3_c::ladytalkb,
     &daNpcCdn3_c::talka,
@@ -1679,50 +1679,50 @@ daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq33_funcTbl[7] = {
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq34_funcTbl[9] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq34_funcTbl[9] = {
     &daNpcCdn3_c::talka,     &daNpcCdn3_c::ladytalka, &daNpcCdn3_c::ladytalkb,
     &daNpcCdn3_c::waita,     &daNpcCdn3_c::talkb,     &daNpcCdn3_c::waita,
     &daNpcCdn3_c::normtalka, &daNpcCdn3_c::normtalkb, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq35_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq35_funcTbl[2] = {
     &daNpcCdn3_c::sellme,
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq36_funcTbl[4] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq36_funcTbl[4] = {
     &daNpcCdn3_c::ladytalkb,
     &daNpcCdn3_c::talka,
     &daNpcCdn3_c::waita,
     NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq37_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq37_funcTbl[2] = {
     &daNpcCdn3_c::sing, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq38_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq38_funcTbl[2] = {
     &daNpcCdn3_c::sittalka, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq39_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq39_funcTbl[2] = {
     &daNpcCdn3_c::sittalkab, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq40_funcTbl[3] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq40_funcTbl[3] = {
     &daNpcCdn3_c::sittalka, &daNpcCdn3_c::sittalkab, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq41_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq41_funcTbl[2] = {
     &daNpcCdn3_c::sittalkb, NULL,
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq42_funcTbl[2] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq42_funcTbl[2] = {
     &daNpcCdn3_c::sittalkbb, NULL,
 
 };
 
-daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq43_funcTbl[3] = {
+DUSK_GAME_DATA daNpcCdn3_c::seqFunc daNpcCdn3_c::m_seq43_funcTbl[3] = {
     &daNpcCdn3_c::sittalkb, &daNpcCdn3_c::sittalkbb, NULL,
 };
 
diff --git a/src/d/actor/d_a_npc_chat.cpp b/src/d/actor/d_a_npc_chat.cpp
index d39f139281..e9f4412b8c 100644
--- a/src/d/actor/d_a_npc_chat.cpp
+++ b/src/d/actor/d_a_npc_chat.cpp
@@ -2182,7 +2182,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Chat";
 
 static NPC_CHAT_HIO_CLASS l_HIO;
 
-daNpcChat_c::eventFunc DUSK_CONST daNpcChat_c::mEvtSeqList[1] = {
+DUSK_GAME_DATA daNpcChat_c::eventFunc DUSK_CONST daNpcChat_c::mEvtSeqList[1] = {
     NULL,
 };
 
@@ -2218,7 +2218,7 @@ static DUSK_CONSTEXPR anmTblPrm const l_objTWTbl[13] = {
     {"objectTW", -1},
 };
 
-daNpcChat_HIOParam const daNpcChat_Param_c::m = {
+DUSK_GAME_DATA daNpcChat_HIOParam const daNpcChat_Param_c::m = {
     55.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_chin.cpp b/src/d/actor/d_a_npc_chin.cpp
index 463efb8c9d..ae629e5d34 100644
--- a/src/d/actor/d_a_npc_chin.cpp
+++ b/src/d/actor/d_a_npc_chin.cpp
@@ -26,7 +26,7 @@ static s16 const sLoadResPat_Normal[6] = {0, 1, 2, 4, 5, -1};
 
 static s16 const sLoadResPat_Tw[3] = {0, 3, -1};
 
-daNpcChin_HIOParam const daNpcChin_Param_c::m = {
+DUSK_GAME_DATA daNpcChin_HIOParam const daNpcChin_Param_c::m = {
     40.0f, -3.0f, 1.0f, 400.0f, 255.0f, 130.0f, 35.0f, 30.0f,
     0.0f, 0.0f, 10.0f, -10.0f, 30.0f, -10.0f, 45.0f, -45.0f,
     0.6f, 12.0f,
@@ -130,7 +130,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[8] = {
 
 static u8 lit_3861[12];
 
-daNpcChin_c::eventFunc daNpcChin_c::mEvtSeqList[8] = {
+DUSK_GAME_DATA daNpcChin_c::eventFunc daNpcChin_c::mEvtSeqList[8] = {
     NULL,
     &daNpcChin_c::_Evt_GameStart,
     &daNpcChin_c::_Evt_GameFailed,
@@ -1804,8 +1804,23 @@ int daNpcChin_c::_Evt_GameSucceed_CutMain(const int& param_0) {
                 itemId1 = 0;
             }
 
+#if TARGET_PC
+            const char* itemCheckName = nullptr;
+            u32 itemGiveTag = 0;
+            if (itemId1 == dItemNo_ARROW_LV2_e) {
+                itemCheckName = "star_reward_1";
+            } else if (itemId1 == dItemNo_ARROW_LV3_e) {
+                itemCheckName = "star_reward_2";
+            }
+            if (itemCheckName != nullptr) {
+                const auto itemCheck =
+                    dusk::mods::item_check_commit(itemCheckName, itemId1, this);
+                itemId1 = itemCheck.itemNo;
+                itemGiveTag = itemCheck.tag;
+            }
+#endif
             fpc_ProcID itemId2 = fopAcM_createItemForPresentDemo(&current.pos, itemId1, 0, -1, -1,
-                                                                 0, 0);
+                0, 0 IF_DUSK_ARG(itemGiveTag));
             if (itemId2 != -1) {
                 dComIfGp_event_setItemPartnerId(itemId2);
             }
diff --git a/src/d/actor/d_a_npc_clerka.cpp b/src/d/actor/d_a_npc_clerka.cpp
index 3232afc7f7..16fb887636 100644
--- a/src/d/actor/d_a_npc_clerka.cpp
+++ b/src/d/actor/d_a_npc_clerka.cpp
@@ -9,7 +9,7 @@
 #include "d/d_msg_object.h"
 #include <cstring>
 
-const daNpc_clerkA_HIOParam daNpc_clerkA_Param_c::m = {
+DUSK_GAME_DATA const daNpc_clerkA_HIOParam daNpc_clerkA_Param_c::m = {
     220.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
@@ -115,9 +115,9 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {6, -9, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_clerkA_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_clerkA_c::mCutNameList[1] = {""};
 
-daNpc_clerkA_c::cutFunc DUSK_CONST daNpc_clerkA_c::mCutList[1] = {NULL};
+DUSK_GAME_DATA daNpc_clerkA_c::cutFunc DUSK_CONST daNpc_clerkA_c::mCutList[1] = {NULL};
 
 daNpc_clerkA_c::~daNpc_clerkA_c() {
     deleteObject();
diff --git a/src/d/actor/d_a_npc_clerkb.cpp b/src/d/actor/d_a_npc_clerkb.cpp
index fdf4ec9ace..38c75135f6 100644
--- a/src/d/actor/d_a_npc_clerkb.cpp
+++ b/src/d/actor/d_a_npc_clerkb.cpp
@@ -9,7 +9,7 @@
 #include "d/d_msg_object.h"
 #include <cstring>
 
-const daNpc_clerkB_HIOParam daNpc_clerkB_Param_c::m = {
+DUSK_GAME_DATA const daNpc_clerkB_HIOParam daNpc_clerkB_Param_c::m = {
     220.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
@@ -120,9 +120,9 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {8, -1, 1}, {2, 0, 0},  {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_clerkB_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_clerkB_c::mCutNameList[1] = {""};
 
-daNpc_clerkB_c::cutFunc DUSK_CONST daNpc_clerkB_c::mCutList[1] = {NULL};
+DUSK_GAME_DATA daNpc_clerkB_c::cutFunc DUSK_CONST daNpc_clerkB_c::mCutList[1] = {NULL};
 
 daNpc_clerkB_c::~daNpc_clerkB_c() {
     deleteObject();
diff --git a/src/d/actor/d_a_npc_clerkt.cpp b/src/d/actor/d_a_npc_clerkt.cpp
index 4d8d90aa29..f305a5f8a3 100644
--- a/src/d/actor/d_a_npc_clerkt.cpp
+++ b/src/d/actor/d_a_npc_clerkt.cpp
@@ -9,7 +9,7 @@
 #include "d/d_msg_object.h"
 #include <cstring>
 
-const daNpcClerkt_HIOParam daNpcClerkt_Param_c::m = {
+DUSK_GAME_DATA const daNpcClerkt_HIOParam daNpcClerkt_Param_c::m = {
     120.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
@@ -108,9 +108,9 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpcClerkT_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpcClerkT_c::mCutNameList[1] = {""};
 
-daNpcClerkT_c::cutFunc DUSK_CONST daNpcClerkT_c::mCutList[1] = {NULL};
+DUSK_GAME_DATA daNpcClerkT_c::cutFunc DUSK_CONST daNpcClerkT_c::mCutList[1] = {NULL};
 
 daNpcClerkT_c::~daNpcClerkT_c() {
     deleteObject();
diff --git a/src/d/actor/d_a_npc_coach.cpp b/src/d/actor/d_a_npc_coach.cpp
index 30bab6e34b..5b395f38c8 100644
--- a/src/d/actor/d_a_npc_coach.cpp
+++ b/src/d/actor/d_a_npc_coach.cpp
@@ -200,7 +200,7 @@ static int jointRearWheelCallBack(J3DJoint* i_joint, int param_2) {
     return 1;
 }
 
-daNpcCoach_Attr_c const daNpcCoach_c::M_attr = {
+DUSK_GAME_DATA daNpcCoach_Attr_c const daNpcCoach_c::M_attr = {
     -3.0f,
     -200.0f,
     -0.25f,
diff --git a/src/d/actor/d_a_npc_doc.cpp b/src/d/actor/d_a_npc_doc.cpp
index cd05d05835..f75b4d4189 100644
--- a/src/d/actor/d_a_npc_doc.cpp
+++ b/src/d/actor/d_a_npc_doc.cpp
@@ -84,13 +84,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {5, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Doc_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Doc_c::mCutNameList[1] = {""};
 
-daNpc_Doc_c::cutFunc DUSK_CONST daNpc_Doc_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_Doc_c::cutFunc DUSK_CONST daNpc_Doc_c::mCutList[1] = {
     NULL,
 };
 
-const daNpc_Doc_HIOParam daNpc_Doc_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Doc_HIOParam daNpc_Doc_Param_c::m = {
     140.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_doorboy.cpp b/src/d/actor/d_a_npc_doorboy.cpp
index 4203faa054..ca2983aa0c 100644
--- a/src/d/actor/d_a_npc_doorboy.cpp
+++ b/src/d/actor/d_a_npc_doorboy.cpp
@@ -117,11 +117,11 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "DoorBoy";
 
 static NPC_DOORBOY_HIO_CLASS l_HIO;
 
-daNpcDoorBoy_c::EventFn DUSK_CONST daNpcDoorBoy_c::mEvtSeqList[1] = {
+DUSK_GAME_DATA daNpcDoorBoy_c::EventFn DUSK_CONST daNpcDoorBoy_c::mEvtSeqList[1] = {
     NULL
 };
 
-daNpcDoorBoy_HIOParam const daNpcDoorBoy_Param_c::m = {
+DUSK_GAME_DATA daNpcDoorBoy_HIOParam const daNpcDoorBoy_Param_c::m = {
     55.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_drainSol.cpp b/src/d/actor/d_a_npc_drainSol.cpp
index 9e1cb1d277..e8b3ca24b6 100644
--- a/src/d/actor/d_a_npc_drainSol.cpp
+++ b/src/d/actor/d_a_npc_drainSol.cpp
@@ -23,7 +23,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_arcNames[2] = {
     "DrainSol2",
 };
 
-const daNpcDrSol_HIOParam daNpcDrSol_Param_c::m = {
+DUSK_GAME_DATA const daNpcDrSol_HIOParam daNpcDrSol_Param_c::m = {
     40.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_fairy.cpp b/src/d/actor/d_a_npc_fairy.cpp
index 9f4dbbfd1a..0b911973e4 100644
--- a/src/d/actor/d_a_npc_fairy.cpp
+++ b/src/d/actor/d_a_npc_fairy.cpp
@@ -145,7 +145,7 @@ enum Type {
     /* 0x4 */ TYPE_50F,
 };
 
-const daNpc_Fairy_HIOParam daNpc_Fairy_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Fairy_HIOParam daNpc_Fairy_Param_c::m = {
     190.0f,
     -3.0f,
     1.0f,
@@ -459,7 +459,7 @@ static DUSK_CONSTEXPR daNpcT_evtData_c l_evtList[18] = {
     {"RETURN_CANCEL", 1},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Fairy_c::mCutNameList[18] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Fairy_c::mCutNameList[18] = {
     "",
     "APPEAR_10F_01",
     "APPEAR_10F_02",
@@ -480,7 +480,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Fairy_c::mCutNameList[18] = {
     "RETURN_CANCEL",
 };
 
-daNpc_Fairy_c::cutFunc DUSK_CONST daNpc_Fairy_c::mCutList[18] = {
+DUSK_GAME_DATA daNpc_Fairy_c::cutFunc DUSK_CONST daNpc_Fairy_c::mCutList[18] = {
     NULL,
     &daNpc_Fairy_c::cutAppear_10F_01,
     &daNpc_Fairy_c::cutAppear_10F_02,
@@ -1333,7 +1333,9 @@ void daNpc_Fairy_c::PresentDemoCall() {
         item_no = 0;
     }
 
-    fpc_ProcID id = fopAcM_createItemForPresentDemo(&current.pos, item_no, 0, -1, -1, NULL, NULL);
+    DUSK_ITEM_CHECK("fairy_reward:D_SB01", item_no, this);
+    fpc_ProcID id = fopAcM_createItemForPresentDemo(&current.pos, item_no, 0, -1, -1, NULL,
+        NULL DUSK_GIVE_TAG("fairy_reward:D_SB01"));
     if (id != fpcM_ERROR_PROCESS_ID_e) {
         dComIfGp_event_setItemPartnerId(id);
     }
diff --git a/src/d/actor/d_a_npc_fairy_seirei.cpp b/src/d/actor/d_a_npc_fairy_seirei.cpp
index 4681234346..f1a40fae6d 100644
--- a/src/d/actor/d_a_npc_fairy_seirei.cpp
+++ b/src/d/actor/d_a_npc_fairy_seirei.cpp
@@ -53,16 +53,16 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-DUSK_CONST char* daNpc_FairySeirei_c::mCutNameList[1] = {
+DUSK_GAME_DATA DUSK_CONST char* daNpc_FairySeirei_c::mCutNameList[1] = {
     "",
 };
 
-DUSK_CONST daNpc_FairySeirei_c::cutFunc daNpc_FairySeirei_c::mCutList[1] = {
+DUSK_GAME_DATA DUSK_CONST daNpc_FairySeirei_c::cutFunc daNpc_FairySeirei_c::mCutList[1] = {
     NULL,
 };
 
 
-const daNpc_FairySeirei_HIOParam daNpc_FairySeirei_Param_c::m = {
+DUSK_GAME_DATA const daNpc_FairySeirei_HIOParam daNpc_FairySeirei_Param_c::m = {
     600.0f, 0.0f, 1.0f, 4000.0f, 255.0f, 200.0f, 0.0f, 60.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
     0.0f,   0.0f, 0.0f, 0.0f,    0,      0,      0,    0,     0.0f, 0.0f, 0.0f, 0.0f, 0,    0,
     0,      0,    0,    0,       0,      0.0f,   0.0f, 0.0f,  0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
diff --git a/src/d/actor/d_a_npc_gnd.cpp b/src/d/actor/d_a_npc_gnd.cpp
index d4f0e84fc0..b88eb94fe9 100644
--- a/src/d/actor/d_a_npc_gnd.cpp
+++ b/src/d/actor/d_a_npc_gnd.cpp
@@ -49,11 +49,11 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Gnd_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Gnd_c::mCutNameList[1] = {""};
 
-daNpc_Gnd_c::cutFunc DUSK_CONST daNpc_Gnd_c::mCutList[1] = {NULL};
+DUSK_GAME_DATA daNpc_Gnd_c::cutFunc DUSK_CONST daNpc_Gnd_c::mCutList[1] = {NULL};
 
-const daNpc_Gnd_HIOParam daNpc_Gnd_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Gnd_HIOParam daNpc_Gnd_Param_c::m = {
     280.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_gra.cpp b/src/d/actor/d_a_npc_gra.cpp
index b1cf3a3d01..6f6293bed7 100644
--- a/src/d/actor/d_a_npc_gra.cpp
+++ b/src/d/actor/d_a_npc_gra.cpp
@@ -14,7 +14,11 @@
 #include "Z2AudioLib/Z2Instances.h"
 #include <cstring>
 
-const daNpc_grA_HIOParam daNpc_grA_Param_c::m = {
+#if TARGET_PC
+#include "mods/items.h"
+#endif
+
+DUSK_GAME_DATA const daNpc_grA_HIOParam daNpc_grA_Param_c::m = {
     {90.0f,  -4.0f,  1.0f,   850.0f,  255.0f, 280.0f, 40.0f, 100.0f, 0.0f, 0.0f, 20.0f,
      -20.0f, 40.0f,  -30.0f, 40.0f,   -40.0f, 0.4f,   12.0f, 4,      6,    6,    6,
      60.0f,  500.0f, 300.0f, -300.0f, 0x3c,   8,      0,     0,      0,    0,    0},
@@ -288,7 +292,7 @@ void daNpc_grA_HIO_c::genMessage(JORMContext* context) {
 }
 #endif
 
-char DUSK_CONST* DUSK_CONST daNpc_grA_c::mEvtCutNameList[12] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grA_c::mEvtCutNameList[12] = {
     "",
     "TALK_SPA",
     "GRDS_ROLL",
@@ -303,7 +307,7 @@ char DUSK_CONST* DUSK_CONST daNpc_grA_c::mEvtCutNameList[12] = {
     "ROLL_ROCK_CRASH",
 };
 
-daNpc_grA_c::cut_type DUSK_CONST daNpc_grA_c::mEvtCutList[] = {
+DUSK_GAME_DATA daNpc_grA_c::cut_type DUSK_CONST daNpc_grA_c::mEvtCutList[] = {
     NULL, 
     &daNpc_grA_c::ECut_talkSpa,
     &daNpc_grA_c::ECut_grDSRoll,
@@ -1323,7 +1327,7 @@ BOOL daNpc_grA_c::isDelete() {
             return FALSE;
         }
         fopAcM_createItemForBoss(&current.pos, 0x21, fopAcM_GetRoomNo(this), NULL, NULL, 0.0f, 0.0f,
-                                 0x80);
+                                 0x80 IF_DUSK_ARG(ITEM_CHECK_GORON_SPRINGWATER_RUSH));
         return TRUE;
     }
     return TRUE;
@@ -2812,7 +2816,7 @@ BOOL daNpc_grA_c::ECut_carrySpaWater(int i_staffID) {
             c.y += 200.0f;
             csXyz c2(0, fopAcM_searchPlayerAngleY(this), 0);
             fopAcM_createItemForBoss(&c, 0x21, fopAcM_GetRoomNo(this), &c2, NULL, 0.0f, 20.0f,
-                                     0x80);
+                                     0x80 IF_DUSK_ARG(ITEM_CHECK_GORON_SPRINGWATER_RUSH));
         } break;
         }
     }
@@ -4018,8 +4022,54 @@ BOOL daNpc_grA_c::talk(void*) {
         }
         if (r26 && talkProc(NULL, TRUE, NULL)) {
             if (mFlow.getEventId(&sp8) == 1) {
-                field_0x1480 =
-                    fopAcM_createItemForPresentDemo(&current.pos, sp8, 0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                const u8 originalItem = sp8;
+                u32 itemGiveTag = 0;
+                bool isItemCheck = false;
+                if (originalItem == dItemNo_BOMB_IN_BAG_e) {
+                    const auto itemCheck =
+                        dusk::mods::item_check_commit("goron_reward:F_SP113", originalItem, this);
+                    sp8 = itemCheck.itemNo;
+                    itemGiveTag = itemCheck.tag;
+                    isItemCheck = true;
+                } else {
+                    const char* stage = dComIfGp_getStartStageName();
+                    const bool isAdultGoronShop = (strcmp(stage, "R_SP160") == 0 && originalItem == dItemNo_HYLIA_SHIELD_e) ||
+                                                  (strcmp(stage, "F_SP116") == 0 && originalItem == dItemNo_ARROW_30_e);
+                    if (isAdultGoronShop) {
+                        const auto itemCheck = dusk::mods::item_check_commit(
+                            dusk::mods::item_give_tag_shop(originalItem), originalItem, this);
+                        sp8 = itemCheck.itemNo;
+                        itemGiveTag = itemCheck.tag;
+                        isItemCheck = true;
+                    }
+                }
+
+                if (isItemCheck && sp8 == dItemNo_NONE_e) {
+                    dusk::mods::item_check_complete({itemGiveTag, dItemNo_NONE_e}, this);
+                    r29 = 1;
+                    if (mType == 0xb) {
+                        field_0x1691 = 1;
+                    }
+                } else {
+                    field_0x1480 = fopAcM_createItemForPresentDemo(
+                        &current.pos, sp8, 0, -1, -1, NULL, NULL, itemGiveTag);
+                    if (field_0x1480 != fpcM_ERROR_PROCESS_ID_e) {
+                        s16 r25 =
+                            dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xff);
+                        dComIfGp_getEvent()->reset(this);
+                        fopAcM_orderChangeEventId(this, r25, 1, -1);
+                        field_0x9ec = 1;
+                        r29 = 1;
+                        mOrderNewEvt = 1;
+                        if (mType == 0xb) {
+                            field_0x1691 = 1;
+                        }
+                    }
+                }
+#else
+                field_0x1480 = fopAcM_createItemForPresentDemo(&current.pos, sp8, 0, -1, -1, NULL,
+                    NULL);
                 if (field_0x1480 != fpcM_ERROR_PROCESS_ID_e) {
                     s16 r25 = dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xff);
                     dComIfGp_getEvent()->reset(this);
@@ -4031,6 +4081,7 @@ BOOL daNpc_grA_c::talk(void*) {
                         field_0x1691 = 1;
                     }
                 }
+#endif
             } else {
                 if (mType == 0xa && field_0x1486 == 0 && daNpcF_chkEvtBit(0x187)) {
                     dComIfGp_getEvent()->reset(this);
diff --git a/src/d/actor/d_a_npc_grc.cpp b/src/d/actor/d_a_npc_grc.cpp
index d5b3bb4cc9..77aeb8016d 100644
--- a/src/d/actor/d_a_npc_grc.cpp
+++ b/src/d/actor/d_a_npc_grc.cpp
@@ -10,6 +10,10 @@
 #include "Z2AudioLib/Z2Instances.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "mods/items.h"
+#endif
+
 enum grC_RES_File_ID {
     /* BCK */
     /* 0x05 */ BCK_GRC_F_CHEERFUL = 0x5,
@@ -230,11 +234,11 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "grC";
 
-char DUSK_CONST* DUSK_CONST daNpc_grC_c::mEvtCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grC_c::mEvtCutNameList = "";
 
-daNpc_grC_c::EventFn DUSK_CONST daNpc_grC_c::mEvtCutList[1] = {NULL};
+DUSK_GAME_DATA daNpc_grC_c::EventFn DUSK_CONST daNpc_grC_c::mEvtCutList[1] = {NULL};
 
-daNpc_grC_HIOParam const daNpc_grC_Param_c::m = {
+DUSK_GAME_DATA daNpc_grC_HIOParam const daNpc_grC_Param_c::m = {
     40.0f,
     -3.0f,
     1.0f,
@@ -1476,8 +1480,27 @@ BOOL daNpc_grC_c::talk(void* param_1) {
                 rv = TRUE;
 
                 if (mFlow.getEventId(&i_itemNo) == 1) {
-                    mItemID = fopAcM_createItemForPresentDemo(&current.pos, i_itemNo, 0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                    const bool isCastleTownShop =
+                        strcmp(dComIfGp_getStartStageName(), "R_SP160") == 0 &&
+                        (i_itemNo == dItemNo_RED_BOTTLE_e || i_itemNo == dItemNo_OIL_BOTTLE_e);
+                    u32 itemGiveTag = 0;
+                    if (isCastleTownShop) {
+                        const auto itemCheck = dusk::mods::item_check_commit(
+                            dusk::mods::item_give_tag_shop(i_itemNo), i_itemNo, this);
+                        i_itemNo = itemCheck.itemNo;
+                        itemGiveTag = itemCheck.tag;
+                    }
 
+                    if (isCastleTownShop && i_itemNo == dItemNo_NONE_e) {
+                        dusk::mods::item_check_complete({itemGiveTag, dItemNo_NONE_e}, this);
+                    } else {
+                        mItemID = fopAcM_createItemForPresentDemo(
+                            &current.pos, i_itemNo, 0, -1, -1, NULL, NULL, itemGiveTag);
+                    }
+#else
+                    mItemID = fopAcM_createItemForPresentDemo(&current.pos, i_itemNo, 0, -1, -1, NULL, NULL);
+#endif
                     if (mItemID != fpcM_ERROR_PROCESS_ID_e) {
                         s16 i_eventID = dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xFF);
                         dComIfGp_getEvent()->reset(this);
diff --git a/src/d/actor/d_a_npc_grd.cpp b/src/d/actor/d_a_npc_grd.cpp
index 5278729e03..59be9c4e00 100644
--- a/src/d/actor/d_a_npc_grd.cpp
+++ b/src/d/actor/d_a_npc_grd.cpp
@@ -109,12 +109,12 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "grD";
 
-char DUSK_CONST* DUSK_CONST daNpc_Grd_c::mEvtCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Grd_c::mEvtCutNameList[2] = {
     "",
     "NOD_TO_GRZ",
 };
 
-daNpc_Grd_c::cutFunc DUSK_CONST daNpc_Grd_c::mEvtCutList[2] = {
+DUSK_GAME_DATA daNpc_Grd_c::cutFunc DUSK_CONST daNpc_Grd_c::mEvtCutList[2] = {
     NULL,
     &daNpc_Grd_c::ECut_nodToGrz,
 };
@@ -131,7 +131,7 @@ daNpc_Grd_c::~daNpc_Grd_c() {
     }
 }
 
-const daNpc_Grd_HIOParam daNpc_Grd_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Grd_HIOParam daNpc_Grd_Param_c::m = {
     230.0f,   // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
diff --git a/src/d/actor/d_a_npc_grm.cpp b/src/d/actor/d_a_npc_grm.cpp
index 25182af4cb..8e124b035d 100644
--- a/src/d/actor/d_a_npc_grm.cpp
+++ b/src/d/actor/d_a_npc_grm.cpp
@@ -122,19 +122,19 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0}, {-1, 0, 0}, {2, -1, 1}, {0, 0, 0},  {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_grM_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grM_c::mCutNameList[2] = {
     "",
     "TALK_SPA",
 };
 
-daNpc_grM_c::cutFunc DUSK_CONST daNpc_grM_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_grM_c::cutFunc DUSK_CONST daNpc_grM_c::mCutList[2] = {
     NULL,
     &daNpc_grM_c::cutTalkSpa,
 };
 
 static NPC_GRM_HIO_CLASS l_HIO;
 
-daNpc_grM_HIOParam const daNpc_grM_Param_c::m = {
+DUSK_GAME_DATA daNpc_grM_HIOParam const daNpc_grM_Param_c::m = {
     300.0f, -3.0f,  1.0f,   600.0f, 255.0f, 260.0f, 35.0f, 70.0f, 0.0f, 0.0f,  30.0f,
     -30.0f, 30.0f,  -10.0f, 20.0f,  -20.0f, 0.6f,   12.0f, 8,     6,    8,     6,
     0.0f,   0.0f,   0.0f,   0.0f,   60,     8,      0,     0,     0,    false, false,
diff --git a/src/d/actor/d_a_npc_grmc.cpp b/src/d/actor/d_a_npc_grmc.cpp
index 1d5ed0d29a..4ac574b021 100644
--- a/src/d/actor/d_a_npc_grmc.cpp
+++ b/src/d/actor/d_a_npc_grmc.cpp
@@ -149,9 +149,9 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {7, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_grMC_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grMC_c::mCutNameList = "";
 
-daNpc_grMC_c::cutFunc DUSK_CONST daNpc_grMC_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_grMC_c::cutFunc DUSK_CONST daNpc_grMC_c::mCutList[1] = {
     NULL,
 };
 
@@ -171,7 +171,7 @@ daNpc_grMC_c::~daNpc_grMC_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-daNpc_grMC_HIOParam const daNpc_grMC_Param_c::m = {
+DUSK_GAME_DATA daNpc_grMC_HIOParam const daNpc_grMC_Param_c::m = {
     140.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_gro.cpp b/src/d/actor/d_a_npc_gro.cpp
index e98fe7f8c0..e1b9e457de 100644
--- a/src/d/actor/d_a_npc_gro.cpp
+++ b/src/d/actor/d_a_npc_gro.cpp
@@ -325,13 +325,13 @@ void daNpc_grO_HIO_c::genMessage(JORMContext* ctx) {
 }
 #endif
 
-char DUSK_CONST* DUSK_CONST daNpc_grO_c::mEvtCutNameList[3] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grO_c::mEvtCutNameList[3] = {
     "",
     "BOKIN_FINISH",
     "PUSHOUT",
 };
 
-daNpc_grO_c::cutFunc DUSK_CONST daNpc_grO_c::mEvtCutList[3] = {
+DUSK_GAME_DATA daNpc_grO_c::cutFunc DUSK_CONST daNpc_grO_c::mEvtCutList[3] = {
     NULL,
     &daNpc_grO_c::ECut_bokinFinish,
     &daNpc_grO_c::cutPushOut,
@@ -355,7 +355,7 @@ daNpc_grO_c::~daNpc_grO_c() {
     #endif
 }
 
-daNpc_grO_HIOParam const daNpc_grO_Param_c::m = {
+DUSK_GAME_DATA daNpc_grO_HIOParam const daNpc_grO_Param_c::m = {
     160.0f,
     -3.0f,
     1.0f,
@@ -1681,7 +1681,9 @@ int daNpc_grO_c::talk(void* param_1) {
             if (facePlayerFlag && talkProc(NULL, TRUE, NULL)) {
                 if (mType == TYPE_MINES) {
                     if (mFlow.getEventId(&itemId) == 1) {
-                        mItemID = fopAcM_createItemForPresentDemo(&current.pos, itemId, 0, -1, -1, NULL, NULL);
+                        DUSK_ITEM_CHECK("key_shard_2:D_MN04", itemId, this);
+                        mItemID = fopAcM_createItemForPresentDemo(&current.pos, itemId, 0, -1, -1,
+                            NULL, NULL DUSK_GIVE_TAG("key_shard_2:D_MN04"));
                         if (mItemID != fpcM_ERROR_PROCESS_ID_e) {
                             s16 eventIdx = dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xFF);
                             dComIfGp_getEvent()->reset(this);
diff --git a/src/d/actor/d_a_npc_grr.cpp b/src/d/actor/d_a_npc_grr.cpp
index 4eac7a5930..4a978c586e 100644
--- a/src/d/actor/d_a_npc_grr.cpp
+++ b/src/d/actor/d_a_npc_grr.cpp
@@ -199,13 +199,13 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {NULL};
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "grR";
 
-char DUSK_CONST* DUSK_CONST daNpc_grR_c::mEvtCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grR_c::mEvtCutNameList = "";
 
-daNpc_grR_c::cutFunc DUSK_CONST daNpc_grR_c::mEvtCutList[1] = {
+DUSK_GAME_DATA daNpc_grR_c::cutFunc DUSK_CONST daNpc_grR_c::mEvtCutList[1] = {
     NULL,
 };
 
-daNpc_grR_HIOParam const daNpc_grR_Param_c::m = {
+DUSK_GAME_DATA daNpc_grR_HIOParam const daNpc_grR_Param_c::m = {
     60.0f,
     -3.0f,
     1.0f,
@@ -1338,7 +1338,9 @@ int daNpc_grR_c::talk(void* param_1) {
             if (bVar1 && talkProc(NULL, TRUE, NULL)) {
                 if (mType == TYPE_0) {
                     if (mFlow.getEventId(&i_itemNo) == 1) {
-                        mItemID = fopAcM_createItemForPresentDemo(&current.pos, i_itemNo, 0, -1, -1, NULL, NULL);
+                        DUSK_ITEM_CHECK("key_shard_3:D_MN04", i_itemNo, this);
+                        mItemID = fopAcM_createItemForPresentDemo(&current.pos, i_itemNo, 0, -1, -1,
+                            NULL, NULL DUSK_GIVE_TAG("key_shard_3:D_MN04"));
 
                         if (mItemID != fpcM_ERROR_PROCESS_ID_e) {
                             s16 i_eventID = dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xFF);
diff --git a/src/d/actor/d_a_npc_grs.cpp b/src/d/actor/d_a_npc_grs.cpp
index bdac5ebf1c..462f77b8a7 100644
--- a/src/d/actor/d_a_npc_grs.cpp
+++ b/src/d/actor/d_a_npc_grs.cpp
@@ -93,12 +93,12 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "grS";
 
 static NPC_GRS_HIO_CLASS l_HIO;
 
-char DUSK_CONST* DUSK_CONST daNpc_grS_c::mEvtCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_grS_c::mEvtCutNameList[2] = {
     "",
     "PUSHOUT",
 };
 
-daNpc_grS_c::cutFunc DUSK_CONST daNpc_grS_c::mEvtCutList[2] = {
+DUSK_GAME_DATA daNpc_grS_c::cutFunc DUSK_CONST daNpc_grS_c::mEvtCutList[2] = {
     NULL,
     &daNpc_grS_c::cutPushOut,
 };
@@ -122,7 +122,7 @@ daNpc_grS_c::~daNpc_grS_c() {
 #endif
 }
 
-const daNpc_grS_HIOParam daNpc_grS_Param_c::m = {
+DUSK_GAME_DATA const daNpc_grS_HIOParam daNpc_grS_Param_c::m = {
     120.0f, -3.0f, 1.0f, 600.0f, 255.0f, 120.0f, 35.0f, 60.0f,
     0.0f, 0.0f, 10.0f, -10.0f, 30.0f, -30.0f, 45.0f, -45.0f,
     0.6f, 12.0f,
@@ -1190,8 +1190,9 @@ int daNpc_grS_c::talk(void* param_0) {
         if (unkFlag1 && talkProc(NULL, 1, NULL)) {
             if (mType == 0) {
                 if (mFlow.getEventId(&unkInt2) == 1) {
-                    mPresentItemId =
-                        fopAcM_createItemForPresentDemo(&current.pos, unkInt2, 0, -1, -1, 0, 0);
+                    DUSK_ITEM_CHECK("key_shard_1:D_MN04", unkInt2, this);
+                    mPresentItemId = fopAcM_createItemForPresentDemo(&current.pos, unkInt2, 0, -1,
+                        -1, 0, 0 DUSK_GIVE_TAG("key_shard_1:D_MN04"));
 
                     if (mPresentItemId != fpcM_ERROR_PROCESS_ID_e) {
                         s16 eventIdx =
diff --git a/src/d/actor/d_a_npc_grz.cpp b/src/d/actor/d_a_npc_grz.cpp
index 3cbd23f9ac..bd376a84ce 100644
--- a/src/d/actor/d_a_npc_grz.cpp
+++ b/src/d/actor/d_a_npc_grz.cpp
@@ -354,7 +354,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNames[6] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "grZ";
 
-char DUSK_CONST* DUSK_CONST daNpc_Grz_c::mEvtCutNameList[7] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Grz_c::mEvtCutNameList[7] = {
     "",
     "WAIT",
     "REBIRTH",
@@ -364,7 +364,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Grz_c::mEvtCutNameList[7] = {
     "STONE_SMASH_SKIP",
 };
 
-daNpc_Grz_c::cutFunc DUSK_CONST daNpc_Grz_c::mEvtCutList[7] = {
+DUSK_GAME_DATA daNpc_Grz_c::cutFunc DUSK_CONST daNpc_Grz_c::mEvtCutList[7] = {
     NULL,
     &daNpc_Grz_c::doWaitCut,
     &daNpc_Grz_c::doRebirthCut,
@@ -406,7 +406,7 @@ daNpc_Grz_c::~daNpc_Grz_c() {
 #endif
 }
 
-daNpc_Grz_HIOParam const daNpc_Grz_Param_c::m = {
+DUSK_GAME_DATA daNpc_Grz_HIOParam const daNpc_Grz_Param_c::m = {
     130.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_guard.cpp b/src/d/actor/d_a_npc_guard.cpp
index b0836bd6d1..8ad17ea9c8 100644
--- a/src/d/actor/d_a_npc_guard.cpp
+++ b/src/d/actor/d_a_npc_guard.cpp
@@ -35,7 +35,7 @@ static int createHeapCallBack(fopAc_ac_c* i_this) {
     return static_cast<daNpcGuard_c*>(i_this)->createHeap();
 }
 
-daNpcGuard_c::actionFunc daNpcGuard_c::ActionTable[7][2] = {
+DUSK_GAME_DATA daNpcGuard_c::actionFunc daNpcGuard_c::ActionTable[7][2] = {
     {&daNpcGuard_c::initPath, &daNpcGuard_c::executePath},
     {&daNpcGuard_c::initRun, &daNpcGuard_c::executeRun},
     {&daNpcGuard_c::initFightWait, &daNpcGuard_c::executeFightWait},
diff --git a/src/d/actor/d_a_npc_gwolf.cpp b/src/d/actor/d_a_npc_gwolf.cpp
index b0fd2d3838..fb4d1d8d17 100644
--- a/src/d/actor/d_a_npc_gwolf.cpp
+++ b/src/d/actor/d_a_npc_gwolf.cpp
@@ -191,7 +191,7 @@ static DUSK_CONSTEXPR s16 l_warpAppearFlag[7] = {
     0x01DD, // dSv_event_flag_c::F_0477 - Secret techniques - Distant howling complete (for secret technique 7)
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_GWolf_c::mEvtCutNameList[5] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_GWolf_c::mEvtCutNameList[5] = {
     "",
     "ATTACK_WARP",
     "ATTACK_WARP_HORSE",
@@ -199,7 +199,7 @@ char DUSK_CONST* DUSK_CONST daNpc_GWolf_c::mEvtCutNameList[5] = {
     "MEET_GWOLFA",
 };
 
-daNpc_GWolf_c::cutFunc DUSK_CONST daNpc_GWolf_c::mEvtCutList[5] = {
+DUSK_GAME_DATA daNpc_GWolf_c::cutFunc DUSK_CONST daNpc_GWolf_c::mEvtCutList[5] = {
     NULL,
     &daNpc_GWolf_c::ECut_attackWarp,
     &daNpc_GWolf_c::ECut_attackWarpHorse,
@@ -207,7 +207,7 @@ daNpc_GWolf_c::cutFunc DUSK_CONST daNpc_GWolf_c::mEvtCutList[5] = {
     &daNpc_GWolf_c::ECut_meetGWolf,
 };
 
-daNpc_GWolf_HIOParam const daNpc_GWolf_Param_c::m = {
+DUSK_GAME_DATA daNpc_GWolf_HIOParam const daNpc_GWolf_Param_c::m = {
     30.0f,
     -4.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_hanjo.cpp b/src/d/actor/d_a_npc_hanjo.cpp
index c1bb5d72c1..2b5284e69d 100644
--- a/src/d/actor/d_a_npc_hanjo.cpp
+++ b/src/d/actor/d_a_npc_hanjo.cpp
@@ -15,7 +15,9 @@
 #include "Z2AudioLib/Z2Instances.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static DUSK_CONSTEXPR int l_bmdData[4][2] = {
     {14, 1}, {26, 2},
@@ -121,7 +123,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},  {-1, 0, 0},  {8, -1, 0},  {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0},  {9, -1, 0},
     {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0}};
 
-char DUSK_CONST* DUSK_CONST daNpc_Hanjo_c::mCutNameList[6] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Hanjo_c::mCutNameList[6] = {
     "",
     "CONVERSATION_ABOUT_SARU",
     "CONVERSATION",
@@ -130,7 +132,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Hanjo_c::mCutNameList[6] = {
     "DIVE",
 };
 
-daNpc_Hanjo_c::cutFunc DUSK_CONST daNpc_Hanjo_c::mCutList[6] = {
+DUSK_GAME_DATA daNpc_Hanjo_c::cutFunc DUSK_CONST daNpc_Hanjo_c::mCutList[6] = {
     NULL,
     &daNpc_Hanjo_c::cutConversationAboutSaru,
     &daNpc_Hanjo_c::cutConversation,
@@ -139,11 +141,11 @@ daNpc_Hanjo_c::cutFunc DUSK_CONST daNpc_Hanjo_c::mCutList[6] = {
     &daNpc_Hanjo_c::cutDive,
 };
 
-dCcD_SrcSph DUSK_CONST daNpc_Hanjo_c::mStoneCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph DUSK_CONST daNpc_Hanjo_c::mStoneCcDSph = {
     daNpc_Hanjo_c::mStoneCcDObjInfo, {}
 };
 
-daNpc_Hanjo_HIOParam const daNpc_Hanjo_Param_c::m = {
+DUSK_GAME_DATA daNpc_Hanjo_HIOParam const daNpc_Hanjo_Param_c::m = {
     160.0f, -3.0f, 1.0f, 400.0f, 
     255.0f, 160.0f, 35.0f, 30.0f, 0.0f, 0.0f, 10.0f, -10.0f, 30.0f, -10.0f, 45.0f,
     -45.0f, 0.6f, 12.0f, 3, 6, 5, 6, 110.0f, 500.0f, 300.0f, -300.0f, 60, 8, 0, 0, 0, 0, 0,
@@ -152,7 +154,7 @@ daNpc_Hanjo_HIOParam const daNpc_Hanjo_Param_c::m = {
      80.0f, 65.0f, 4.0f, 600.0f, 136.0f, 0x500, 90, 90, 2,
 };
 
-dCcD_SrcGObjInf const daNpc_Hanjo_c::mStoneCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daNpc_Hanjo_c::mStoneCcDObjInfo = {
     {0, {{0, 0, 0}, {0, 0}, {0x79}}},
     {0, 0, 0, 0, {0}},
     {0, 0, 0, 0, {0}},
diff --git a/src/d/actor/d_a_npc_hoz.cpp b/src/d/actor/d_a_npc_hoz.cpp
index 012112f266..48e3fe4f5e 100644
--- a/src/d/actor/d_a_npc_hoz.cpp
+++ b/src/d/actor/d_a_npc_hoz.cpp
@@ -188,7 +188,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {29, -1, 1}, {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {9, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Hoz_c::mCutNameList[8] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Hoz_c::mCutNameList[8] = {
     "",
     "BOAT_RACE",
     "BEFORE_BATTLE",
@@ -199,7 +199,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Hoz_c::mCutNameList[8] = {
     "TALK_BREAK",
 };
 
-daNpc_Hoz_c::cutFunc DUSK_CONST daNpc_Hoz_c::mCutList[] = {
+DUSK_GAME_DATA daNpc_Hoz_c::cutFunc DUSK_CONST daNpc_Hoz_c::mCutList[] = {
     NULL,
     &daNpc_Hoz_c::ECut_boatRace,
     &daNpc_Hoz_c::ECut_beforeBattle,
@@ -210,7 +210,7 @@ daNpc_Hoz_c::cutFunc DUSK_CONST daNpc_Hoz_c::mCutList[] = {
     &daNpc_Hoz_c::ECut_talkBreak,
 };
 
-const daNpc_Hoz_HIOParam daNpc_Hoz_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Hoz_HIOParam daNpc_Hoz_Param_c::m = {
     60.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_impal.cpp b/src/d/actor/d_a_npc_impal.cpp
index 9a736e5ea9..171c36c289 100644
--- a/src/d/actor/d_a_npc_impal.cpp
+++ b/src/d/actor/d_a_npc_impal.cpp
@@ -9,7 +9,7 @@
 #include "d/actor/d_a_npc.h"
 #include <cstring>
 
-daNpcImpal_HIOParam const daNpcImpal_Param_c::m = {
+DUSK_GAME_DATA daNpcImpal_HIOParam const daNpcImpal_Param_c::m = {
     135.0f,        // attention_offset
     -3.0f,         // gravity
     1.0f,          // scale
@@ -91,7 +91,7 @@ void daNpcImpal_HIO_c::genMessage(JORMContext* ctext) {
 }
 #endif
 
-daNpcImpal_c::EventFn daNpcImpal_c::mEvtSeqList[4] = {
+DUSK_GAME_DATA daNpcImpal_c::EventFn daNpcImpal_c::mEvtSeqList[4] = {
     NULL,
     &daNpcImpal_c::EvCut_ImpalAppear1,
     &daNpcImpal_c::EvCut_ImpalAppear2,
@@ -971,8 +971,9 @@ BOOL daNpcImpal_c::EvCut_ImpalAppear1(int i_cut_index) {
         if (talkProc(NULL, 1, NULL)) {
             int evt_id = 0;
             if (mFlow.getEventId(&evt_id) == 1) {
-                mItemPartnerId =
-                    fopAcM_createItemForPresentDemo(&current.pos, evt_id, 0, -1, -1, 0, 0);
+                DUSK_ITEM_CHECK("ilia_charm", evt_id, this);
+                mItemPartnerId = fopAcM_createItemForPresentDemo(
+                    &current.pos, evt_id, 0, -1, -1, 0, 0 DUSK_GIVE_TAG("ilia_charm"));
                 if (mItemPartnerId != 0xffffffff) {
                     s16 evt_idx =
                         dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xff);
@@ -1060,8 +1061,9 @@ BOOL daNpcImpal_c::EvCut_CopyRod(int i_cut_index) {
         case '0003':
             int evt_id = 0;
             if (mFlow.getEventId(&evt_id) == 1) {
-                mItemPartnerId =
-                    fopAcM_createItemForPresentDemo(&current.pos, evt_id, 0, -1, -1, 0, 0);
+                DUSK_ITEM_CHECK("skybook", evt_id, this);
+                mItemPartnerId = fopAcM_createItemForPresentDemo(
+                    &current.pos, evt_id, 0, -1, -1, 0, 0 DUSK_GIVE_TAG("skybook"));
                 dComIfGp_event_setItemPartnerId(mItemPartnerId);
                 mItemPartnerId = -1;
             }
diff --git a/src/d/actor/d_a_npc_ins.cpp b/src/d/actor/d_a_npc_ins.cpp
index 0600e01222..7dfdec325e 100644
--- a/src/d/actor/d_a_npc_ins.cpp
+++ b/src/d/actor/d_a_npc_ins.cpp
@@ -11,6 +11,10 @@
 #include "d/d_msg_object.h"
 #include <cstring>
 
+#if TARGET_PC
+static u8 s_givenInsectId = dItemNo_NONE_e;
+#endif
+
 enum Ins_RES_File_ID {
     /* BCK */
     /* 0x06 */ BCK_INS_F_HAPPY = 0x6,
@@ -288,7 +292,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "ins";
 
-daNpcIns_c::eventFunc daNpcIns_c::mEvtSeqList[1] = {
+DUSK_GAME_DATA daNpcIns_c::eventFunc daNpcIns_c::mEvtSeqList[1] = {
     NULL,
 };
 
@@ -319,7 +323,7 @@ static insect_param_data const l_insectParams[24] = {
     {0x01A8, 0x714, 0, 0},
 };
 
-daNpcIns_HIOParam const daNpcIns_Param_c::m = {
+DUSK_GAME_DATA daNpcIns_HIOParam const daNpcIns_Param_c::m = {
     35.0f,
     -3.0f,
     1.0f,
@@ -1259,6 +1263,7 @@ int daNpcIns_c::waitPresent(void* param_1) {
                     daPy_py_c* player = daPy_getPlayerActorClass();
                     player->changeOriginalDemo();
                     player->changeDemoMode(0x25, 2, type, 0);
+                    IF_DUSK(s_givenInsectId = type;)
                 } else {
                     mInsectMsgNo = 0x719;
                 }
@@ -1487,7 +1492,19 @@ int daNpcIns_c::talk(void* param_1) {
                         OS_REPORT("会話終了時 イベントID=%d アイテムNo=%d\n", eventID, itemNo);
 
                         if (eventID == 1) {
-                            mItemID = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                            u32 itemGiveTag = 0;
+                            if (s_givenInsectId != dItemNo_NONE_e) {
+                                const auto itemCheck = dusk::mods::item_check_commit(
+                                    dusk::mods::item_give_tag_bug(s_givenInsectId), itemNo & 0xFF,
+                                    this);
+                                itemNo = itemCheck.itemNo;
+                                itemGiveTag = itemCheck.tag;
+                                s_givenInsectId = dItemNo_NONE_e;
+                            }
+#endif
+                            mItemID = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1,
+                                -1, NULL, NULL IF_DUSK_ARG(itemGiveTag));
 
                             if (mItemID != fpcM_ERROR_PROCESS_ID_e) {
                                 daPy_getPlayerActorClass()->cancelOriginalDemo();
diff --git a/src/d/actor/d_a_npc_jagar.cpp b/src/d/actor/d_a_npc_jagar.cpp
index a0782d8d30..fce6435a04 100644
--- a/src/d/actor/d_a_npc_jagar.cpp
+++ b/src/d/actor/d_a_npc_jagar.cpp
@@ -138,7 +138,7 @@ enum Event {
     /* 0x8 */ EVENT_FIND_WOLF_VER2,
 };
 
-daNpc_Jagar_HIOParam const daNpc_Jagar_Param_c::m = {
+DUSK_GAME_DATA daNpc_Jagar_HIOParam const daNpc_Jagar_Param_c::m = {
     170.0f, -3.0f, 1.0f, 400.0f, 255.0f, 160.0f,
     35.0f, 30.0f, 0.0f, 0.0f, 10.0f, -10.0f,
     30.0f, -10.0f, 45.0f, -45.0f, 0.6f, 12.0f,
@@ -315,7 +315,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {13, -1, 1}, {12, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Jagar_c::mCutNameList[7] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Jagar_c::mCutNameList[7] = {
     "",
     "CLIMBUP",
     "NEED_YOUR_HELP",
@@ -325,7 +325,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Jagar_c::mCutNameList[7] = {
     "FIND_WOLF",
 };
 
-daNpc_Jagar_c::cutFunc DUSK_CONST daNpc_Jagar_c::mCutList[7] = {
+DUSK_GAME_DATA daNpc_Jagar_c::cutFunc DUSK_CONST daNpc_Jagar_c::mCutList[7] = {
     NULL,
     &daNpc_Jagar_c::cutClimbUp,
     &daNpc_Jagar_c::cutNeedYourHelp,
diff --git a/src/d/actor/d_a_npc_kakashi.cpp b/src/d/actor/d_a_npc_kakashi.cpp
index 4a15be8dca..6a3f72241f 100644
--- a/src/d/actor/d_a_npc_kakashi.cpp
+++ b/src/d/actor/d_a_npc_kakashi.cpp
@@ -75,21 +75,21 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Kakashi_c::mCutNameList[4] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Kakashi_c::mCutNameList[4] = {
     "",
     "SWDTUTORIAL",
     "GET_WOODSWD",
     "MAROS_WHISPER",
 };
 
-int (daNpc_Kakashi_c::* DUSK_CONST daNpc_Kakashi_c::mCutList[])(int) = {
+DUSK_GAME_DATA int (daNpc_Kakashi_c::* DUSK_CONST daNpc_Kakashi_c::mCutList[])(int) = {
     NULL,
     &daNpc_Kakashi_c::cutSwdTutorial,
     &daNpc_Kakashi_c::cutGetWoodSwd,
     &daNpc_Kakashi_c::cutMarosWhisper,
 };
 
-const daNpc_Kakashi_HIOParam daNpc_Kakashi_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Kakashi_HIOParam daNpc_Kakashi_Param_c::m = {
     190.0f,
     -6.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_kasi_hana.cpp b/src/d/actor/d_a_npc_kasi_hana.cpp
index a1c33ba3e1..e7191118a6 100644
--- a/src/d/actor/d_a_npc_kasi_hana.cpp
+++ b/src/d/actor/d_a_npc_kasi_hana.cpp
@@ -557,7 +557,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[6] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "kasi_hana";
 
-daNpcKasiHana_HIOParam const daNpcKasiHana_Param_c::m = {
+DUSK_GAME_DATA daNpcKasiHana_HIOParam const daNpcKasiHana_Param_c::m = {
     55.0f,
     -3.0f,
     1.0f,
@@ -611,7 +611,7 @@ void daNpcKasiHana_HIO_c::genMessage(JORMContext* ctext) {
 }
 #endif
 
-daNpcKasiHana_c::EventFn daNpcKasiHana_c::mEvtSeqList[6] = {
+DUSK_GAME_DATA daNpcKasiHana_c::EventFn daNpcKasiHana_c::mEvtSeqList[6] = {
     NULL,
     &daNpcKasiHana_c::_Evt_Kasi_Appear,
     &daNpcKasiHana_c::_Evt_Kasi_Talk,
@@ -1469,11 +1469,11 @@ int daNpcKasiHana_c::fear(int param_1) {
     return 1;
 }
 
-daTagEscape_c* daNpcKasiHana_c::mTargetTag;
+DUSK_GAME_DATA daTagEscape_c* daNpcKasiHana_c::mTargetTag;
 
-f32 daNpcKasiHana_c::mTargetTagDist;
+DUSK_GAME_DATA f32 daNpcKasiHana_c::mTargetTagDist;
 
-s16 daNpcKasiHana_c::mWolfAngle;
+DUSK_GAME_DATA s16 daNpcKasiHana_c::mWolfAngle;
 
 daTagEscape_c* daNpcKasiHana_c::srchWolfTag() {
     mTargetTag = NULL;
diff --git a/src/d/actor/d_a_npc_kasi_kyu.cpp b/src/d/actor/d_a_npc_kasi_kyu.cpp
index 0d034155c5..86ef71380e 100644
--- a/src/d/actor/d_a_npc_kasi_kyu.cpp
+++ b/src/d/actor/d_a_npc_kasi_kyu.cpp
@@ -140,11 +140,11 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "kasi_kyu";
 
-daNpcKasiKyu_c::EventFn DUSK_CONST daNpcKasiKyu_c::mEvtSeqList[1] = {
+DUSK_GAME_DATA daNpcKasiKyu_c::EventFn DUSK_CONST daNpcKasiKyu_c::mEvtSeqList[1] = {
     NULL
 };
 
-daNpcKasiKyu_HIOParam const daNpcKasiKyu_Param_c::m = {
+DUSK_GAME_DATA daNpcKasiKyu_HIOParam const daNpcKasiKyu_Param_c::m = {
     55.0f,
     -3.0f,
     1.0f,
@@ -366,11 +366,11 @@ void daNpcKasiKyu_c::setParam() {
     attention_info.flags = fopAc_AttnFlag_SPEAK_e | fopAc_AttnFlag_TALK_e;
 }
 
-daTagEscape_c* daNpcKasiKyu_c::mTargetTag;
+DUSK_GAME_DATA daTagEscape_c* daNpcKasiKyu_c::mTargetTag;
 
-f32 daNpcKasiKyu_c::mTargetTagDist;
+DUSK_GAME_DATA f32 daNpcKasiKyu_c::mTargetTagDist;
 
-s16 daNpcKasiKyu_c::mWolfAngle;
+DUSK_GAME_DATA s16 daNpcKasiKyu_c::mWolfAngle;
 
 BOOL daNpcKasiKyu_c::main() {
     if (mSygnal >= 0) {
diff --git a/src/d/actor/d_a_npc_kasi_mich.cpp b/src/d/actor/d_a_npc_kasi_mich.cpp
index a1565dac53..b5ffa90f47 100644
--- a/src/d/actor/d_a_npc_kasi_mich.cpp
+++ b/src/d/actor/d_a_npc_kasi_mich.cpp
@@ -140,11 +140,11 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "kasi_mich";
 
-daNpcKasiMich_c::EventFn DUSK_CONST daNpcKasiMich_c::mEvtSeqList[1] = {
+DUSK_GAME_DATA daNpcKasiMich_c::EventFn DUSK_CONST daNpcKasiMich_c::mEvtSeqList[1] = {
     NULL
 };
 
-daNpcKasiMich_HIOParam const daNpcKasiMich_Param_c::m = {
+DUSK_GAME_DATA daNpcKasiMich_HIOParam const daNpcKasiMich_Param_c::m = {
     55.0f,
     -3.0f,
     1.0f,
@@ -366,11 +366,11 @@ void daNpcKasiMich_c::setParam() {
     attention_info.flags = fopAc_AttnFlag_SPEAK_e | fopAc_AttnFlag_TALK_e;
 }
 
-daTagEscape_c* daNpcKasiMich_c::mTargetTag;
+DUSK_GAME_DATA daTagEscape_c* daNpcKasiMich_c::mTargetTag;
 
-f32 daNpcKasiMich_c::mTargetTagDist;
+DUSK_GAME_DATA f32 daNpcKasiMich_c::mTargetTagDist;
 
-s16 daNpcKasiMich_c::mWolfAngle;
+DUSK_GAME_DATA s16 daNpcKasiMich_c::mWolfAngle;
 
 BOOL daNpcKasiMich_c::main() {
     if (mSygnal >= 0) {
diff --git a/src/d/actor/d_a_npc_kkri.cpp b/src/d/actor/d_a_npc_kkri.cpp
index 2b37ee81f1..9082c9c473 100644
--- a/src/d/actor/d_a_npc_kkri.cpp
+++ b/src/d/actor/d_a_npc_kkri.cpp
@@ -9,6 +9,10 @@
 #include "d/actor/d_a_e_ym.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "mods/items.h"
+#endif
+
 static DUSK_CONSTEXPR int l_bmdData[2][2] = {
     {35, 1},
     {18, 2},
@@ -222,13 +226,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Kkri_c::mCutNameList[3] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Kkri_c::mCutNameList[3] = {
     "",
     "CONVERSATION_ABOUT_SOUP",
     "YM_LOOK",
 };
 
-int (daNpc_Kkri_c::* DUSK_CONST daNpc_Kkri_c::mCutList[])(int) = {
+DUSK_GAME_DATA int (daNpc_Kkri_c::* DUSK_CONST daNpc_Kkri_c::mCutList[])(int) = {
     NULL,
     &daNpc_Kkri_c::cutConversationAboutSoup,
     &daNpc_Kkri_c::cutYmLook,
@@ -236,7 +240,7 @@ int (daNpc_Kkri_c::* DUSK_CONST daNpc_Kkri_c::mCutList[])(int) = {
 
 static NPC_KKRI_HIO_CLASS l_HIO;
 
-const daNpc_Kkri_HIOParam daNpc_Kkri_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Kkri_HIOParam daNpc_Kkri_Param_c::m = {
     180.0f,
     -3.0f,
     1.0f,
@@ -1181,7 +1185,41 @@ int daNpc_Kkri_c::talk(void*) {
                     switch (eventId) {
                     case 1:
                         if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                            mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, item_no, 0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                            u32 itemGiveTag = 0;
+                            const char* itemCheckName = nullptr;
+                            switch (item_no) {
+                            case dItemNo_OIL_BOTTLE3_e:
+                                itemCheckName = ITEM_CHECK_CORO_BOTTLE;
+                                break;
+                            case dItemNo_KANTERA_e:
+                                itemCheckName = ITEM_CHECK_CORO_LANTERN;
+                                break;
+                            case dItemNo_KEY_OF_FILONE_e:
+                                itemCheckName = ITEM_CHECK_CORO_GATE_KEY;
+                                break;
+                            }
+
+                            if (itemCheckName != nullptr) {
+                                const auto itemCheck = dusk::mods::item_check_commit(
+                                    itemCheckName, item_no, this);
+                                item_no = itemCheck.itemNo;
+                                itemGiveTag = itemCheck.tag;
+                            }
+
+                            if (item_no == dItemNo_NONE_e && itemCheckName != nullptr) {
+                                dusk::mods::item_check_complete({itemGiveTag, dItemNo_NONE_e}, this);
+                                field_0xfd5 = 1;
+                                mEvtNo = 1;
+                                evtChange();
+                            } else {
+                                mItemPartnerId = fopAcM_createItemForPresentDemo(
+                                    &current.pos, item_no, 0, -1, -1, NULL, NULL, itemGiveTag);
+                            }
+#else
+                            mItemPartnerId = fopAcM_createItemForPresentDemo(
+                                &current.pos, item_no, 0, -1, -1, NULL, NULL);
+#endif
                         }
 
                         if (fopAcM_IsExecuting(mItemPartnerId)) {
diff --git a/src/d/actor/d_a_npc_kn.cpp b/src/d/actor/d_a_npc_kn.cpp
index 3f221e55c4..1edecfe650 100644
--- a/src/d/actor/d_a_npc_kn.cpp
+++ b/src/d/actor/d_a_npc_kn.cpp
@@ -17,25 +17,25 @@
 #include <cstring>
 #endif
 
-dCcD_SrcCyl daNpc_Kn_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daNpc_Kn_c::mCcDCyl = {
     mCcDObjData,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f},
     }
 };
 
-dCcD_SrcSph daNpc_Kn_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daNpc_Kn_c::mCcDSph = {
     mCcDObjData,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSphCc
     },
 };
 
-s16 daNpc_Kn_c::mSrchName;
+DUSK_GAME_DATA s16 daNpc_Kn_c::mSrchName;
 
-fopAc_ac_c* daNpc_Kn_c::mFindActorPtrs[50];
+DUSK_GAME_DATA fopAc_ac_c* daNpc_Kn_c::mFindActorPtrs[50];
 
-int daNpc_Kn_c::mFindCount;
+DUSK_GAME_DATA int daNpc_Kn_c::mFindCount;
 
 void* dummy_srchActor(void* i_actor1, void* i_actor2) {
     // Fake function (though a similar one likely existed and got stripped out).
@@ -59,7 +59,7 @@ void* dummy_srchActor(void* i_actor1, void* i_actor2) {
     return NULL;
 }
 
-const dCcD_SrcGObjInf daNpc_Kn_c::mCcDObjData = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daNpc_Kn_c::mCcDObjData = {
     {0, {{0, 0, 0}, {0, 0}, {0x79}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 0},
@@ -68,7 +68,7 @@ const dCcD_SrcGObjInf daNpc_Kn_c::mCcDObjData = {
 
 #include "d/actor/d_a_npc_kn_base.inc"
 
-const daNpc_Kn_HIOParam daNpc_Kn_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Kn_HIOParam daNpc_Kn_Param_c::m = {
     50.0f,
     -5.0f,
     1.0f,
@@ -468,7 +468,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Kn_c::mCutNameList[21] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Kn_c::mCutNameList[21] = {
     "",
     "NONE_EQUIP_CHANGE_TALK",
     "NO_EQ_CHNGE_TLK_STD",
@@ -492,7 +492,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Kn_c::mCutNameList[21] = {
     "SEVENTH_SKILL_GET",
 };
 
-daNpc_Kn_c::cutFunc DUSK_CONST daNpc_Kn_c::mCutList[21] = {
+DUSK_GAME_DATA daNpc_Kn_c::cutFunc DUSK_CONST daNpc_Kn_c::mCutList[21] = {
     NULL,
     &daNpc_Kn_c::ECut_noneEquipChangeTalk,
     &daNpc_Kn_c::ECut_noneEquipChangeTalkStand,
diff --git a/src/d/actor/d_a_npc_knj.cpp b/src/d/actor/d_a_npc_knj.cpp
index 52b922955d..cf40a06221 100644
--- a/src/d/actor/d_a_npc_knj.cpp
+++ b/src/d/actor/d_a_npc_knj.cpp
@@ -8,7 +8,7 @@
 #include "d/actor/d_a_npc_knj.h"
 #include <cstring>
 
-const daNpc_Knj_HIOParam daNpc_Knj_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Knj_HIOParam daNpc_Knj_Param_c::m = {
     0.0f,     // attention_offset
     0.0f,     // gravity
     1.0f,     // scale
@@ -125,9 +125,9 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Knj_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Knj_c::mCutNameList[1] = {""};
 
-daNpc_Knj_c::cutFunc DUSK_CONST daNpc_Knj_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_Knj_c::cutFunc DUSK_CONST daNpc_Knj_c::mCutList[1] = {
     NULL,
 };
 
diff --git a/src/d/actor/d_a_npc_kolin.cpp b/src/d/actor/d_a_npc_kolin.cpp
index 09fc2d12ff..3440f551e4 100644
--- a/src/d/actor/d_a_npc_kolin.cpp
+++ b/src/d/actor/d_a_npc_kolin.cpp
@@ -308,7 +308,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {20, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Kolin_c::mCutNameList[11] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Kolin_c::mCutNameList[11] = {
     "",
     "NO_RIDE",
     "HAIL",
@@ -322,7 +322,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Kolin_c::mCutNameList[11] = {
     "THANK_YOU",
 };
 
-daNpc_Kolin_c::cutFunc DUSK_CONST daNpc_Kolin_c::mCutList[11] = {
+DUSK_GAME_DATA daNpc_Kolin_c::cutFunc DUSK_CONST daNpc_Kolin_c::mCutList[11] = {
     NULL,
     &daNpc_Kolin_c::cutNoRide,
     &daNpc_Kolin_c::cutHail,
@@ -336,7 +336,7 @@ daNpc_Kolin_c::cutFunc DUSK_CONST daNpc_Kolin_c::mCutList[11] = {
     &daNpc_Kolin_c::cutThankYou
 };
 
-daNpc_Kolin_HIOParam const daNpc_Kolin_Param_c::m = {
+DUSK_GAME_DATA daNpc_Kolin_HIOParam const daNpc_Kolin_Param_c::m = {
     140.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_kolinb.cpp b/src/d/actor/d_a_npc_kolinb.cpp
index bf0d78e0fa..caff7135a1 100644
--- a/src/d/actor/d_a_npc_kolinb.cpp
+++ b/src/d/actor/d_a_npc_kolinb.cpp
@@ -177,7 +177,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {8, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Kolinb_c::mCutNameList[7] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Kolinb_c::mCutNameList[7] = {
     "",
     "CONVERSATION_IN_HOTEL",
     "CONVERSATION_ABOUT_DEATHMT",
@@ -187,7 +187,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Kolinb_c::mCutNameList[7] = {
     "THANK_YOU",
 };
 
-daNpc_Kolinb_c::cutFunc DUSK_CONST daNpc_Kolinb_c::mCutList[7] = {
+DUSK_GAME_DATA daNpc_Kolinb_c::cutFunc DUSK_CONST daNpc_Kolinb_c::mCutList[7] = {
     NULL,
     &daNpc_Kolinb_c::cutConversationInHotel,
     &daNpc_Kolinb_c::cutConversationAboutDeathMt,
@@ -199,7 +199,7 @@ daNpc_Kolinb_c::cutFunc DUSK_CONST daNpc_Kolinb_c::mCutList[7] = {
 
 static NPC_KOLINB_HIO_CLASS l_HIO;
 
-daNpc_Kolinb_HIOParam const daNpc_Kolinb_Param_c::m = {
+DUSK_GAME_DATA daNpc_Kolinb_HIOParam const daNpc_Kolinb_Param_c::m = {
     100.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_kyury.cpp b/src/d/actor/d_a_npc_kyury.cpp
index 429249bbfc..15913aaf49 100644
--- a/src/d/actor/d_a_npc_kyury.cpp
+++ b/src/d/actor/d_a_npc_kyury.cpp
@@ -8,7 +8,7 @@
 #include "d/actor/d_a_npc_kyury.h"
 #include <cstring>
 
-const daNpc_Kyury_HIOParam daNpc_Kyury_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Kyury_HIOParam daNpc_Kyury_Param_c::m = {
     200.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
@@ -127,12 +127,12 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Kyury_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Kyury_c::mCutNameList[2] = {
     "",
     "CONVERSATION",
 };
 
-daNpc_Kyury_c::cutFunc DUSK_CONST daNpc_Kyury_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_Kyury_c::cutFunc DUSK_CONST daNpc_Kyury_c::mCutList[2] = {
     NULL,
     &daNpc_Kyury_c::cutConversation,
 };
diff --git a/src/d/actor/d_a_npc_len.cpp b/src/d/actor/d_a_npc_len.cpp
index 35b8c33dd2..2568462e8b 100644
--- a/src/d/actor/d_a_npc_len.cpp
+++ b/src/d/actor/d_a_npc_len.cpp
@@ -44,7 +44,7 @@ enum Motion {
     /* 0x11 */ MOT_UNK_17 = 17,
 };
 
-const daNpc_Len_HIOParam daNpc_Len_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Len_HIOParam daNpc_Len_Param_c::m = {
     230.0f, -3.0f,  1.0f,   450.0f, 255.0f, 210.0f, 35.0f, 40.0f,  0.0f,  0.0f, 15.0f,
     -15.0f, 30.0f,  -10.0f, 30.0f,  -30.0f, 0.6f,   12.0f, 3,      6,     5,    6,
     110.0f, 0.0f,   0.0f,   0.0f,   60,     8,      0,     0,      0,     0,    0,
@@ -144,14 +144,14 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},  {-1, 0, 0}, {-1, 0, 0},  {17, 4, 1},  {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Len_c::mCutNameList[4] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Len_c::mCutNameList[4] = {
     "",
     "HURRY",
     "CONVERSATION_IN_HOTEL",
     "TAKE_WOODSTATUE",
 };
 
-daNpc_Len_c::cutFunc DUSK_CONST daNpc_Len_c::mCutList[4] = {
+DUSK_GAME_DATA daNpc_Len_c::cutFunc DUSK_CONST daNpc_Len_c::mCutList[4] = {
     NULL,
     &daNpc_Len_c::cutHurry,
     &daNpc_Len_c::cutConversationInHotel,
@@ -1236,8 +1236,9 @@ int daNpc_Len_c::talk(void* param_0) {
                     switch (evt_id) {
                     case 1:
                         if (mItemPartnerId == -1) {
+                            DUSK_ITEM_CHECK("renado_letter", local_18, this);
                             mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, local_18,
-                                                                             0, -1, -1, 0, 0);
+                                0, -1, -1, 0, 0 DUSK_GIVE_TAG("renado_letter"));
                         }
                         if (fopAcM_IsExecuting(mItemPartnerId)) {
                             mEvtNo = 1;
diff --git a/src/d/actor/d_a_npc_lud.cpp b/src/d/actor/d_a_npc_lud.cpp
index 38632d9a5d..3551b68db9 100644
--- a/src/d/actor/d_a_npc_lud.cpp
+++ b/src/d/actor/d_a_npc_lud.cpp
@@ -9,7 +9,7 @@
 #include "d/actor/d_a_npc_lud.h"
 #include <cstring>
 
-const daNpc_Lud_HIOParam daNpc_Lud_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Lud_HIOParam daNpc_Lud_Param_c::m = {
     160.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
@@ -212,7 +212,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Lud_c::mCutNameList[8] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Lud_c::mCutNameList[8] = {
     "",
     "HURRY",
     "CONVERSATION_IN_HOTEL",
@@ -223,7 +223,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Lud_c::mCutNameList[8] = {
     "THANK_YOU",
 };
 
-daNpc_Lud_c::cutFunc DUSK_CONST daNpc_Lud_c::mCutList[8] = {
+DUSK_GAME_DATA daNpc_Lud_c::cutFunc DUSK_CONST daNpc_Lud_c::mCutList[8] = {
     NULL,
     &daNpc_Lud_c::cutHurry,
     &daNpc_Lud_c::cutConversationInHotel,
diff --git a/src/d/actor/d_a_npc_maro.cpp b/src/d/actor/d_a_npc_maro.cpp
index 040849ec2e..d985349a48 100644
--- a/src/d/actor/d_a_npc_maro.cpp
+++ b/src/d/actor/d_a_npc_maro.cpp
@@ -22,7 +22,7 @@
 #include <cstring>
 #endif
 
-const daNpc_Maro_HIOParam daNpc_Maro_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Maro_HIOParam daNpc_Maro_Param_c::m = {
     100.0f,
     -3.0f,
     1.0f,
@@ -206,7 +206,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {9, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Maro_c::mCutNameList[17] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Maro_c::mCutNameList[17] = {
     "",
     "CONVERSATION_ABOUT_PACHINKO",
     "CONVERSATION_ABOUT_WOODSWD",
@@ -226,7 +226,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Maro_c::mCutNameList[17] = {
     "TALK_TO_KAKASHI",
 };
 
-daNpc_Maro_c::cutFunc DUSK_CONST daNpc_Maro_c::mCutList[17] = {
+DUSK_GAME_DATA daNpc_Maro_c::cutFunc DUSK_CONST daNpc_Maro_c::mCutList[17] = {
     NULL,
     &daNpc_Maro_c::cutConversationAboutPachinko,
     &daNpc_Maro_c::cutConversationAboutWoodSwd,
@@ -2393,7 +2393,10 @@ int daNpc_Maro_c::cutArrowTutorial(int arg0) {
                     switch (evt_ret) {
                         case 1: {
                             if (mItemPartnerId == -1) {
-                                mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, evt_id, 0, -1, -1, NULL, NULL);
+                                DUSK_ITEM_CHECK("archery_reward:F_SP109", evt_id, this);
+                                mItemPartnerId =
+                                    fopAcM_createItemForPresentDemo(&current.pos, evt_id, 0, -1, -1,
+                                        NULL, NULL DUSK_GIVE_TAG("archery_reward:F_SP109"));
                             }
 
                             if (fopAcM_IsExecuting(mItemPartnerId)) {
diff --git a/src/d/actor/d_a_npc_midp.cpp b/src/d/actor/d_a_npc_midp.cpp
index 1500ca6963..4edfc74d27 100644
--- a/src/d/actor/d_a_npc_midp.cpp
+++ b/src/d/actor/d_a_npc_midp.cpp
@@ -62,11 +62,11 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_midP_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_midP_c::mCutNameList = "";
 
-daNpc_midP_c::cutFunc DUSK_CONST daNpc_midP_c::mCutList[1] = { 0 };
+DUSK_GAME_DATA daNpc_midP_c::cutFunc DUSK_CONST daNpc_midP_c::mCutList[1] = { 0 };
 
-daNpc_midP_HIOParam const daNpc_midP_Param_c::m = {
+DUSK_GAME_DATA daNpc_midP_HIOParam const daNpc_midP_Param_c::m = {
     210.0f, 
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_moi.cpp b/src/d/actor/d_a_npc_moi.cpp
index 5a76e70c3a..58060909df 100644
--- a/src/d/actor/d_a_npc_moi.cpp
+++ b/src/d/actor/d_a_npc_moi.cpp
@@ -13,7 +13,7 @@
 #include "d/actor/d_a_npc_uri.h"
 #include <cstring>
 
-const daNpc_Moi_HIOParam daNpc_Moi_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Moi_HIOParam daNpc_Moi_Param_c::m = {
     200.0f,   // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
@@ -207,11 +207,11 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0},  {18, 4, 0},  {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Moi_c::mCutNameList[5] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Moi_c::mCutNameList[5] = {
     "", "DELIVERED_SW", "APPEARANCE_MOI", "CONVERSATION_WITH_URI", "FIND_WOLF",
 };
 
-daNpc_Moi_c::cutFunc DUSK_CONST daNpc_Moi_c::mCutList[5] = {
+DUSK_GAME_DATA daNpc_Moi_c::cutFunc DUSK_CONST daNpc_Moi_c::mCutList[5] = {
     NULL,
     &daNpc_Moi_c::cutDeliveredSw,
     &daNpc_Moi_c::cutAppearanceMoi,
diff --git a/src/d/actor/d_a_npc_moir.cpp b/src/d/actor/d_a_npc_moir.cpp
index f3a6d29ba1..48f58cc621 100644
--- a/src/d/actor/d_a_npc_moir.cpp
+++ b/src/d/actor/d_a_npc_moir.cpp
@@ -207,7 +207,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[4] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "MoiR";
 
-daNpcMoiR_HIOParam const daNpcMoiR_Param_c::m = {
+DUSK_GAME_DATA daNpcMoiR_HIOParam const daNpcMoiR_Param_c::m = {
     35.0f,
     -3.0f,
     1.0f,
@@ -261,7 +261,7 @@ void daNpcMoiR_HIO_c::genMessage(JORMContext* ctext) {
 
 static NPC_MOIR_HIO_CLASS l_HIO;
 
-daNpcMoiR_c::EventFn daNpcMoiR_c::mEvtSeqList[4] = {
+DUSK_GAME_DATA daNpcMoiR_c::EventFn daNpcMoiR_c::mEvtSeqList[4] = {
     NULL,
     &daNpcMoiR_c::EvCut_Introduction,
     &daNpcMoiR_c::EvCut_Appear,
diff --git a/src/d/actor/d_a_npc_myna2.cpp b/src/d/actor/d_a_npc_myna2.cpp
index 5a3cb09240..9b7bc973fc 100644
--- a/src/d/actor/d_a_npc_myna2.cpp
+++ b/src/d/actor/d_a_npc_myna2.cpp
@@ -91,7 +91,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNames[3] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "myna2";
 
-char DUSK_CONST* DUSK_CONST daNpc_myna2_c::mEvtCutNameList[5] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_myna2_c::mEvtCutNameList[5] = {
     "",
     "FIRST_TALK",
     "GAME_FAILURE",
@@ -99,7 +99,7 @@ char DUSK_CONST* DUSK_CONST daNpc_myna2_c::mEvtCutNameList[5] = {
     "GAME_GOAL_SUCCESS",
 };
 
-daNpc_myna2_c::EventFn DUSK_CONST daNpc_myna2_c::mEvtCutList[] = {
+DUSK_GAME_DATA daNpc_myna2_c::EventFn DUSK_CONST daNpc_myna2_c::mEvtCutList[] = {
     NULL,
     &daNpc_myna2_c::ECut_firstTalk,
     &daNpc_myna2_c::ECut_gameFailure,
@@ -107,7 +107,7 @@ daNpc_myna2_c::EventFn DUSK_CONST daNpc_myna2_c::mEvtCutList[] = {
     &daNpc_myna2_c::ECut_gameGoalSuccess,
 };
 
-const daNpc_myna2_HIOParam daNpc_myna2_Param_c::m = {
+DUSK_GAME_DATA const daNpc_myna2_HIOParam daNpc_myna2_Param_c::m = {
     60.0f,
     0.0f,
     1.0f,
@@ -1191,7 +1191,17 @@ int daNpc_myna2_c::ECut_gameGoalSuccess(int i_staffId) {
         case 20: {
             int itemNo = 0;
             if (mFlow.getEventId(&itemNo) == 1) {
-                mItemPid = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                u32 itemGiveTag = 0;
+                if (itemNo == dItemNo_KAKERA_HEART_e) {
+                    const auto itemCheck =
+                        dusk::mods::item_check_commit("plumm_minigame_reward", itemNo, this);
+                    itemNo = itemCheck.itemNo;
+                    itemGiveTag = itemCheck.tag;
+                }
+#endif
+                mItemPid = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL,
+                    NULL IF_DUSK_ARG(itemGiveTag));
             }
             break;
         }
diff --git a/src/d/actor/d_a_npc_ne.cpp b/src/d/actor/d_a_npc_ne.cpp
index edce270a2c..530654400f 100644
--- a/src/d/actor/d_a_npc_ne.cpp
+++ b/src/d/actor/d_a_npc_ne.cpp
@@ -18,9 +18,12 @@
 #include "f_op/f_op_kankyo_mng.h"
 #include "c/c_damagereaction.h"
 #include "Z2AudioLib/Z2Instances.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 static home_path_pnt home_path[38] = {
     {0, {561.0f, 87.0f, -1110.0f}},
     {1, {306.0f, 87.0f, -849.0f}},
@@ -2656,9 +2659,7 @@ static void demo_camera(npc_ne_class* i_this) {
         i_this->mCameraFovY = 55.0f;
         camera->mCamera.SetTrimSize(3);
         daPy_getPlayerActorClass()->changeOriginalDemo();
-#ifdef TARGET_PC
-        dusk::frame_interp::request_presentation_sync();
-#endif
+        IF_DUSK(dusk::interp::request_presentation_sync());
         // fallthrough
 
     case 2:
@@ -2687,9 +2688,7 @@ static void demo_camera(npc_ne_class* i_this) {
         if (i_this->mDemoCounter == 0) {
             i_this->mCameraCenter1.set(387.0f, 133.0f, -866.0f);
             i_this->mCameraEye1.set(284.0f, 208.0f, -585.0f);
-#ifdef TARGET_PC
-            dusk::frame_interp::request_presentation_sync();
-#endif
+            IF_DUSK(dusk::interp::request_presentation_sync());
         }
 
         if (i_this->mDemoCounter == 12) {
@@ -2726,9 +2725,7 @@ static void demo_camera(npc_ne_class* i_this) {
         i_this->mCameraFovY = 45.0f;
         camera->mCamera.SetTrimSize(3);
         daPy_getPlayerActorClass()->changeOriginalDemo();
-#ifdef TARGET_PC
-        dusk::frame_interp::request_presentation_sync();
-#endif
+        IF_DUSK(dusk::interp::request_presentation_sync());
         // fallthrough
 
     case 11:
@@ -2809,14 +2806,10 @@ static void demo_camera(npc_ne_class* i_this) {
                     MtxPosition(&vec, &i_this->mCameraEye2);
                     i_this->mCameraEye2 += player->current.pos;
                     player->changeDemoParam2(2);
-#ifdef TARGET_PC
-                    dusk::frame_interp::request_presentation_sync();
-#endif
+                    IF_DUSK(dusk::interp::request_presentation_sync());
                 } else if (i_this->mDemoCounter == 120) {
                     player->changeDemoParam2(0);
-#ifdef TARGET_PC
-                    dusk::frame_interp::request_presentation_sync();
-#endif
+                    IF_DUSK(dusk::interp::request_presentation_sync());
                 }
             }
         }
@@ -2869,9 +2862,7 @@ static void demo_camera(npc_ne_class* i_this) {
                 i_this->mCameraCenter1 = _this->current.pos;
                 i_this->mCameraCenter1.y += 20.0f;
                 i_this->mCameraFovY = 55.0f;
-#ifdef TARGET_PC
-                dusk::frame_interp::request_presentation_sync();
-#endif
+                IF_DUSK(dusk::interp::request_presentation_sync());
             }
 
             camera->mCamera.Set(i_this->mCameraCenter1, i_this->mCameraEye1,
diff --git a/src/d/actor/d_a_npc_pachi_besu.cpp b/src/d/actor/d_a_npc_pachi_besu.cpp
index 096c745555..089d9b4acc 100644
--- a/src/d/actor/d_a_npc_pachi_besu.cpp
+++ b/src/d/actor/d_a_npc_pachi_besu.cpp
@@ -441,7 +441,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {9, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Pachi_Besu_c::mCutNameList[11] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Pachi_Besu_c::mCutNameList[11] = {
     "",
     "TUTRIAL_BEGIN",
     "TUTRIAL_BEGIN_SKIP",
@@ -455,7 +455,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Pachi_Besu_c::mCutNameList[11] = {
     "TUTRIAL_CAUTION",
 };
 
-daNpc_Pachi_Besu_c::cutFunc DUSK_CONST daNpc_Pachi_Besu_c::mCutList[11] = {
+DUSK_GAME_DATA daNpc_Pachi_Besu_c::cutFunc DUSK_CONST daNpc_Pachi_Besu_c::mCutList[11] = {
     NULL,
     &daNpc_Pachi_Besu_c::cutTutrialBegin,
     &daNpc_Pachi_Besu_c::cutTutrialBegin_Skip,
@@ -469,7 +469,7 @@ daNpc_Pachi_Besu_c::cutFunc DUSK_CONST daNpc_Pachi_Besu_c::mCutList[11] = {
     &daNpc_Pachi_Besu_c::cutTutrialCaution,
 };
 
-daNpc_Pachi_Besu_HIOParam const daNpc_Pachi_Besu_Param_c::m = {
+DUSK_GAME_DATA daNpc_Pachi_Besu_HIOParam const daNpc_Pachi_Besu_Param_c::m = {
     160.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_pachi_maro.cpp b/src/d/actor/d_a_npc_pachi_maro.cpp
index 9b469866f8..61cc4eabe1 100644
--- a/src/d/actor/d_a_npc_pachi_maro.cpp
+++ b/src/d/actor/d_a_npc_pachi_maro.cpp
@@ -460,7 +460,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {MOT_ANM_RUN, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Pachi_Maro_c::mCutNameList[11] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Pachi_Maro_c::mCutNameList[11] = {
     "",
     "TUTRIAL_BEGIN",
     "TUTRIAL_BEGIN_SKIP",
@@ -474,7 +474,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Pachi_Maro_c::mCutNameList[11] = {
     "TUTRIAL_CAUTION",
 };
 
-daNpc_Pachi_Maro_c::cutFunc DUSK_CONST daNpc_Pachi_Maro_c::mCutList[11] = {
+DUSK_GAME_DATA daNpc_Pachi_Maro_c::cutFunc DUSK_CONST daNpc_Pachi_Maro_c::mCutList[11] = {
     NULL,
     &daNpc_Pachi_Maro_c::cutTutrialBegin,
     &daNpc_Pachi_Maro_c::cutTutrialBegin_Skip,
@@ -506,7 +506,7 @@ daNpc_Pachi_Maro_c::~daNpc_Pachi_Maro_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-daNpc_Pachi_Maro_HIOParam const daNpc_Pachi_Maro_Param_c::m = {
+DUSK_GAME_DATA daNpc_Pachi_Maro_HIOParam const daNpc_Pachi_Maro_Param_c::m = {
     100.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_pachi_taro.cpp b/src/d/actor/d_a_npc_pachi_taro.cpp
index 647b954ed9..d0e905f900 100644
--- a/src/d/actor/d_a_npc_pachi_taro.cpp
+++ b/src/d/actor/d_a_npc_pachi_taro.cpp
@@ -688,7 +688,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {MOT_ANM_SAVED, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Pachi_Taro_c::mCutNameList[11] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Pachi_Taro_c::mCutNameList[11] = {
     "",
     "TUTRIAL_BEGIN",
     "TUTRIAL_BEGIN_SKIP",
@@ -702,7 +702,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Pachi_Taro_c::mCutNameList[11] = {
     "TUTRIAL_CAUTION",
 };
 
-daNpc_Pachi_Taro_c::cutFunc DUSK_CONST daNpc_Pachi_Taro_c::mCutList[11] = {
+DUSK_GAME_DATA daNpc_Pachi_Taro_c::cutFunc DUSK_CONST daNpc_Pachi_Taro_c::mCutList[11] = {
     NULL,
     &daNpc_Pachi_Taro_c::cutTutrialBegin,
     &daNpc_Pachi_Taro_c::cutTutrialBegin_Skip,
@@ -734,7 +734,7 @@ daNpc_Pachi_Taro_c::~daNpc_Pachi_Taro_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-daNpc_Pachi_Taro_HIOParam const daNpc_Pachi_Taro_Param_c::m = {
+DUSK_GAME_DATA daNpc_Pachi_Taro_HIOParam const daNpc_Pachi_Taro_Param_c::m = {
     140.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_passer.cpp b/src/d/actor/d_a_npc_passer.cpp
index 9fe0fcbd6a..11bd69e88c 100644
--- a/src/d/actor/d_a_npc_passer.cpp
+++ b/src/d/actor/d_a_npc_passer.cpp
@@ -8,7 +8,7 @@
 #include "d/actor/d_a_npc_passer.h"
 #include "d/d_s_play.h"
 
-daNpcPasser_c::actionFunc daNpcPasser_c::ActionTable[5][2] = {
+DUSK_GAME_DATA daNpcPasser_c::actionFunc daNpcPasser_c::ActionTable[5][2] = {
     {&daNpcPasser_c::initPath, &daNpcPasser_c::executePath},
     {&daNpcPasser_c::initEscape, &daNpcPasser_c::executeEscape},
     {&daNpcPasser_c::initFear, &daNpcPasser_c::executeFear},
@@ -481,7 +481,7 @@ void daNpcPasser_c::create_init() {
     setBaseMtx();
 }
 
-daNpcPasser_c::seqFunc* daNpcPasser_c::m_funcTbl[28] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc* daNpcPasser_c::m_funcTbl[28] = {
     daNpcPasser_c::m_seq00_funcTbl, daNpcPasser_c::m_seq01_funcTbl,
     daNpcPasser_c::m_seq02_funcTbl, daNpcPasser_c::m_seq03_funcTbl,
     daNpcPasser_c::m_seq04_funcTbl, daNpcPasser_c::m_seq05_funcTbl,
@@ -498,51 +498,51 @@ daNpcPasser_c::seqFunc* daNpcPasser_c::m_funcTbl[28] = {
     daNpcPasser_c::m_seq26_funcTbl, daNpcPasser_c::m_seq27_funcTbl,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq00_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq00_funcTbl[2] = {
     &daNpcPasser_c::walka,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq01_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq01_funcTbl[2] = {
     &daNpcPasser_c::runa,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq02_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq02_funcTbl[2] = {
     &daNpcPasser_c::waita,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq03_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq03_funcTbl[2] = {
     &daNpcPasser_c::talka,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq04_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq04_funcTbl[2] = {
     &daNpcPasser_c::runb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq05_funcTbl[4] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq05_funcTbl[4] = {
     &daNpcPasser_c::turnr,
     &daNpcPasser_c::waita,
     &daNpcPasser_c::talka,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq06_funcTbl[4] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq06_funcTbl[4] = {
     &daNpcPasser_c::turnl,
     &daNpcPasser_c::waita,
     &daNpcPasser_c::talka,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq07_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq07_funcTbl[2] = {
     &daNpcPasser_c::waitwall,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq08_funcTbl[7] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq08_funcTbl[7] = {
     &daNpcPasser_c::talkwall,
     &daNpcPasser_c::waitwall,
     &daNpcPasser_c::talkbwall,
@@ -552,17 +552,17 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq08_funcTbl[7] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq09_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq09_funcTbl[2] = {
     &daNpcPasser_c::talkb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq10_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq10_funcTbl[2] = {
     &daNpcPasser_c::talkc,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq11_funcTbl[6] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq11_funcTbl[6] = {
     &daNpcPasser_c::talka,
     &daNpcPasser_c::waita,
     &daNpcPasser_c::talkb,
@@ -571,12 +571,12 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq11_funcTbl[6] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq12_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq12_funcTbl[2] = {
     &daNpcPasser_c::waitb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq13_funcTbl[6] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq13_funcTbl[6] = {
     &daNpcPasser_c::browsea,
     &daNpcPasser_c::browseb,
     &daNpcPasser_c::talka,
@@ -585,17 +585,17 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq13_funcTbl[6] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq14_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq14_funcTbl[2] = {
     &daNpcPasser_c::walkb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq15_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq15_funcTbl[2] = {
     &daNpcPasser_c::sitwaita,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq16_funcTbl[7] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq16_funcTbl[7] = {
     &daNpcPasser_c::sittalka,
     &daNpcPasser_c::sitwaita,
     &daNpcPasser_c::sittalkab,
@@ -605,17 +605,17 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq16_funcTbl[7] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq17_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq17_funcTbl[2] = {
     &daNpcPasser_c::playm,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq18_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq18_funcTbl[2] = {
     &daNpcPasser_c::sitwaitb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq19_funcTbl[7] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq19_funcTbl[7] = {
     &daNpcPasser_c::sittalkb,
     &daNpcPasser_c::sitwaitb,
     &daNpcPasser_c::sittalkbb,
@@ -625,24 +625,24 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq19_funcTbl[7] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq20_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq20_funcTbl[2] = {
     &daNpcPasser_c::looka,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq21_funcTbl[2] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq21_funcTbl[2] = {
     &daNpcPasser_c::lookb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq22_funcTbl[4] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq22_funcTbl[4] = {
     &daNpcPasser_c::looka,
     &daNpcPasser_c::lookb,
     &daNpcPasser_c::waita,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq23_funcTbl[7] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq23_funcTbl[7] = {
     &daNpcPasser_c::talka,
     &daNpcPasser_c::waita,
     &daNpcPasser_c::talkb,
@@ -652,7 +652,7 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq23_funcTbl[7] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq24_funcTbl[5] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq24_funcTbl[5] = {
     &daNpcPasser_c::talkb,
     &daNpcPasser_c::talka,
     &daNpcPasser_c::talkc,
@@ -660,7 +660,7 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq24_funcTbl[5] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq25_funcTbl[7] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq25_funcTbl[7] = {
     &daNpcPasser_c::browsea,
     &daNpcPasser_c::browseb,
     &daNpcPasser_c::talka,
@@ -670,13 +670,13 @@ daNpcPasser_c::seqFunc daNpcPasser_c::m_seq25_funcTbl[7] = {
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq26_funcTbl[3] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq26_funcTbl[3] = {
     &daNpcPasser_c::browsea,
     &daNpcPasser_c::browseb,
     NULL,
 };
 
-daNpcPasser_c::seqFunc daNpcPasser_c::m_seq27_funcTbl[1] = {
+DUSK_GAME_DATA daNpcPasser_c::seqFunc daNpcPasser_c::m_seq27_funcTbl[1] = {
     &daNpcPasser_c::waitTime,
 };
 
diff --git a/src/d/actor/d_a_npc_passer2.cpp b/src/d/actor/d_a_npc_passer2.cpp
index cc95c9e9a7..00656fb835 100644
--- a/src/d/actor/d_a_npc_passer2.cpp
+++ b/src/d/actor/d_a_npc_passer2.cpp
@@ -31,7 +31,7 @@ static int createHeapCallBack(fopAc_ac_c* i_this) {
     return actor->createHeap();
 }
 
-daNpcPasser2_c::actionFunc daNpcPasser2_c::ActionTable[1][2] = {
+DUSK_GAME_DATA daNpcPasser2_c::actionFunc daNpcPasser2_c::ActionTable[1][2] = {
     {&daNpcPasser2_c::initPath, &daNpcPasser2_c::executePath},
 };
 
diff --git a/src/d/actor/d_a_npc_post.cpp b/src/d/actor/d_a_npc_post.cpp
index 747ccd34c7..b26e4da1c7 100644
--- a/src/d/actor/d_a_npc_post.cpp
+++ b/src/d/actor/d_a_npc_post.cpp
@@ -159,7 +159,7 @@ enum Type {
     /* 0x3 */ TYPE_DEFAULT,
 };
 
-daNpc_Post_HIOParam const daNpc_Post_Param_c::m = {
+DUSK_GAME_DATA daNpc_Post_HIOParam const daNpc_Post_Param_c::m = {
     190.0f,
     -3.0f,
     1.0f,
@@ -354,12 +354,12 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {2, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Post_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Post_c::mCutNameList[2] = {
     "",
     "DELIVER",
 };
 
-daNpc_Post_c::cutFunc DUSK_CONST daNpc_Post_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_Post_c::cutFunc DUSK_CONST daNpc_Post_c::mCutList[2] = {
     NULL,
     &daNpc_Post_c::cutDeliver,
 };
diff --git a/src/d/actor/d_a_npc_pouya.cpp b/src/d/actor/d_a_npc_pouya.cpp
index 4d463bc91f..5b9ad82755 100644
--- a/src/d/actor/d_a_npc_pouya.cpp
+++ b/src/d/actor/d_a_npc_pouya.cpp
@@ -8,7 +8,7 @@
 #include "d/actor/d_a_npc_pouya.h"
 #include <cstring>
 
-const daNpc_Pouya_HIOParam daNpc_Pouya_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Pouya_HIOParam daNpc_Pouya_Param_c::m = {
     120.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
@@ -147,13 +147,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},  {-1, 0, 0},  {25, -1, 1}, {10, 0, 0},  {-1, 0, 0},  {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Pouya_c::mCutNameList[3] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Pouya_c::mCutNameList[3] = {
     "",
     "HAVE_FAVORTO_ASK",
     "RETURN_FAVOR",
 };
 
-daNpc_Pouya_c::cutFunc DUSK_CONST daNpc_Pouya_c::mCutList[3] = {
+DUSK_GAME_DATA daNpc_Pouya_c::cutFunc DUSK_CONST daNpc_Pouya_c::mCutList[3] = {
     NULL,
     &daNpc_Pouya_c::cutHaveFavorToAsk,
     &daNpc_Pouya_c::cutHaveFavorToAsk,
@@ -958,8 +958,23 @@ int daNpc_Pouya_c::cutHaveFavorToAsk(int param_0) {
                 switch (evt_id) {
                 case 1:
                     if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
+#if TARGET_PC
+                        const char* itemCheckName = nullptr;
+                        u32 itemGiveTag = 0;
+                        if (local_64 == dItemNo_DROP_BOTTLE_e) {
+                            itemCheckName = "jovani_reward_1";
+                        } else if (local_64 == dItemNo_SILVER_RUPEE_e) {
+                            itemCheckName = "jovani_reward_2";
+                        }
+                        if (itemCheckName != nullptr) {
+                            const auto itemCheck =
+                                dusk::mods::item_check_commit(itemCheckName, local_64, this);
+                            local_64 = itemCheck.itemNo;
+                            itemGiveTag = itemCheck.tag;
+                        }
+#endif
                         mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, local_64, 0,
-                                                                         -1, -1, 0, 0);
+                            -1, -1, 0, 0 IF_DUSK_ARG(itemGiveTag));
                     }
                     if (fopAcM_IsExecuting(mItemPartnerId)) {
                         field_0xfce = 1;
diff --git a/src/d/actor/d_a_npc_prayer.cpp b/src/d/actor/d_a_npc_prayer.cpp
index 146c73cef6..1e10121f56 100644
--- a/src/d/actor/d_a_npc_prayer.cpp
+++ b/src/d/actor/d_a_npc_prayer.cpp
@@ -42,12 +42,12 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[2] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Prayer";
 
-daNpcPray_c::EvtSeq DUSK_CONST daNpcPray_c::mEvtSeqList[] = {
+DUSK_GAME_DATA daNpcPray_c::EvtSeq DUSK_CONST daNpcPray_c::mEvtSeqList[] = {
     NULL,
     &daNpcPray_c::_Evt_GetHeart,
 };
 
-const daNpcPray_HIOParam daNpcPray_Param_c::m = {
+DUSK_GAME_DATA const daNpcPray_HIOParam daNpcPray_Param_c::m = {
     55.0f,
     -3.0f,
     1.0f,
@@ -720,7 +720,8 @@ fpc_ProcID daNpcPray_c::createHeart() {
     mDoMtx_stack_c::ZXYrotS(rot);
     mDoMtx_stack_c::multVec(&offset, &offset);
     pos += offset;
-    return fopAcM_createItemForBoss(&pos, dItemNo_KAKERA_HEART_e, fopAcM_GetRoomNo(this), &rot, &size, 0.0f, 0.0f, 0);
+    return fopAcM_createItemForBoss(&pos, dItemNo_KAKERA_HEART_e, fopAcM_GetRoomNo(this), &rot,
+        &size, 0.0f, 0.0f, 0 IF_DUSK_ARG("prayer_reward"));
 }
 
 BOOL daNpcPray_c::_Evt_GetHeart(int i_staffID) {
diff --git a/src/d/actor/d_a_npc_raca.cpp b/src/d/actor/d_a_npc_raca.cpp
index 71f367c693..42b01aeaff 100644
--- a/src/d/actor/d_a_npc_raca.cpp
+++ b/src/d/actor/d_a_npc_raca.cpp
@@ -150,13 +150,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {9, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Raca_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Raca_c::mCutNameList = "";
 
-daNpc_Raca_c::cutFunc DUSK_CONST daNpc_Raca_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_Raca_c::cutFunc DUSK_CONST daNpc_Raca_c::mCutList[1] = {
     NULL,
 };
 
-daNpc_Raca_HIOParam const daNpc_Raca_Param_c::m = {
+DUSK_GAME_DATA daNpc_Raca_HIOParam const daNpc_Raca_Param_c::m = {
     230.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_rafrel.cpp b/src/d/actor/d_a_npc_rafrel.cpp
index 2ed3cd3a21..d51d514785 100644
--- a/src/d/actor/d_a_npc_rafrel.cpp
+++ b/src/d/actor/d_a_npc_rafrel.cpp
@@ -97,7 +97,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[7] = {
     "RESIST_WIRETAP_RAFREL",
 };
 
-const daNpcRafrel_HIOParam daNpcRafrel_Param_c::m = {
+DUSK_GAME_DATA const daNpcRafrel_HIOParam daNpcRafrel_Param_c::m = {
     35.0f,
     -3.0f,
     1.0f,
@@ -152,7 +152,7 @@ void daNpcRafrel_HIO_c::genMessage(JORMContext* ctx) {
 static NPC_RAFREL_HIO_CLASS l_HIO;
 
 typedef BOOL (daNpcRafrel_c::*EventFn)(int);
-EventFn daNpcRafrel_c::mEvtSeqList[] = {
+DUSK_GAME_DATA EventFn daNpcRafrel_c::mEvtSeqList[] = {
     NULL,
     &daNpcRafrel_c::EvCut_Introduction,
     &daNpcRafrel_c::EvCut_Meeting,
@@ -1310,7 +1310,9 @@ bool daNpcRafrel_c::talk(void* param_0) {
                 OS_REPORT("会話終了時 イベントID=%d アイテムNo=%d\n", eventId, itemNo);
 
                 if (eventId == 1) {
-                    field_0xe00 = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL, NULL);
+                    DUSK_ITEM_CHECK("auru_memo", itemNo, this);
+                    field_0xe00 = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1,
+                        NULL, NULL DUSK_GIVE_TAG("auru_memo"));
                     if (field_0xe00 != fpcM_ERROR_PROCESS_ID_e) {
                         s16 eventIdx = dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xFF);
                         dComIfGp_getEvent()->reset(this);
@@ -1562,7 +1564,9 @@ int daNpcRafrel_c::EvCut_Appear(int i_staffId) {
             int itemNo = 0;
             u16 eventId = mFlow.getEventId(&itemNo);
             if (eventId == 1) {
-                field_0xe00 = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL, NULL);
+                DUSK_ITEM_CHECK("auru_memo", itemNo, this);
+                field_0xe00 = fopAcM_createItemForPresentDemo(
+                    &current.pos, itemNo, 0, -1, -1, NULL, NULL DUSK_GIVE_TAG("auru_memo"));
                 dComIfGp_event_setItemPartnerId(field_0xe00);
                 field_0xe00 = fpcM_ERROR_PROCESS_ID_e;
             }
diff --git a/src/d/actor/d_a_npc_saru.cpp b/src/d/actor/d_a_npc_saru.cpp
index efd8bf097a..4f98b7f6e9 100644
--- a/src/d/actor/d_a_npc_saru.cpp
+++ b/src/d/actor/d_a_npc_saru.cpp
@@ -11,7 +11,9 @@
 #include "d/actor/d_a_e_ym.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 enum saru_TW_RES_File_ID {
     /* BMDR */
@@ -216,21 +218,21 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {3, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Saru_c::mCutNameList[4] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Saru_c::mCutNameList[4] = {
     "",
     "FIND_MONKEY",
     "HELP_ME",
     "YM_LOOK",
 };
 
-daNpc_Saru_c::cutFunc DUSK_CONST daNpc_Saru_c::mCutList[4] = {
+DUSK_GAME_DATA daNpc_Saru_c::cutFunc DUSK_CONST daNpc_Saru_c::mCutList[4] = {
     NULL,
     &daNpc_Saru_c::cutFindMonkey,
     &daNpc_Saru_c::cutHelpMe,
     &daNpc_Saru_c::cutYmLook,
 };
 
-daNpc_Saru_HIOParam const daNpc_Saru_Param_c::m = {
+DUSK_GAME_DATA daNpc_Saru_HIOParam const daNpc_Saru_Param_c::m = {
     140.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_seib.cpp b/src/d/actor/d_a_npc_seib.cpp
index a022821d4b..e5ab22228b 100644
--- a/src/d/actor/d_a_npc_seib.cpp
+++ b/src/d/actor/d_a_npc_seib.cpp
@@ -46,13 +46,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {2, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {3, 0, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_seiB_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_seiB_c::mCutNameList = "";
 
-daNpc_seiB_c::cutFunc DUSK_CONST daNpc_seiB_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_seiB_c::cutFunc DUSK_CONST daNpc_seiB_c::mCutList[1] = {
     0,
 };
 
-daNpc_seiB_HIOParam const daNpc_seiB_Param_c::m = {
+DUSK_GAME_DATA daNpc_seiB_HIOParam const daNpc_seiB_Param_c::m = {
     0.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_seic.cpp b/src/d/actor/d_a_npc_seic.cpp
index 5525c52d57..bb94a59c39 100644
--- a/src/d/actor/d_a_npc_seic.cpp
+++ b/src/d/actor/d_a_npc_seic.cpp
@@ -49,13 +49,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_seiC_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_seiC_c::mCutNameList = "";
 
-daNpc_seiC_c::cutFunc DUSK_CONST daNpc_seiC_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_seiC_c::cutFunc DUSK_CONST daNpc_seiC_c::mCutList[1] = {
     0
 };
 
-daNpc_seiC_HIOParam const daNpc_seiC_Param_c::m = {
+DUSK_GAME_DATA daNpc_seiC_HIOParam const daNpc_seiC_Param_c::m = {
     0.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_seid.cpp b/src/d/actor/d_a_npc_seid.cpp
index 4e71129e00..ed96e2ebe5 100644
--- a/src/d/actor/d_a_npc_seid.cpp
+++ b/src/d/actor/d_a_npc_seid.cpp
@@ -49,13 +49,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_seiD_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_seiD_c::mCutNameList = "";
 
-daNpc_seiD_c::cutFunc DUSK_CONST daNpc_seiD_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_seiD_c::cutFunc DUSK_CONST daNpc_seiD_c::mCutList[1] = {
     0
 };
 
-daNpc_seiD_HIOParam const daNpc_seiD_Param_c::m = {
+DUSK_GAME_DATA daNpc_seiD_HIOParam const daNpc_seiD_Param_c::m = {
     0.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_seira.cpp b/src/d/actor/d_a_npc_seira.cpp
index e43eaad3bd..c8d0b52503 100644
--- a/src/d/actor/d_a_npc_seira.cpp
+++ b/src/d/actor/d_a_npc_seira.cpp
@@ -111,19 +111,19 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {25, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {2, -1, 1}, {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Seira_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Seira_c::mCutNameList[2] = {
     "",
     "CONVERSATION_ABOUT_SARU",
 };
 
-daNpc_Seira_c::cutFunc DUSK_CONST daNpc_Seira_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_Seira_c::cutFunc DUSK_CONST daNpc_Seira_c::mCutList[2] = {
     NULL,
     &daNpc_Seira_c::cutConversationAboutSaru,
 };
 
 static NPC_SEIRA_HIO_CLASS l_HIO;
 
-const daNpc_Seira_HIOParam daNpc_Seira_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Seira_HIOParam daNpc_Seira_Param_c::m = {
     210.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_seira2.cpp b/src/d/actor/d_a_npc_seira2.cpp
index 720b1d395b..fc5afa55bb 100644
--- a/src/d/actor/d_a_npc_seira2.cpp
+++ b/src/d/actor/d_a_npc_seira2.cpp
@@ -103,13 +103,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {24, 4, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Seira2_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Seira2_c::mCutNameList[1] = {""};
 
-daNpc_Seira2_c::cutFunc DUSK_CONST daNpc_Seira2_c::mCutList[1] = { NULL };
+DUSK_GAME_DATA daNpc_Seira2_c::cutFunc DUSK_CONST daNpc_Seira2_c::mCutList[1] = { NULL };
 
 static NPC_SEIRA2_HIO_CLASS l_HIO;
 
-const daNpc_Seira2_HIOParam daNpc_Seira2_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Seira2_HIOParam daNpc_Seira2_Param_c::m = {
     210.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_seirei.cpp b/src/d/actor/d_a_npc_seirei.cpp
index a957d51e67..85d9e83476 100644
--- a/src/d/actor/d_a_npc_seirei.cpp
+++ b/src/d/actor/d_a_npc_seirei.cpp
@@ -141,17 +141,17 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Seirei_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Seirei_c::mCutNameList[2] = {
     "",
     "CONVERSATION",
 };
 
-daNpc_Seirei_c::cutFunc DUSK_CONST daNpc_Seirei_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_Seirei_c::cutFunc DUSK_CONST daNpc_Seirei_c::mCutList[2] = {
     NULL,
     &daNpc_Seirei_c::cutConversation,
 };
 
-daNpc_Seirei_HIOParam const daNpc_Seirei_Param_c::m = {
+DUSK_GAME_DATA daNpc_Seirei_HIOParam const daNpc_Seirei_Param_c::m = {
     600.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_shad.cpp b/src/d/actor/d_a_npc_shad.cpp
index 99707fdf05..a93e02a94e 100644
--- a/src/d/actor/d_a_npc_shad.cpp
+++ b/src/d/actor/d_a_npc_shad.cpp
@@ -12,7 +12,7 @@
 #include "d/d_msg_object.h"
 #include <cstring>
 
-const daNpcShad_HIOParam daNpcShad_Param_c::m = {
+DUSK_GAME_DATA const daNpcShad_HIOParam daNpcShad_Param_c::m = {
     35.0f,      // attention_offset
     -3.0f,      // gravity
     1.0f,       // scale
@@ -310,7 +310,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Shad";
 
 static NPC_SHAD_HIO_CLASS l_HIO;
 
-daNpcShad_c::EventFn DUSK_CONST daNpcShad_c::mEvtSeqList[14] = {
+DUSK_GAME_DATA daNpcShad_c::EventFn DUSK_CONST daNpcShad_c::mEvtSeqList[14] = {
     NULL,
     &daNpcShad_c::EvCut_Introduction,
     &daNpcShad_c::EvCut_Meeting,
diff --git a/src/d/actor/d_a_npc_shaman.cpp b/src/d/actor/d_a_npc_shaman.cpp
index f5b32b7184..bb1e070c92 100644
--- a/src/d/actor/d_a_npc_shaman.cpp
+++ b/src/d/actor/d_a_npc_shaman.cpp
@@ -165,12 +165,12 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {7, 0, 1}, {0, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Sha_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Sha_c::mCutNameList[2] = {
     "",
     "PERFORM_AUGURY",
 };
 
-daNpc_Sha_c::cutFunc DUSK_CONST daNpc_Sha_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_Sha_c::cutFunc DUSK_CONST daNpc_Sha_c::mCutList[2] = {
     NULL,
     &daNpc_Sha_c::cutPerformAugury,
 };
@@ -193,7 +193,7 @@ daNpc_Sha_c::~daNpc_Sha_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-daNpc_Sha_HIOParam const daNpc_Sha_Param_c::m = {
+DUSK_GAME_DATA daNpc_Sha_HIOParam const daNpc_Sha_Param_c::m = {
     210.0f,
     -3.0f,
     1.0f,
@@ -1131,15 +1131,15 @@ int daNpc_Sha_c::test(void* param_1) {
     return 1;
 }
 
-const u16 daNpc_Sha_c::mEvtBitLabels[6] = {
+DUSK_GAME_DATA const u16 daNpc_Sha_c::mEvtBitLabels[6] = {
     0xF0FF, 0xEFFF, 0xEEFF, 0xEDFF, 0xECFF, 0xEBFF,
 };
 
-const u16 daNpc_Sha_c::mTmpBitLabels[6] = {
+DUSK_GAME_DATA const u16 daNpc_Sha_c::mTmpBitLabels[6] = {
     0xFAFF, 0xF9FF, 0xF8FF, 0xF7FF, 0xF6FF, 0xF5FF,
 };
 
-const int daNpc_Sha_c::mSceneChangeNoTable[48] = {
+DUSK_GAME_DATA const int daNpc_Sha_c::mSceneChangeNoTable[48] = {
     1, 2, 3, 4,
     5, 6, 7, 8,
     9, 0xA, 0xB, 0xC,
@@ -1154,7 +1154,7 @@ const int daNpc_Sha_c::mSceneChangeNoTable[48] = {
     0x2D, -1, -1, -1,
 };
 
-daNpc_Sha_c::queryFunc daNpc_Sha_c::mQueries[48] = {
+DUSK_GAME_DATA daNpc_Sha_c::queryFunc daNpc_Sha_c::mQueries[48] = {
     &daNpc_Sha_c::query000, &daNpc_Sha_c::query265, &daNpc_Sha_c::query000, &daNpc_Sha_c::query267,
     &daNpc_Sha_c::query000, &daNpc_Sha_c::query000, &daNpc_Sha_c::query078, &daNpc_Sha_c::query268,
     &daNpc_Sha_c::query265, &daNpc_Sha_c::query265, &daNpc_Sha_c::query078, &daNpc_Sha_c::query000,
diff --git a/src/d/actor/d_a_npc_shoe.cpp b/src/d/actor/d_a_npc_shoe.cpp
index 1fef7437a0..b7fcc2e14c 100644
--- a/src/d/actor/d_a_npc_shoe.cpp
+++ b/src/d/actor/d_a_npc_shoe.cpp
@@ -8,7 +8,7 @@
 #include "d/actor/d_a_npc_shoe.h"
 #include "d/actor/d_a_npc.h"
 
-const daNpcShoe_HIOParam daNpcShoe_Param_c::m = {
+DUSK_GAME_DATA const daNpcShoe_HIOParam daNpcShoe_Param_c::m = {
     55.0f,    // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
@@ -104,7 +104,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[1] = {NULL};
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Shoe";
 
-daNpcShoe_c::EventFn DUSK_CONST daNpcShoe_c::mEvtSeqList[1] = {NULL};
+DUSK_GAME_DATA daNpcShoe_c::EventFn DUSK_CONST daNpcShoe_c::mEvtSeqList[1] = {NULL};
 
 daNpcShoe_c::daNpcShoe_c() {}
 
diff --git a/src/d/actor/d_a_npc_shop0.cpp b/src/d/actor/d_a_npc_shop0.cpp
index 3612cd846e..eaa0b1d603 100644
--- a/src/d/actor/d_a_npc_shop0.cpp
+++ b/src/d/actor/d_a_npc_shop0.cpp
@@ -8,7 +8,9 @@
 #include "d/actor/d_a_npc_shop0.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static int createHeapCallBack(fopAc_ac_c* i_this) {
     return static_cast<daNpc_Shop0_c*>(i_this)->createHeap();
@@ -39,7 +41,7 @@ int daNpc_Shop0_c::create() {
     return phase_step;
 }
 
-dCcD_SrcCyl const daNpc_Shop0_c::mCylDat = {
+DUSK_GAME_DATA dCcD_SrcCyl const daNpc_Shop0_c::mCylDat = {
     {
         {
             0x0, // mFlags
@@ -62,7 +64,7 @@ dCcD_SrcCyl const daNpc_Shop0_c::mCylDat = {
     }
 };
 
-daNpc_Shop0_Param_c::param const daNpc_Shop0_Param_c::mParam = {
+DUSK_GAME_DATA daNpc_Shop0_Param_c::param const daNpc_Shop0_Param_c::mParam = {
     0x44480000, 
     0x44480000,
     0x41F00000,
diff --git a/src/d/actor/d_a_npc_sola.cpp b/src/d/actor/d_a_npc_sola.cpp
index 093a1cbee6..cf0b21dd32 100644
--- a/src/d/actor/d_a_npc_sola.cpp
+++ b/src/d/actor/d_a_npc_sola.cpp
@@ -60,13 +60,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_solA_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_solA_c::mCutNameList[1] = {""};
 
-daNpc_solA_c::cutFunc DUSK_CONST daNpc_solA_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_solA_c::cutFunc DUSK_CONST daNpc_solA_c::mCutList[1] = {
     NULL,
 };
 
-daNpc_solA_HIOParam const daNpc_solA_Param_c::m = {
+DUSK_GAME_DATA daNpc_solA_HIOParam const daNpc_solA_Param_c::m = {
     220.0f, -3.0f, 1.0f,   400.0f, 255.0f, 200.0f, 35.0f, 30.0f, 0.0f, 0.0f,  10.0f,
     -10.0f, 30.0f, -10.0f, 45.0f,  -45.0f, 0.6f,   12.0f, 3,     6,    5,     6,
     0.0f,   0.0f,  0.0f,   0.0f,   60,     8,      0,     0,     0,    false, false,
diff --git a/src/d/actor/d_a_npc_soldierA.cpp b/src/d/actor/d_a_npc_soldierA.cpp
index d3baf97440..a6fd6e6abb 100644
--- a/src/d/actor/d_a_npc_soldierA.cpp
+++ b/src/d/actor/d_a_npc_soldierA.cpp
@@ -133,13 +133,13 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNames[1] = {"chtSolA"};
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "chtSolA";
 
-char DUSK_CONST* DUSK_CONST daNpc_SoldierA_c::mEvtCutNameList[3] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_SoldierA_c::mEvtCutNameList[3] = {
     "",
     "TALK_LAKE",
     "LISTEN_LAKE",
 };
 
-daNpc_SoldierA_c::cutFunc DUSK_CONST daNpc_SoldierA_c::mEvtCutList[3] = {
+DUSK_GAME_DATA daNpc_SoldierA_c::cutFunc DUSK_CONST daNpc_SoldierA_c::mEvtCutList[3] = {
     NULL,
     &daNpc_SoldierA_c::ECut_talkLake,
     &daNpc_SoldierA_c::ECut_listenLake,
@@ -163,7 +163,7 @@ daNpc_SoldierA_c::~daNpc_SoldierA_c() {
     #endif
 }
 
-daNpc_SoldierA_HIOParam const daNpc_SoldierA_Param_c::m = {
+DUSK_GAME_DATA daNpc_SoldierA_HIOParam const daNpc_SoldierA_Param_c::m = {
     30.0f,
     -4.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_soldierB.cpp b/src/d/actor/d_a_npc_soldierB.cpp
index e867c2b660..b8289f479f 100644
--- a/src/d/actor/d_a_npc_soldierB.cpp
+++ b/src/d/actor/d_a_npc_soldierB.cpp
@@ -106,12 +106,12 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNames[1] = {"chtSolB"};
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "chtSolB";
 
-char DUSK_CONST* DUSK_CONST daNpc_SoldierB_c::mEvtCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_SoldierB_c::mEvtCutNameList[2] = {
     "",
     "LISTEN_LAKE",
 };
 
-daNpc_SoldierB_c::cutFunc DUSK_CONST daNpc_SoldierB_c::mEvtCutList[2] = {
+DUSK_GAME_DATA daNpc_SoldierB_c::cutFunc DUSK_CONST daNpc_SoldierB_c::mEvtCutList[2] = {
     NULL,
     &daNpc_SoldierB_c::ECut_listenLake,
 };
@@ -128,7 +128,7 @@ daNpc_SoldierB_c::~daNpc_SoldierB_c() {
     }
 }
 
-daNpc_SoldierB_HIOParam const daNpc_SoldierB_Param_c::m = {
+DUSK_GAME_DATA daNpc_SoldierB_HIOParam const daNpc_SoldierB_Param_c::m = {
     30.0f,    // attention_offset
     -4.0f,    // gravity
     1.0f,     // scale
diff --git a/src/d/actor/d_a_npc_taro.cpp b/src/d/actor/d_a_npc_taro.cpp
index efb3cddf4b..1a6a3473e3 100644
--- a/src/d/actor/d_a_npc_taro.cpp
+++ b/src/d/actor/d_a_npc_taro.cpp
@@ -198,7 +198,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {40, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {40, -1, 1}, {41, -1, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Taro_c::mCutNameList[17] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Taro_c::mCutNameList[17] = {
     "",
     "CONVERSATION_ABOUT_PACHINKO",
     "CONVERSATION_ABOUT_WOODSWD",
@@ -218,7 +218,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Taro_c::mCutNameList[17] = {
     "TAG_PUSH4",
 };
 
-daNpc_Taro_c::cutFunc DUSK_CONST daNpc_Taro_c::mCutList[17] = {
+DUSK_GAME_DATA daNpc_Taro_c::cutFunc DUSK_CONST daNpc_Taro_c::mCutList[17] = {
     NULL,
     &daNpc_Taro_c::cutConversationAboutPachinko,
     &daNpc_Taro_c::cutConversationAboutWoodSwd,
@@ -240,7 +240,7 @@ daNpc_Taro_c::cutFunc DUSK_CONST daNpc_Taro_c::mCutList[17] = {
 
 static NPC_TARO_HIO_CLASS l_HIO;
 
-daNpc_Taro_HIOParam const daNpc_Taro_Param_c::m = {
+DUSK_GAME_DATA daNpc_Taro_HIOParam const daNpc_Taro_Param_c::m = {
     140.0f, -3.0f,  1.0f,   400.0f, 255.0f, 120.0f, 35.0f, 30.0f, 0.0f, 0.0f, 10.0f,
     -10.0f, 30.0f,  -10.0f, 45.0f,  -45.0f, 0.6f,   12.0f, 3,     6,    5,    6,
     110.0f, 0.0f,   0.0f,   0.0f,   60,     8,      0,     0,     0,    0,    0,
diff --git a/src/d/actor/d_a_npc_the.cpp b/src/d/actor/d_a_npc_the.cpp
index 8a1a23d122..7291e14715 100644
--- a/src/d/actor/d_a_npc_the.cpp
+++ b/src/d/actor/d_a_npc_the.cpp
@@ -12,7 +12,7 @@
 #include "SSystem/SComponent/c_math.h"
 #include <cstring>
 
-const daNpcThe_HIOParam daNpcThe_Param_c::m = {
+DUSK_GAME_DATA const daNpcThe_HIOParam daNpcThe_Param_c::m = {
     220.0f,   // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
@@ -155,14 +155,14 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[4] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "The";
 
-char DUSK_CONST* DUSK_CONST daNpcThe_c::mEvtCutNameList[4] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpcThe_c::mEvtCutNameList[4] = {
     "",
     "TW_RESISTANCE",
     "TW_RESISTANCE",
     "THE_INTRODUCTION",
 };
 
-daNpcThe_c::EventFn DUSK_CONST daNpcThe_c::mEvtCutList[4] = {
+DUSK_GAME_DATA daNpcThe_c::EventFn DUSK_CONST daNpcThe_c::mEvtCutList[4] = {
     NULL,
     &daNpcThe_c::EvCut_TwResistance,
     &daNpcThe_c::EvCut_TwResistance,
@@ -823,8 +823,9 @@ BOOL daNpcThe_c::talk(void* param_0) {
                     }
                     int item_no = 0;
                     if (mFlow.getEventId(&item_no) == 1) {
+                        DUSK_ITEM_CHECK("telma_invoice", item_no, this);
                         mItemID = fopAcM_createItemForPresentDemo(&current.pos, item_no, 0, -1, -1,
-                                                                  NULL, NULL);
+                            NULL, NULL DUSK_GIVE_TAG("telma_invoice"));
                         if (mItemID != -1) {
                             s16 event_id = dComIfGp_getEventManager().getEventIdx(
                                 this, "DEFAULT_GETITEM", 0xff);
diff --git a/src/d/actor/d_a_npc_theB.cpp b/src/d/actor/d_a_npc_theB.cpp
index efee49d934..01e371277b 100644
--- a/src/d/actor/d_a_npc_theB.cpp
+++ b/src/d/actor/d_a_npc_theB.cpp
@@ -174,7 +174,7 @@ void daNpcTheB_HIO_c::genMessage(JORMContext* ctx) {
 }
 #endif
 
-daNpcTheB_c::cutFunc daNpcTheB_c::mEvtSeqList[6] = {
+DUSK_GAME_DATA daNpcTheB_c::cutFunc daNpcTheB_c::mEvtSeqList[6] = {
     NULL,
     &daNpcTheB_c::EvCut_PersonalCombatIntro,
     &daNpcTheB_c::EvCut_PersonalCombatRevenge,
@@ -199,7 +199,7 @@ daNpcTheB_c::~daNpcTheB_c() {
     #endif
 }
 
-daNpcTheB_HIOParam const daNpcTheB_Param_c::m = {
+DUSK_GAME_DATA daNpcTheB_HIOParam const daNpcTheB_Param_c::m = {
     115.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_tkc.cpp b/src/d/actor/d_a_npc_tkc.cpp
index e05fb64024..94fa1538b3 100644
--- a/src/d/actor/d_a_npc_tkc.cpp
+++ b/src/d/actor/d_a_npc_tkc.cpp
@@ -126,7 +126,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Tkc";
 
 static NPC_TKC_HIO_CLASS l_HIO;
 
-daNpcTkc_c::evtFunc daNpcTkc_c::mEvtSeqList[4] = {
+DUSK_GAME_DATA daNpcTkc_c::evtFunc daNpcTkc_c::mEvtSeqList[4] = {
     NULL,
     &daNpcTkc_c::EvCut_TksSecretChild,
     &daNpcTkc_c::EvCut_TksWarpExit,
@@ -149,7 +149,7 @@ daNpcTkc_c::~daNpcTkc_c() {
     #endif
 }
 
-daNpcTkc_HIOParam const daNpcTkc_Param_c::m = {
+DUSK_GAME_DATA daNpcTkc_HIOParam const daNpcTkc_Param_c::m = {
     10.0f,
     0.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_tkj.cpp b/src/d/actor/d_a_npc_tkj.cpp
index 4a798bcb4d..909b72b4b4 100644
--- a/src/d/actor/d_a_npc_tkj.cpp
+++ b/src/d/actor/d_a_npc_tkj.cpp
@@ -64,17 +64,17 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpcTkj_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpcTkj_c::mCutNameList[2] = {
     "",
     "LV7_FIRST_START",
 };
 
-int (daNpcTkj_c::* DUSK_CONST daNpcTkj_c::mCutList[])(int) = {
+DUSK_GAME_DATA int (daNpcTkj_c::* DUSK_CONST daNpcTkj_c::mCutList[])(int) = {
     NULL,
     &daNpcTkj_c::cutLv7Start,
 };
 
-const daNpc_Tkj_HIOParam daNpc_Tkj_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Tkj_HIOParam daNpc_Tkj_Param_c::m = {
     120.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_tks.cpp b/src/d/actor/d_a_npc_tks.cpp
index 0399b36dd6..9990e4834b 100644
--- a/src/d/actor/d_a_npc_tks.cpp
+++ b/src/d/actor/d_a_npc_tks.cpp
@@ -202,7 +202,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_arcName = "TKS";
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Tks";
 
-daNpcTks_HIOParam const daNpcTks_Param_c::m = {
+DUSK_GAME_DATA daNpcTks_HIOParam const daNpcTks_Param_c::m = {
     90.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_toby.cpp b/src/d/actor/d_a_npc_toby.cpp
index 78b6b08dee..d42787e2a2 100644
--- a/src/d/actor/d_a_npc_toby.cpp
+++ b/src/d/actor/d_a_npc_toby.cpp
@@ -14,10 +14,13 @@
 #include "d/actor/d_a_obj_automata.h"
 #include "d/d_msg_object.h"
 #include "d/actor/d_a_obj_scannon.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
 
-const daNpc_Toby_HIOParam daNpc_Toby_Param_c::m = {
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
+DUSK_GAME_DATA const daNpc_Toby_HIOParam daNpc_Toby_Param_c::m = {
     160.0f,
     -3.0f,
     1.0f,
@@ -247,7 +250,7 @@ enum NPC_TOBY_CUTS {
     CUT_CONVERSATION_ABOUT_ZRA = 6,
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Toby_c::mCutNameList[7] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Toby_c::mCutNameList[7] = {
     "",
     "TOBY_HOUSE_FIRE",
     "TALKTO_ONESELF",
@@ -257,7 +260,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Toby_c::mCutNameList[7] = {
     "CONVERSATION_ABOUT_ZRA",
 };
 
-daNpc_Toby_c::cutFunc DUSK_CONST daNpc_Toby_c::mCutList[7] = {
+DUSK_GAME_DATA daNpc_Toby_c::cutFunc DUSK_CONST daNpc_Toby_c::mCutList[7] = {
     NULL,
     &daNpc_Toby_c::cutTobyHouseFire,
     &daNpc_Toby_c::cutTalkToOneself,
@@ -1399,7 +1402,7 @@ int daNpc_Toby_c::cutRepairSCannon(int arg0) {
                 old.pos = current.pos;
                 setAngle(cM_deg2s(5.0f * f32(mPath.getArg0())));
                 mEventTimer = mPath.getArg2();
-                dusk::frame_interp::request_presentation_sync();
+                IF_DUSK(dusk::interp::request_presentation_sync());
             }
         } else if (!mHide) {
             mHide = 1;
diff --git a/src/d/actor/d_a_npc_uri.cpp b/src/d/actor/d_a_npc_uri.cpp
index f28ac6109e..afb1d11b1b 100644
--- a/src/d/actor/d_a_npc_uri.cpp
+++ b/src/d/actor/d_a_npc_uri.cpp
@@ -10,7 +10,7 @@
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>
 
-const daNpc_Uri_HIOParam daNpc_Uri_Param_c::m = {
+DUSK_GAME_DATA const daNpc_Uri_HIOParam daNpc_Uri_Param_c::m = {
     200.0f,   // attention_offset
     -3.0f,    // gravity
     1.0f,     // scale
@@ -190,7 +190,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0},
 };
 
-const char* daNpc_Uri_c::mCutNameList[7] = {
+DUSK_GAME_DATA const char* daNpc_Uri_c::mCutNameList[7] = {
     "",
     "CONVERSATION",
     "START_CARRY_TUTORIAL",
@@ -200,7 +200,7 @@ const char* daNpc_Uri_c::mCutNameList[7] = {
     "MEETING_AGAIN",
 };
 
-daNpc_Uri_c::cutFunc DUSK_CONST daNpc_Uri_c::mCutList[7] = {
+DUSK_GAME_DATA daNpc_Uri_c::cutFunc DUSK_CONST daNpc_Uri_c::mCutList[7] = {
     NULL,
     &daNpc_Uri_c::cutConversation,
     &daNpc_Uri_c::cutStartCarryTutorial,
@@ -1165,8 +1165,9 @@ int daNpc_Uri_c::cutEndCarryTutorial(int param_1) {
             (s32)mFlow.getEventId(&local_48) == 1)
         {
             if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                mItemPartnerId =
-                    fopAcM_createItemForPresentDemo(&current.pos, local_48, 0, -1, -1, NULL, NULL);
+                DUSK_ITEM_CHECK("uli_cradle_reward", local_48, this);
+                mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, local_48, 0, -1, -1,
+                    NULL, NULL DUSK_GIVE_TAG("uli_cradle_reward"));
             }
             if (fopAcM_IsExecuting(mItemPartnerId)) {
                 /* T_0007 - Ordon Village - During Uli's pick-up tutorial */
diff --git a/src/d/actor/d_a_npc_wrestler.cpp b/src/d/actor/d_a_npc_wrestler.cpp
index e31404e1da..a7e71f5902 100644
--- a/src/d/actor/d_a_npc_wrestler.cpp
+++ b/src/d/actor/d_a_npc_wrestler.cpp
@@ -388,7 +388,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "Wrestler";
 
 static NPC_WRESTLER_HIO_CLASS l_HIO;
 
-const daNpcWrestler_HIOParam daNpcWrestler_Param_c::m = {
+DUSK_GAME_DATA const daNpcWrestler_HIOParam daNpcWrestler_Param_c::m = {
     220.0f,
     -3.0f,
     1.0f,
@@ -646,7 +646,7 @@ void daNpcWrestler_HIO_c::genMessage(JORMContext* ctext) {
 }
 #endif
 
-daNpcWrestler_c::EventFn DUSK_CONST daNpcWrestler_c::mEvtSeqList[7] = {
+DUSK_GAME_DATA daNpcWrestler_c::EventFn DUSK_CONST daNpcWrestler_c::mEvtSeqList[7] = {
     NULL,
     &daNpcWrestler_c::EvCut_grDSEntry,
     &daNpcWrestler_c::EvCut_grDSEntry2,
diff --git a/src/d/actor/d_a_npc_yamid.cpp b/src/d/actor/d_a_npc_yamid.cpp
index 4593ee2946..d43458bd32 100644
--- a/src/d/actor/d_a_npc_yamid.cpp
+++ b/src/d/actor/d_a_npc_yamid.cpp
@@ -121,12 +121,12 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {1, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_yamiD_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_yamiD_c::mCutNameList[2] = {
     "",
     "STOPPER",
 };
 
-daNpc_yamiD_c::cutFunc DUSK_CONST daNpc_yamiD_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_yamiD_c::cutFunc DUSK_CONST daNpc_yamiD_c::mCutList[2] = {
     NULL,
     &daNpc_yamiD_c::cutStopper,
 };
@@ -145,7 +145,7 @@ daNpc_yamiD_c::~daNpc_yamiD_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-daNpc_yamiD_HIOParam const daNpc_yamiD_Param_c::m = {
+DUSK_GAME_DATA daNpc_yamiD_HIOParam const daNpc_yamiD_Param_c::m = {
     180.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_yamis.cpp b/src/d/actor/d_a_npc_yamis.cpp
index 24272132fb..ca7e52f130 100644
--- a/src/d/actor/d_a_npc_yamis.cpp
+++ b/src/d/actor/d_a_npc_yamis.cpp
@@ -77,12 +77,12 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {1, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_yamiS_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_yamiS_c::mCutNameList[2] = {
     "",
     "STOPPER",
 };
 
-daNpc_yamiS_c::cutFunc DUSK_CONST daNpc_yamiS_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_yamiS_c::cutFunc DUSK_CONST daNpc_yamiS_c::mCutList[2] = {
     NULL,
     &daNpc_yamiS_c::cutStopper,
 };
@@ -94,7 +94,7 @@ daNpc_yamiS_c::~daNpc_yamiS_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-const daNpc_yamiS_HIOParam daNpc_yamiS_Param_c::m = {
+DUSK_GAME_DATA const daNpc_yamiS_HIOParam daNpc_yamiS_Param_c::m = {
     140.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
diff --git a/src/d/actor/d_a_npc_yamit.cpp b/src/d/actor/d_a_npc_yamit.cpp
index 1c6b25740d..ac67845d70 100644
--- a/src/d/actor/d_a_npc_yamit.cpp
+++ b/src/d/actor/d_a_npc_yamit.cpp
@@ -80,12 +80,12 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0}, {-1, 0, 0}, {2, -1, 1}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_yamiT_c::mCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_yamiT_c::mCutNameList[2] = {
     "",
     "STOPPER",
 };
 
-daNpc_yamiT_c::cutFunc DUSK_CONST daNpc_yamiT_c::mCutList[2] = {
+DUSK_GAME_DATA daNpc_yamiT_c::cutFunc DUSK_CONST daNpc_yamiT_c::mCutList[2] = {
     NULL,
     &daNpc_yamiT_c::cutStopper,
 };
@@ -97,7 +97,7 @@ daNpc_yamiT_c::~daNpc_yamiT_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-const daNpc_yamiT_HIOParam daNpc_yamiT_Param_c::m = {
+DUSK_GAME_DATA const daNpc_yamiT_HIOParam daNpc_yamiT_Param_c::m = {
     230.0f,  // attention_offset
     -3.0f,   // gravity
     1.0f,    // scale
diff --git a/src/d/actor/d_a_npc_yelia.cpp b/src/d/actor/d_a_npc_yelia.cpp
index 25aa37d896..d826abd947 100644
--- a/src/d/actor/d_a_npc_yelia.cpp
+++ b/src/d/actor/d_a_npc_yelia.cpp
@@ -9,7 +9,9 @@
 #include "d/actor/d_a_demo_item.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static DUSK_CONSTEXPR daNpc_GetParam1 l_bmdData[3] = {
     {3, 1},
@@ -192,7 +194,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {32, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Yelia_c::mCutNameList[6] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Yelia_c::mCutNameList[6] = {
     "",
     "CONVERSATION_ABOUT_LOOPHOLE",
     "TW_RESISTANCE",
@@ -201,7 +203,7 @@ char DUSK_CONST* DUSK_CONST daNpc_Yelia_c::mCutNameList[6] = {
     "THANK_YOU",
 };
 
-BOOL (daNpc_Yelia_c::*daNpc_Yelia_c::mCutList[6])(int) = {
+DUSK_GAME_DATA BOOL (daNpc_Yelia_c::*daNpc_Yelia_c::mCutList[6])(int) = {
     NULL,
     &daNpc_Yelia_c::cutConversationAboutLoopHole,
     &daNpc_Yelia_c::cutTWResistance,
@@ -298,7 +300,7 @@ enum Motion {
     /* 0x21 */ MOTION_KIZUKU_WAIT,
 };
 
-daNpc_Yelia_HIOParam const daNpc_Yelia_Param_c::m = {
+DUSK_GAME_DATA daNpc_Yelia_HIOParam const daNpc_Yelia_Param_c::m = {
     170.0f,   // mAttnOffsetY
     -3.0f,    // mGravity
     1.0f,     // mScale
diff --git a/src/d/actor/d_a_npc_ykm.cpp b/src/d/actor/d_a_npc_ykm.cpp
index 65beb46e4e..d4ac67b04c 100644
--- a/src/d/actor/d_a_npc_ykm.cpp
+++ b/src/d/actor/d_a_npc_ykm.cpp
@@ -175,7 +175,7 @@ enum RES_Name {
     /* 0x4 */ YKM3,
 };
 
-daNpc_ykM_HIOParam const daNpc_ykM_Param_c::m = {
+DUSK_GAME_DATA daNpc_ykM_HIOParam const daNpc_ykM_Param_c::m = {
     500.0f,
     -4.0f,
     1.0f,
@@ -511,7 +511,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0x27, -1, 1}, {0x28, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_ykM_c::mCutNameList[10] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_ykM_c::mCutNameList[10] = {
     "",
     "SLIDEDOWN",
     "MEETING_AGAIN",
@@ -524,7 +524,7 @@ char DUSK_CONST* DUSK_CONST daNpc_ykM_c::mCutNameList[10] = {
     "HUG"
 };
 
-daNpc_ykM_c::cutFunc DUSK_CONST daNpc_ykM_c::mCutList[10] = {
+DUSK_GAME_DATA daNpc_ykM_c::cutFunc DUSK_CONST daNpc_ykM_c::mCutList[10] = {
     NULL,
     &daNpc_ykM_c::cutSlideDown,
     &daNpc_ykM_c::cutMeetingAgain,
diff --git a/src/d/actor/d_a_npc_ykw.cpp b/src/d/actor/d_a_npc_ykw.cpp
index f2e195087d..f79b71b7e2 100644
--- a/src/d/actor/d_a_npc_ykw.cpp
+++ b/src/d/actor/d_a_npc_ykw.cpp
@@ -20,7 +20,9 @@
 #include "m_Do/m_Do_ext.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 #if DEBUG
 class daNpc_ykW_HIO_c : public mDoHIO_entry_c {
@@ -157,7 +159,7 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {23, 0, 1}, {24, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-const char* daNpc_ykW_c::mCutNameList[8] = {
+DUSK_GAME_DATA const char* daNpc_ykW_c::mCutNameList[8] = {
     "",
     "SHOW_DOOR",
     "GO_INTO_BOSSROOM",
@@ -168,7 +170,7 @@ const char* daNpc_ykW_c::mCutNameList[8] = {
     "HUG",
 };
 
-daNpc_ykW_c::cutFunc DUSK_CONST daNpc_ykW_c::mCutList[8] = {
+DUSK_GAME_DATA daNpc_ykW_c::cutFunc DUSK_CONST daNpc_ykW_c::mCutList[8] = {
     NULL,
     &daNpc_ykW_c::cutShowDoor,
     &daNpc_ykW_c::cutGoIntoBossRoom,
@@ -272,7 +274,7 @@ daNpc_ykW_c::~daNpc_ykW_c() {
     daNpcT_offTmpBit(0x55);
 }
 
-const daNpc_ykW_HIOParam daNpc_ykW_Param_c::m = {
+DUSK_GAME_DATA const daNpc_ykW_HIOParam daNpc_ykW_Param_c::m = {
     {
         250.0f, -3.0f, 1.0f, 500.0f, 255.0f, 230.0f, 35.0f, 60.0f,
         0.0f, 0.0f, 20.0f, -20.0f, 15.0f, -15.0f, 20.0f, -20.0f,
@@ -2213,8 +2215,9 @@ int daNpc_ykW_c::cutEndSnowboardRace(int param_0) {
             switch (eventId) {
             case 1:
                 if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                    mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, itemId, 0,
-                                                            -1, -1, 0, 0);
+                    DUSK_ITEM_CHECK("snowboard_race_reward", itemId, this);
+                    mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, itemId, 0, -1,
+                        -1, 0, 0 DUSK_GIVE_TAG("snowboard_race_reward"));
                 }
 
                 if (fopAcM_IsExecuting(mItemPartnerId)) {
@@ -2911,8 +2914,9 @@ int daNpc_ykW_c::talk(void* param_0) {
                     switch (eventId) {
                     case 1:
                         if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                            mItemPartnerId =
-                                fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, 0, 0);
+                            DUSK_ITEM_CHECK("dungeon_map:D_MN11", itemNo, this);
+                            mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, itemNo,
+                                0, -1, -1, 0, 0 DUSK_GIVE_TAG("dungeon_map:D_MN11"));
                         }
 
                         if (fopAcM_IsExecuting(mItemPartnerId)) {
diff --git a/src/d/actor/d_a_npc_zanb.cpp b/src/d/actor/d_a_npc_zanb.cpp
index 9bbcb9d71b..69775de42e 100644
--- a/src/d/actor/d_a_npc_zanb.cpp
+++ b/src/d/actor/d_a_npc_zanb.cpp
@@ -73,9 +73,9 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {1, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_zanB_c::mCutNameList[1] = {""};
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_zanB_c::mCutNameList[1] = {""};
 
-daNpc_zanB_c::cutFunc DUSK_CONST daNpc_zanB_c::mCutList[1] = {NULL};
+DUSK_GAME_DATA daNpc_zanB_c::cutFunc DUSK_CONST daNpc_zanB_c::mCutList[1] = {NULL};
 
 daNpc_zanB_c::~daNpc_zanB_c() {
     OS_REPORT("|%06d:%x|daNpc_zanB_c -> デストラクト\n", g_Counter.mCounter0, this);
@@ -93,7 +93,7 @@ daNpc_zanB_c::~daNpc_zanB_c() {
     deleteRes(l_loadResPtrnList[mType], (const char**)l_resNameList);
 }
 
-daNpc_zanB_HIOParam const daNpc_zanB_Param_c::m = {
+DUSK_GAME_DATA daNpc_zanB_HIOParam const daNpc_zanB_Param_c::m = {
     270.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_zant.cpp b/src/d/actor/d_a_npc_zant.cpp
index a63c13bf6c..ba13a93954 100644
--- a/src/d/actor/d_a_npc_zant.cpp
+++ b/src/d/actor/d_a_npc_zant.cpp
@@ -51,15 +51,15 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0}, {-1, 0, 0}
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_Zant_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_Zant_c::mCutNameList = "";
 
-daNpc_Zant_c::cutFunc DUSK_CONST daNpc_Zant_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_Zant_c::cutFunc DUSK_CONST daNpc_Zant_c::mCutList[1] = {
     NULL
 };
 
 static NPC_ZANT_HIO_CLASS l_HIO;
 
-daNpc_Zant_HIOParam const daNpc_Zant_Param_c::m  = {
+DUSK_GAME_DATA daNpc_Zant_HIOParam const daNpc_Zant_Param_c::m  = {
     270.0f, -3.0f, 1.0f, 500.0f, 255.0f, 250.0f, 35.0f, 50.0f,
     0.0f, 0.0f, 10.0f, -10.0f, 30.0f, -10.0f, 45.0f, -45.0f,
     0.6f, 12.0f, 3, 6, 5, 6, 110.0f, 0.0f, 0.0f, 0.0f, 60, 8,
diff --git a/src/d/actor/d_a_npc_zelR.cpp b/src/d/actor/d_a_npc_zelR.cpp
index 25c63aea38..3e1b8cb2cb 100644
--- a/src/d/actor/d_a_npc_zelR.cpp
+++ b/src/d/actor/d_a_npc_zelR.cpp
@@ -57,15 +57,15 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {-1, 0, 0}, {-1, 0, 0}
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_ZelR_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_ZelR_c::mCutNameList = "";
 
-daNpc_ZelR_c::EventFn daNpc_ZelR_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_ZelR_c::EventFn daNpc_ZelR_c::mCutList[1] = {
     NULL
 };
 
 static NPC_ZELR_HIO_CLASS l_HIO;
 
-daNpc_ZelR_HIOParam const daNpc_ZelR_Param_c::m = {
+DUSK_GAME_DATA daNpc_ZelR_HIOParam const daNpc_ZelR_Param_c::m = {
     190.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_zelRo.cpp b/src/d/actor/d_a_npc_zelRo.cpp
index 3cf7d29f2a..213de4d018 100644
--- a/src/d/actor/d_a_npc_zelRo.cpp
+++ b/src/d/actor/d_a_npc_zelRo.cpp
@@ -83,13 +83,13 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_ZelRo_c::mCutNameList = "";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_ZelRo_c::mCutNameList = "";
 
-daNpc_ZelRo_c::cutFunc DUSK_CONST daNpc_ZelRo_c::mCutList[1] = {
+DUSK_GAME_DATA daNpc_ZelRo_c::cutFunc DUSK_CONST daNpc_ZelRo_c::mCutList[1] = {
     NULL
 };
 
-const daNpc_ZelRo_HIOParam daNpc_ZelRo_Param_c::m = {
+DUSK_GAME_DATA const daNpc_ZelRo_HIOParam daNpc_ZelRo_Param_c::m = {
     190.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_npc_zelda.cpp b/src/d/actor/d_a_npc_zelda.cpp
index b40ff46be3..065ac236f9 100644
--- a/src/d/actor/d_a_npc_zelda.cpp
+++ b/src/d/actor/d_a_npc_zelda.cpp
@@ -53,8 +53,8 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {0, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {1, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-const char* daNpc_Zelda_c::mCutNameList = "";
-daNpc_Zelda_c::cutFunc DUSK_CONST daNpc_Zelda_c::mCutList[1] = { 0 };
+DUSK_GAME_DATA const char* daNpc_Zelda_c::mCutNameList = "";
+DUSK_GAME_DATA daNpc_Zelda_c::cutFunc DUSK_CONST daNpc_Zelda_c::mCutList[1] = { 0 };
 
 static NPC_ZELDA_HIO_CLASS l_HIO;
 
@@ -108,7 +108,7 @@ daNpc_Zelda_c::~daNpc_Zelda_c() {
     deleteRes(l_loadResPtrnList[field_0xf80], (const char**)l_resNameList);
 }
 
-const daNpc_Zelda_HIOParam daNpc_Zelda_Param_c::m = {{
+DUSK_GAME_DATA const daNpc_Zelda_HIOParam daNpc_Zelda_Param_c::m = {{
     190.0f, // attention_offset
     -3.0f, // gravity
     1.0f, // scale
diff --git a/src/d/actor/d_a_npc_zra.cpp b/src/d/actor/d_a_npc_zra.cpp
index a33e32feef..f77200c514 100644
--- a/src/d/actor/d_a_npc_zra.cpp
+++ b/src/d/actor/d_a_npc_zra.cpp
@@ -20,9 +20,13 @@
 #include "d/actor/d_a_obj_zraMark.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 static NPC_ZRA_HIO_CLASS l_HIO;
 
-daNpc_zrA_HIOParam const daNpc_zrA_Param_c::m = {
+DUSK_GAME_DATA daNpc_zrA_HIOParam const daNpc_zrA_Param_c::m = {
     230.0f,   // mAttnOffsetY
     -3.0f,    // mGravity
     1.0f,     // mScale
@@ -410,7 +414,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_myName[4] = {
     "zrWF",
 };
 
-char DUSK_CONST* DUSK_CONST daNpc_zrA_c::mEvtCutNameList[11] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_zrA_c::mEvtCutNameList[11] = {
     "",
     "TALK_SWIM",
     "BEFORE_BLAST_ZRR",
@@ -424,7 +428,7 @@ char DUSK_CONST* DUSK_CONST daNpc_zrA_c::mEvtCutNameList[11] = {
     "TALK_MULTI",
 };
 
-daNpc_zrA_c::EventFn DUSK_CONST daNpc_zrA_c::mEvtCutList[11] = {
+DUSK_GAME_DATA daNpc_zrA_c::EventFn DUSK_CONST daNpc_zrA_c::mEvtCutList[11] = {
     NULL,
     &daNpc_zrA_c::ECut_talkSwim,
     &daNpc_zrA_c::ECut_beforeBlastzrR,
@@ -686,6 +690,69 @@ int daNpc_zrA_c::Execute() {
     return execute();
 }
 
+#if TARGET_PC
+void daNpc_zrA_interp_callback(void* pUserWork) {
+    daNpc_zrA_c* i_this = static_cast<daNpc_zrA_c*>(pUserWork);
+    if (i_this == NULL || i_this->mAnm_p == NULL || i_this->checkHide()) {
+        return;
+    }
+
+    J3DModel* model = i_this->mAnm_p->getModel();
+    if (model == NULL) {
+        return;
+    }
+
+    J3DModelData* model_data = model->getModelData();
+    model_data->getMaterialNodePointer(1)->setMaterialAnm(i_this->mpMatAnm);
+
+    if (i_this->mTwilight) {
+        g_env_light.settingTevStruct(4, &i_this->current.pos, &i_this->tevStr);
+    } else {
+        g_env_light.settingTevStruct(0, &i_this->current.pos, &i_this->tevStr);
+    }
+    g_env_light.setLightTevColorType_MAJI(model, &i_this->tevStr);
+
+    if (i_this->mWaterAnmFlags & daNpcF_c::ANM_PLAY_BTK) {
+        i_this->mWaterBtkAnm.entry(model_data);
+    }
+    if (i_this->mWaterAnmFlags & daNpcF_c::ANM_PLAY_BPK) {
+        i_this->mWaterBpkAnm.entry(model_data);
+    }
+    if (i_this->mAnmFlags & daNpcF_c::ANM_PLAY_BTP) {
+        i_this->mBtpAnm.entry(model_data);
+    }
+    if (i_this->mAnmFlags & daNpcF_c::ANM_PLAY_BTK) {
+        i_this->mBtkAnm.entry(model_data);
+    }
+    if (i_this->mAnmFlags & daNpcF_c::ANM_PLAY_BRK) {
+        i_this->mBrkAnm.entry(model_data);
+    }
+
+    if (!i_this->mHide && !i_this->mTwilight) {
+        fopAcM_setEffectMtx(i_this, model_data);
+    }
+
+    model->calcMaterial();
+    model->diff();
+
+    if (i_this->mAnmFlags & daNpcF_c::ANM_PLAY_BTP) {
+        i_this->mBtpAnm.remove(model_data);
+    }
+    if (i_this->mAnmFlags & daNpcF_c::ANM_PLAY_BTK) {
+        i_this->mBtkAnm.remove(model_data);
+    }
+    if (i_this->mAnmFlags & daNpcF_c::ANM_PLAY_BRK) {
+        i_this->mBrkAnm.remove(model_data);
+    }
+    if (i_this->mWaterAnmFlags & daNpcF_c::ANM_PLAY_BPK) {
+        i_this->mWaterBpkAnm.remove(model_data);
+    }
+    if (i_this->mWaterAnmFlags & daNpcF_c::ANM_PLAY_BTK) {
+        i_this->mWaterBtkAnm.remove(model_data);
+    }
+}
+#endif
+
 int daNpc_zrA_c::Draw() {
     BOOL bvar2 = false;
     J3DModel* model = mAnm_p->getModel();
@@ -737,6 +804,8 @@ int daNpc_zrA_c::Draw() {
                 mAnm_p->entryDL();
             }
 
+            IF_DUSK(dusk::interp::add_interpolation_callback(&daNpc_zrA_interp_callback, this));
+
             if (mAnmFlags & ANM_PLAY_BTP) {
                 mBtpAnm.remove(model_data);
             }
diff --git a/src/d/actor/d_a_npc_zra.inc b/src/d/actor/d_a_npc_zra.inc
index 2ada4601c8..5cdb380423 100644
--- a/src/d/actor/d_a_npc_zra.inc
+++ b/src/d/actor/d_a_npc_zra.inc
@@ -2609,8 +2609,23 @@ BOOL daNpc_zrA_c::ECut_thanksBlast(int i_staffID) {
         case 31: {
             int item_id = 0;
             if (mFlow.getEventId(&item_id) == 1) {
-                mItemID = fopAcM_createItemForPresentDemo(&current.pos, item_id,
-                                                          0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                const char* itemCheckName = nullptr;
+                u32 itemGiveTag = 0;
+                if (item_id == dItemNo_BOMB_IN_BAG_e) {
+                    itemCheckName = "iza_reward_1";
+                } else if (item_id == dItemNo_BOMB_BAG_LV2_e) {
+                    itemCheckName = "iza_reward_2";
+                }
+                if (itemCheckName != nullptr) {
+                    const auto itemCheck =
+                        dusk::mods::item_check_commit(itemCheckName, item_id, this);
+                    item_id = itemCheck.itemNo;
+                    itemGiveTag = itemCheck.tag;
+                }
+#endif
+                mItemID = fopAcM_createItemForPresentDemo(&current.pos, item_id, 0, -1, -1, NULL,
+                    NULL IF_DUSK_ARG(itemGiveTag));
             }
             field_0x9eb = true;
             break;
diff --git a/src/d/actor/d_a_npc_zrc.cpp b/src/d/actor/d_a_npc_zrc.cpp
index c049091428..f94dbaf087 100644
--- a/src/d/actor/d_a_npc_zrc.cpp
+++ b/src/d/actor/d_a_npc_zrc.cpp
@@ -17,7 +17,7 @@ enum Event_Cut_Nums {
 
 static NPC_ZRC_HIO_CLASS l_HIO;
 
-daNpc_zrC_HIOParam const daNpc_zrC_Param_c::m = {
+DUSK_GAME_DATA daNpc_zrC_HIOParam const daNpc_zrC_Param_c::m = {
     50.0f,    // mAttnOffsetY
     -3.0f,    // mGravity
     1.0f,     // mScale
@@ -171,12 +171,12 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNames[7] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "zrC";
 
-char DUSK_CONST* DUSK_CONST daNpc_zrC_c::mEvtCutNameList[2] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_zrC_c::mEvtCutNameList[2] = {
     "",
     "EARRING_GET",
 };
 
-daNpc_zrC_c::EventFn DUSK_CONST daNpc_zrC_c::mEvtCutList[2] = {
+DUSK_GAME_DATA daNpc_zrC_c::EventFn DUSK_CONST daNpc_zrC_c::mEvtCutList[2] = {
     NULL,
     &daNpc_zrC_c::ECut_earringGet,
 };
@@ -1681,8 +1681,9 @@ BOOL daNpc_zrC_c::ECut_earringGet(int i_staffID) {
         case 40: {
             int item_no = 0;
             if (mFlow.getEventId(&item_no) == 1) {
-                mItemID = fopAcM_createItemForPresentDemo(&current.pos, item_no,
-                                                          0, -1, -1, NULL, NULL);
+                DUSK_ITEM_CHECK("coral_earring", item_no, this);
+                mItemID = fopAcM_createItemForPresentDemo(
+                    &current.pos, item_no, 0, -1, -1, NULL, NULL DUSK_GIVE_TAG("coral_earring"));
             }
             break;
         }
diff --git a/src/d/actor/d_a_npc_zrz.cpp b/src/d/actor/d_a_npc_zrz.cpp
index 2aace19adf..0662a290cd 100644
--- a/src/d/actor/d_a_npc_zrz.cpp
+++ b/src/d/actor/d_a_npc_zrz.cpp
@@ -16,7 +16,7 @@
 
 static NPC_ZRZ_HIO_CLASS l_HIO;
 
-daNpc_zrZ_HIOParam const daNpc_zrZ_Param_c::m = {
+DUSK_GAME_DATA daNpc_zrZ_HIOParam const daNpc_zrZ_Param_c::m = {
     700.0f,   // mAttnOffsetY
     0.0f,     // mGravity
     1.0f,     // mScale
@@ -139,7 +139,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_evtNames[8] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_myName = "zrZ";
 
-char DUSK_CONST* DUSK_CONST daNpc_zrZ_c::mEvtCutNameList[8] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daNpc_zrZ_c::mEvtCutNameList[8] = {
     "",
     "HELP_PRINCE",
     "COME_HERE",
@@ -150,7 +150,7 @@ char DUSK_CONST* DUSK_CONST daNpc_zrZ_c::mEvtCutNameList[8] = {
     "SR_SKIP",
 };
 
-daNpc_zrZ_c::EventFn DUSK_CONST daNpc_zrZ_c::mEvtCutList[8] = {
+DUSK_GAME_DATA daNpc_zrZ_c::EventFn DUSK_CONST daNpc_zrZ_c::mEvtCutList[8] = {
     NULL,
     &daNpc_zrZ_c::ECut_helpPrince,
     &daNpc_zrZ_c::ECut_comeHere,
@@ -1729,8 +1729,9 @@ BOOL daNpc_zrZ_c::ECut_clothesGet(int i_staffID) {
             }
             item_no = 0;
             if (mFlow.getEventId(&item_no) == 1) {
-                mItemID = fopAcM_createItemForPresentDemo(&current.pos, item_no,
-                                                          0, -1, -1, NULL, NULL);
+                DUSK_ITEM_CHECK("zora_armor", item_no, this);
+                mItemID = fopAcM_createItemForPresentDemo(
+                    &current.pos, item_no, 0, -1, -1, NULL, NULL DUSK_GIVE_TAG("zora_armor"));
             }
             break;
 
diff --git a/src/d/actor/d_a_obj_Turara.cpp b/src/d/actor/d_a_obj_Turara.cpp
index 2925712179..767129993c 100644
--- a/src/d/actor/d_a_obj_Turara.cpp
+++ b/src/d/actor/d_a_obj_Turara.cpp
@@ -50,7 +50,7 @@ void daTurara_c::setBaseMtx() {
 
 static daTurara_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daTurara_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daTurara_c::mCcDObjInfo = {
     {0, // mFlags
         {
             {0x20, 0x1, 0x1f},  // mObjAt
@@ -63,7 +63,7 @@ const dCcD_SrcGObjInf daTurara_c::mCcDObjInfo = {
     {0} // mGObjCo
 };
 
-dCcD_SrcCyl daTurara_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daTurara_c::mCcDCyl = {
     daTurara_c::mCcDObjInfo, // mObjInf
     {
         {
diff --git a/src/d/actor/d_a_obj_TvCdlst.cpp b/src/d/actor/d_a_obj_TvCdlst.cpp
index 2b734d2aab..1b7cbb44db 100644
--- a/src/d/actor/d_a_obj_TvCdlst.cpp
+++ b/src/d/actor/d_a_obj_TvCdlst.cpp
@@ -10,7 +10,7 @@
 
 static daTvCdlst_HIO_c l_HIO;
 
-dCcD_SrcCyl daTvCdlst_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daTvCdlst_c::mCcDCyl = {
     daTvCdlst_c::mCcDObjInfo, // mObjInf
     {
         {
@@ -42,7 +42,7 @@ int daTvCdlst_c::CreateHeap() {
     return 1;
 }
 
-const dCcD_SrcGObjInf daTvCdlst_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daTvCdlst_c::mCcDObjInfo = {
     {0, // mFlags
         {
             {0x0, 0x0, 0x0},  // mObjAt
diff --git a/src/d/actor/d_a_obj_amiShutter.cpp b/src/d/actor/d_a_obj_amiShutter.cpp
index 13004d68e3..8d193c8811 100644
--- a/src/d/actor/d_a_obj_amiShutter.cpp
+++ b/src/d/actor/d_a_obj_amiShutter.cpp
@@ -284,7 +284,7 @@ int daAmiShutter_Create(fopAc_ac_c* i_this) {
     return static_cast<daAmiShutter_c*>(i_this)->create();
 }
 
-actor_method_class l_daAmiShutter_Method = {
+DUSK_GAME_DATA actor_method_class l_daAmiShutter_Method = {
     (process_method_func)daAmiShutter_Create,
     (process_method_func)daAmiShutter_Delete,
     (process_method_func)daAmiShutter_Execute,
diff --git a/src/d/actor/d_a_obj_automata.cpp b/src/d/actor/d_a_obj_automata.cpp
index a0ee360518..3d6b5d804e 100644
--- a/src/d/actor/d_a_obj_automata.cpp
+++ b/src/d/actor/d_a_obj_automata.cpp
@@ -19,7 +19,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNameList[2] = {
     "AutoMata",
 };
 
-daObj_AutoMata_HIOParam const daObj_AutoMata_Param_c::m = {
+DUSK_GAME_DATA daObj_AutoMata_HIOParam const daObj_AutoMata_Param_c::m = {
     220.0f, 80.0f, 40.0f,
 };
 
diff --git a/src/d/actor/d_a_obj_barDesk.cpp b/src/d/actor/d_a_obj_barDesk.cpp
index 768c233c61..a333cb1a3d 100644
--- a/src/d/actor/d_a_obj_barDesk.cpp
+++ b/src/d/actor/d_a_obj_barDesk.cpp
@@ -12,14 +12,14 @@
 
 static daBarDesk_HIO_c l_HIO;
 
-dCcD_SrcGObjInf const daBarDesk_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daBarDesk_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0xD8FAFDBF, 0x11}, {0}}},
     {1, 0, 0, 0, 0},
     {0xA, 0, 0, 0, 6},
     {0}
 };
 
-dCcD_SrcCyl daBarDesk_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daBarDesk_c::mCcDCyl = {
     mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f}
diff --git a/src/d/actor/d_a_obj_bed.cpp b/src/d/actor/d_a_obj_bed.cpp
index a2b017082a..e4d11f5b29 100644
--- a/src/d/actor/d_a_obj_bed.cpp
+++ b/src/d/actor/d_a_obj_bed.cpp
@@ -30,7 +30,7 @@ void daObj_Bed_HIO_c::genMessage(JORMContext* ctx) {
 }
 #endif
 
-daObj_Bed_HIOParam const daObj_Bed_Param_c::m = {0, -3.0f, 1.0f, 600.0f};
+DUSK_GAME_DATA daObj_Bed_HIOParam const daObj_Bed_Param_c::m = {0, -3.0f, 1.0f, 600.0f};
 
 daObj_Bed_c::~daObj_Bed_c() {
     if (mpCollider != NULL) {
diff --git a/src/d/actor/d_a_obj_bemos.cpp b/src/d/actor/d_a_obj_bemos.cpp
index a232df06ec..2603294ed0 100644
--- a/src/d/actor/d_a_obj_bemos.cpp
+++ b/src/d/actor/d_a_obj_bemos.cpp
@@ -52,7 +52,7 @@ static Vec const l_craw_offset[4] = {
     {0.0f, 0.0f, 95.0f},
 };
 
-s16 const daObjBm_c::M_dir_base[4] = {
+DUSK_GAME_DATA s16 const daObjBm_c::M_dir_base[4] = {
     0x0000,
     0x4000,
     -0x8000,
@@ -1037,12 +1037,12 @@ void daObjBm_c::mode_wait() {
     }
 }
 
-const daObjBm_c::BgcSrc_c daObjBm_c::Bgc_c::M_lin5[] = {
+DUSK_GAME_DATA const daObjBm_c::BgcSrc_c daObjBm_c::Bgc_c::M_lin5[] = {
     {0.0f, 0.0f, 0.0f, 0.0f}, {-0.5f, -0.5f, -1.0f, -1.0f}, {0.5f, -0.5f, 1.0f, -1.0f},
     {0.5f, 0.5f, 1.0f, 1.0f}, {-0.5f, 0.5f, -1.0f, 1.0f},
 };
 
-const daObjBm_c::BgcSrc_c daObjBm_c::Bgc_c::M_lin20[] = {
+DUSK_GAME_DATA const daObjBm_c::BgcSrc_c daObjBm_c::Bgc_c::M_lin20[] = {
     {0.0f, 0.0f, 0.0f, 0.0f},    {-0.25f, -0.25f, 0.0f, 0.0f}, {-0.5f, -0.5f, -1.0f, -1.0f},
     {0.0f, -0.5f, 1.0f, -1.0f},  {0.0f, 0.0f, 1.0f, 1.0f},     {-0.5f, 0.0f, -1.0f, 1.0f},
     {0.25f, -0.25f, 0.0f, 0.0f}, {0.0f, -0.5f, -1.0f, -1.0f},  {0.5f, -0.5f, 1.0f, -1.0f},
@@ -1148,11 +1148,11 @@ static f32 dummy_rodata_5157() {
     return -G_CM3D_F_INF;
 }
 
-dBgS_ObjGndChk daObjBm_c::Bgc_c::M_gnd_work[23];
+DUSK_GAME_DATA dBgS_ObjGndChk daObjBm_c::Bgc_c::M_gnd_work[23];
 
-dBgS_WtrChk daObjBm_c::Bgc_c::M_wrt_work;
+DUSK_GAME_DATA dBgS_WtrChk daObjBm_c::Bgc_c::M_wrt_work;
 
-dBgS_ObjLinChk daObjBm_c::Bgc_c::M_wall_work[23];
+DUSK_GAME_DATA dBgS_ObjLinChk daObjBm_c::Bgc_c::M_wall_work[23];
 
 void daObjBm_c::Bgc_c::chk_wall_touch(const fopAc_ac_c*, const daObjBm_c::BgcSrc_c*, short) {
     static dBgS_ObjLinChk touch_work;
diff --git a/src/d/actor/d_a_obj_bky_rock.cpp b/src/d/actor/d_a_obj_bky_rock.cpp
index 08ba68267f..d88e99c24c 100644
--- a/src/d/actor/d_a_obj_bky_rock.cpp
+++ b/src/d/actor/d_a_obj_bky_rock.cpp
@@ -18,7 +18,7 @@ static int daBkyRock_c_createHeap(fopAc_ac_c* i_this) {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_arcName = "BYRock";
 
-daBkyRock_c::exeProc daBkyRock_c::s_exeProc[3] = {
+DUSK_GAME_DATA daBkyRock_c::exeProc daBkyRock_c::s_exeProc[3] = {
     &daBkyRock_c::exeModeNoDamage,
     &daBkyRock_c::exeModeDamage,
     &daBkyRock_c::exeModePiece,
@@ -124,7 +124,7 @@ static u16 const SECOND_PARTICLE_NAME[6] = {
     0x89C2, 0x89C3, 0x89C4, 0x89C5, 0x89C6, 0x89C7,
 };
 
-dCcD_SrcCyl const daBkyRock_c::s_CcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl const daBkyRock_c::s_CcDCyl = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0x20a0, 0x11}, 0x0}}, // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
diff --git a/src/d/actor/d_a_obj_bmWindow.cpp b/src/d/actor/d_a_obj_bmWindow.cpp
index b6a09b53dd..6148004948 100644
--- a/src/d/actor/d_a_obj_bmWindow.cpp
+++ b/src/d/actor/d_a_obj_bmWindow.cpp
@@ -45,7 +45,7 @@ int daBmWindow_c::CreateHeap() {
     return mModel != NULL ? 1 : 0;
 }
 
-dCcD_SrcGObjInf const daBmWindow_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daBmWindow_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0xd8fafdbf, 0x11}, {0}}},
     {1, 0, 0, 0, 0},
     {0xa, 0, 0, 0, 0xa6},
@@ -122,7 +122,7 @@ int daBmWindow_c::Execute(Mtx** param_1) {
 
 static daBmWindow_HIO_c l_HIO;
 
-dCcD_SrcCyl daBmWindow_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daBmWindow_c::mCcDCyl = {
     daBmWindow_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_bosswarp.cpp b/src/d/actor/d_a_obj_bosswarp.cpp
index e286ce1640..5bf510d04a 100644
--- a/src/d/actor/d_a_obj_bosswarp.cpp
+++ b/src/d/actor/d_a_obj_bosswarp.cpp
@@ -14,6 +14,11 @@
 #include "d/actor/d_a_obj_ystone.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/mods/item.hpp"
+#include "mods/items.h"
+#endif
+
 static DUSK_CONST char* l_arcName = "ef_Portal";
 
 static char const* l_clearEvName[9] = {
@@ -77,6 +82,27 @@ static int getNowLevel() {
     return -1;
 }
 
+#if TARGET_PC
+static const char* dungeon_reward_check_name(int level) {
+    switch (level) {
+    case 0:
+        return ITEM_CHECK_DUNGEON_REWARD_FOREST;
+    case 1:
+        return ITEM_CHECK_DUNGEON_REWARD_GORON;
+    case 2:
+        return ITEM_CHECK_DUNGEON_REWARD_LAKEBED;
+    case 4:
+        return ITEM_CHECK_DUNGEON_REWARD_SNOWPEAK;
+    case 5:
+        return ITEM_CHECK_DUNGEON_REWARD_TIME;
+    case 6:
+        return ITEM_CHECK_DUNGEON_REWARD_CITY;
+    default:
+        return nullptr;
+    }
+}
+#endif
+
 void daObjBossWarp_c::initBaseMtx() {
     scale.y = 0.15f;
     mpModel->setBaseScale(scale);
@@ -485,6 +511,9 @@ int daObjBossWarp_c::demoProc() {
             player->onSceneChangeArea(scene, 0xff, 0);
             break;
         case 4:  // STONE_FALL
+#if TARGET_PC
+        {
+#endif
             if (ystone != NULL) {
                 mYstonePos = ystone->current.pos;
                 if (getNowLevel() < 3) {
@@ -506,28 +535,52 @@ int daObjBossWarp_c::demoProc() {
             mDoMtx_stack_c::multVec(&mYstoneTargetPos, &mYstoneTargetPos);
             mYstonePos.x = mYstoneTargetPos.x;
             mYstonePos.z = mYstoneTargetPos.z;
-            switch (getNowLevel()) {
-            case 0:
-                dComIfGs_onCollectCrystal(0);
-                break;
-            case 1:
-                dComIfGs_onCollectCrystal(1);
-                break;
-            case 2:
-                dComIfGs_onCollectCrystal(2);
-                break;
-            case 4:
-                dComIfGs_onCollectMirror(1);
-                break;
-            case 5:
-                dComIfGs_onCollectMirror(2);
-                break;
-            case 6:
-                dComIfGs_onCollectMirror(3);
-                break;
+#if TARGET_PC
+            int level = getNowLevel();
+            const char* checkName = dungeon_reward_check_name(level);
+            dusk::mods::ItemCheckResult itemCheck{};
+            bool applyVanillaReward = true;
+            if (checkName != nullptr) {
+                itemCheck = dusk::mods::item_check_commit(checkName, dItemNo_NONE_e, this);
+                applyVanillaReward = itemCheck.itemNo == dItemNo_NONE_e;
             }
+            if (applyVanillaReward) {
+                switch (level) {
+#else
+            switch (getNowLevel()) {
+#endif
+                case 0:
+                    dComIfGs_onCollectCrystal(0);
+                    break;
+                case 1:
+                    dComIfGs_onCollectCrystal(1);
+                    break;
+                case 2:
+                    dComIfGs_onCollectCrystal(2);
+                    break;
+                case 4:
+                    dComIfGs_onCollectMirror(1);
+                    break;
+                case 5:
+                    dComIfGs_onCollectMirror(2);
+                    break;
+                case 6:
+                    dComIfGs_onCollectMirror(3);
+                    break;
+                }
+#if TARGET_PC
+                if (checkName != nullptr) {
+                    dusk::mods::item_check_complete(itemCheck, this);
+                }
+            } else {
+                dusk::mods::item_check_enqueue(itemCheck, dusk::mods::ItemGiveMode::Silent);
+            }
+#endif
             mCounter = 0;
             break;
+#if TARGET_PC
+        }
+#endif
         case 5:  // STONE_MIDNA
             mCounter = 0;
             break;
diff --git a/src/d/actor/d_a_obj_boumato.cpp b/src/d/actor/d_a_obj_boumato.cpp
index df3bc442b3..173b23fea6 100644
--- a/src/d/actor/d_a_obj_boumato.cpp
+++ b/src/d/actor/d_a_obj_boumato.cpp
@@ -14,7 +14,7 @@
 
 static const char* dummyString() { return ""; }
 
-daObj_BouMato_HIOParam const daObj_BouMato_Param_c::m = {
+DUSK_GAME_DATA daObj_BouMato_HIOParam const daObj_BouMato_Param_c::m = {
     0.0f, -3.0f, 1.0f, 400.0f, 300.0f, 4.0f, 20.0f,
 };
 
diff --git a/src/d/actor/d_a_obj_brakeeff.cpp b/src/d/actor/d_a_obj_brakeeff.cpp
index 504c91dfa3..ae3032119c 100644
--- a/src/d/actor/d_a_obj_brakeeff.cpp
+++ b/src/d/actor/d_a_obj_brakeeff.cpp
@@ -28,7 +28,7 @@ int daObj_Brakeeff_Draw(obj_brakeeff_class* i_this) {
 }
 
 // Particle IDS
-u16 e_name[5] = {0x00, 0x00, 0x00, 0x00, 0x00};
+DUSK_GAME_DATA u16 e_name[5] = {0x00, 0x00, 0x00, 0x00, 0x00};
 
 void obj_brakeeff_1(obj_brakeeff_class* i_this) {
     fopAc_ac_c* a_this = static_cast<fopAc_ac_c*>(i_this);
@@ -130,13 +130,13 @@ int daObj_Brakeeff_Delete(obj_brakeeff_class* i_this) {
 }
 
 // model data per effect type
-u32 bef_bmd[2] = {
+DUSK_GAME_DATA u32 bef_bmd[2] = {
     5,
     6,
 };
 
 // J3DAnmTevRegKey per effect type
-u32 bef_brk[2] = {
+DUSK_GAME_DATA u32 bef_brk[2] = {
     9,
     10,
 };
@@ -229,7 +229,7 @@ int daObj_Brakeeff_Create(fopAc_ac_c* a_this) {
     return res_load_result;
 }
 
-actor_method_class l_daObj_Brakeeff_Method = {
+DUSK_GAME_DATA actor_method_class l_daObj_Brakeeff_Method = {
     (process_method_func)daObj_Brakeeff_Create,  (process_method_func)daObj_Brakeeff_Delete,
     (process_method_func)daObj_Brakeeff_Execute, (process_method_func)daObj_Brakeeff_IsDelete,
     (process_method_func)daObj_Brakeeff_Draw,
diff --git a/src/d/actor/d_a_obj_bubblePilar.cpp b/src/d/actor/d_a_obj_bubblePilar.cpp
index 11e42355f2..c1393b919e 100644
--- a/src/d/actor/d_a_obj_bubblePilar.cpp
+++ b/src/d/actor/d_a_obj_bubblePilar.cpp
@@ -11,14 +11,14 @@
 
 static daBubbPilar_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daBubbPilar_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daBubbPilar_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0x20, 0x11}, {0}}},
     {dCcD_SE_NONE, 0, 1, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 2},
     {0},
 };
 
-dCcD_SrcCyl daBubbPilar_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daBubbPilar_c::mCcDCyl = {
     daBubbPilar_c::mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f}
diff --git a/src/d/actor/d_a_obj_burnbox.cpp b/src/d/actor/d_a_obj_burnbox.cpp
index 3d379cebe5..36fa21275e 100644
--- a/src/d/actor/d_a_obj_burnbox.cpp
+++ b/src/d/actor/d_a_obj_burnbox.cpp
@@ -186,7 +186,7 @@ int daObjBurnBox_MoveBGDraw(daObjBurnBox_c* i_this) {
     return i_this->MoveBGDraw();
 }
 
-actor_method_class daObjBurnBox_METHODS = {
+DUSK_GAME_DATA actor_method_class daObjBurnBox_METHODS = {
     (process_method_func) daObjBurnBox_create1st,     (process_method_func)daObjBurnBox_MoveBGDelete,
     (process_method_func) daObjBurnBox_MoveBGExecute, NULL,
     (process_method_func) daObjBurnBox_MoveBGDraw,
diff --git a/src/d/actor/d_a_obj_carry.cpp b/src/d/actor/d_a_obj_carry.cpp
index f27ec717e9..d00b06b10a 100644
--- a/src/d/actor/d_a_obj_carry.cpp
+++ b/src/d/actor/d_a_obj_carry.cpp
@@ -39,7 +39,7 @@ static const cM3dGCylS l_cyl_info[] = {
     { 0.0f, 0.0f, 0.0f, 50.0f, 100.0f },
 };
 
-const daObjCarry_dt_t daObjCarry_c::mData[] = {
+DUSK_GAME_DATA const daObjCarry_dt_t daObjCarry_c::mData[] = {
     // TYPE_TSUBO
     {
         27.0f,
diff --git a/src/d/actor/d_a_obj_catdoor.cpp b/src/d/actor/d_a_obj_catdoor.cpp
index 4ca78ce4d0..21f4ed2bc9 100644
--- a/src/d/actor/d_a_obj_catdoor.cpp
+++ b/src/d/actor/d_a_obj_catdoor.cpp
@@ -10,7 +10,7 @@
 
 static const char* l_arcName = "CatDoor";
 
-const daObjCatDoor_Attr_c daObjCatDoor_c::M_attr = {
+DUSK_GAME_DATA const daObjCatDoor_Attr_c daObjCatDoor_c::M_attr = {
     30,
     1400,
 };
diff --git a/src/d/actor/d_a_obj_chandelier.cpp b/src/d/actor/d_a_obj_chandelier.cpp
index 900edd75ca..27d1f7f7eb 100644
--- a/src/d/actor/d_a_obj_chandelier.cpp
+++ b/src/d/actor/d_a_obj_chandelier.cpp
@@ -12,7 +12,7 @@
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_arcName = "L9Chand";
 
-daObjChandelier_proc daObjChandelier_c::s_exeProc[5] = {
+DUSK_GAME_DATA daObjChandelier_proc daObjChandelier_c::s_exeProc[5] = {
     &daObjChandelier_c::exeModeWait,
     &daObjChandelier_c::exeModeStartSwg,
     &daObjChandelier_c::exeModeDown,
diff --git a/src/d/actor/d_a_obj_fchain.cpp b/src/d/actor/d_a_obj_fchain.cpp
index b4d473c424..cf2470fc17 100644
--- a/src/d/actor/d_a_obj_fchain.cpp
+++ b/src/d/actor/d_a_obj_fchain.cpp
@@ -10,10 +10,15 @@
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
 #include "SSystem/SComponent/c_math.h"
 #include "d/d_com_inf_game.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/interp/dual_buffer.h"
+
+static const int CHAIN_COUNT = 22;
+typedef dusk::interp::DualBuffer<cXyz, CHAIN_COUNT> ChainInterp;
+#endif
+
 static char const l_arcName[] = "Fchain";
 
 int daObjFchain_c::createHeap() {
@@ -67,10 +72,6 @@ int daObjFchain_c::create() {
             local_48++;
         }
         rv = cPhs_COMPLEATE_e;
-#if TARGET_PC
-        mChainInterpPrevValid = false;
-        mChainInterpCurrValid = false;
-#endif
         break;
     }
     return rv;
@@ -295,26 +296,6 @@ void daObjFchain_shape_c::draw() {
     }
 }
 
-#if TARGET_PC
-static void fchain_interp_callback(bool isSimFrame, void* pUserWork) {
-    static_cast<daObjFchain_c*>(pUserWork)->onInterpCallback();
-}
-
-void daObjFchain_c::onInterpCallback() {
-    if (!mChainInterpPrevValid || !mChainInterpCurrValid) {
-        return;
-    }
-
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-
-    for (int i = 0; i < CHAIN_COUNT; i++) {
-        const cXyz& p0 = mChainInterpPrev[i];
-        const cXyz& p1 = mChainInterpCurr[i];
-        field_0x694[i] = p0 + (p1 - p0) * alpha;
-    }
-}
-#endif
-
 int daObjFchain_c::draw() {
     if (field_0x584 != 0) {
         g_env_light.settingTevStruct(0, &current.pos, &tevStr);
@@ -324,18 +305,7 @@ int daObjFchain_c::draw() {
         }
         dComIfGd_getOpaListDark()->entryImm(&mShape, 0);
 
-#if TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
-            if (mChainInterpCurrValid) {
-                memcpy(mChainInterpPrev, mChainInterpCurr, sizeof(mChainInterpCurr));
-                mChainInterpPrevValid = true;
-            }
-
-            memcpy(mChainInterpCurr, field_0x694, sizeof(mChainInterpCurr));
-            mChainInterpCurrValid = true;
-            dusk::frame_interp::add_interpolation_callback(&fchain_interp_callback, this);
-        }
-#endif
+        IF_DUSK(dusk::interp::get<ChainInterp>(this).writeback(field_0x694, CHAIN_COUNT));
     }
     return 1;
 }
diff --git a/src/d/actor/d_a_obj_fireWood.cpp b/src/d/actor/d_a_obj_fireWood.cpp
index 621a15f7a3..b73a526b40 100644
--- a/src/d/actor/d_a_obj_fireWood.cpp
+++ b/src/d/actor/d_a_obj_fireWood.cpp
@@ -21,7 +21,7 @@ void daFireWood_c::setBaseMtx() {
 
 static daFireWood_HIO_c l_HIO;
 
-dCcD_SrcCyl daFireWood_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daFireWood_c::mCcDCyl = {
     daFireWood_c::mCcDObjInfo,
     {
         {
@@ -32,7 +32,7 @@ dCcD_SrcCyl daFireWood_c::mCcDCyl = {
     }
 };
 
-const dCcD_SrcGObjInf daFireWood_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daFireWood_c::mCcDObjInfo = {
     {0, {{AT_TYPE_LANTERN_SWING, 0, 0x13}, {0xD8FBFFFF, 0x1F}, {0x0}}},
     {dCcD_SE_SWORD, 0, 0, dCcD_MTRL_NONE, 0},
     {dCcD_SE_STONE, 0, 0, dCcD_MTRL_NONE, 0},
diff --git a/src/d/actor/d_a_obj_fireWood2.cpp b/src/d/actor/d_a_obj_fireWood2.cpp
index d20ab61f5e..69ee25f6d1 100644
--- a/src/d/actor/d_a_obj_fireWood2.cpp
+++ b/src/d/actor/d_a_obj_fireWood2.cpp
@@ -21,14 +21,14 @@ void daFireWood2_c::setBaseMtx() {
 
 static daFireWood2_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daFireWood2_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daFireWood2_c::mCcDObjInfo = {
     {0, {{AT_TYPE_LANTERN_SWING, 0, 0x13}, {0xD8FBFFFF, 0x1F}, {0x79}}},
     {dCcD_SE_SWORD, 0, 0, dCcD_MTRL_NONE, 0},
     {dCcD_SE_STONE, 0, 0, dCcD_MTRL_NONE, 0},
     {0},
 };
 
-dCcD_SrcCyl daFireWood2_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daFireWood2_c::mCcDCyl = {
     daFireWood2_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_flag.cpp b/src/d/actor/d_a_obj_flag.cpp
index b474b05893..5edd11ff88 100644
--- a/src/d/actor/d_a_obj_flag.cpp
+++ b/src/d/actor/d_a_obj_flag.cpp
@@ -7,7 +7,7 @@
 
 #include "d/actor/d_a_obj_flag.h"
 
-daObjFlag_c::M_attrs const daObjFlag_c::M_attr = {
+DUSK_GAME_DATA daObjFlag_c::M_attrs const daObjFlag_c::M_attr = {
     4000.0f, 1.0f, 0.3f, 
     15, 2000, 1500, 4000, 
     1800, 0, 0, 1000, 400, 
diff --git a/src/d/actor/d_a_obj_flag2.cpp b/src/d/actor/d_a_obj_flag2.cpp
index a11287480f..20fa2021e9 100644
--- a/src/d/actor/d_a_obj_flag2.cpp
+++ b/src/d/actor/d_a_obj_flag2.cpp
@@ -51,7 +51,7 @@ public:
 daObjFlag2_Hio_c M_hio;
 #endif
 
-daObjFlag2_Attr_c const daObjFlag2_c::M_attr = {
+DUSK_GAME_DATA daObjFlag2_Attr_c const daObjFlag2_c::M_attr = {
     -2.0f, 0.74f, 0.68f, 40.0f, 100.0f,
 };
 
@@ -101,7 +101,7 @@ static f32 l_texCoord[42] = {
     0.8f, 0.9f, 1.0,  0.0,  1.0,  0.2f, 1.0,  0.4f, 1.0,  0.6f, 1.0,  0.8f, 1.0,  1.0,
 };
 
-static u8 l_pennant_flagDL[152] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_pennant_flagDL[152] = {
     0x98, 0x00, 0x0B, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x04, 0x04, 0x04, 0x05,
     0x05, 0x05, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0D, 0x0D, 0x0D, 0x0E, 0x0E, 0x0E, 0x13, 0x13,
     0x13, 0x14, 0x14, 0x14, 0x98, 0x00, 0x09, 0x01, 0x01, 0x01, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04,
diff --git a/src/d/actor/d_a_obj_flag3.cpp b/src/d/actor/d_a_obj_flag3.cpp
index 094223ddfa..d053c045b9 100644
--- a/src/d/actor/d_a_obj_flag3.cpp
+++ b/src/d/actor/d_a_obj_flag3.cpp
@@ -49,7 +49,7 @@ public:
 daObjFlag3_Hio_c M_hio;
 #endif
 
-daObjFlag3_Attr_c const daObjFlag3_c::M_attr = {
+DUSK_GAME_DATA daObjFlag3_Attr_c const daObjFlag3_c::M_attr = {
     -2.0f, 0.6f, 0.68f, 40.0f, 100.0f,
 };
 
diff --git a/src/d/actor/d_a_obj_gadget.cpp b/src/d/actor/d_a_obj_gadget.cpp
index 0f7927a243..cd401c9654 100644
--- a/src/d/actor/d_a_obj_gadget.cpp
+++ b/src/d/actor/d_a_obj_gadget.cpp
@@ -35,7 +35,7 @@ public:
 #endif
 
 
-daObj_Gadget_HIOParam const daObj_Gadget_Param_c::m = {
+DUSK_GAME_DATA daObj_Gadget_HIOParam const daObj_Gadget_Param_c::m = {
     0.0f, -4.0f, 1.0f, 100.0f, 37.0f, 26.0f, 13.0f, 14.0f,
      37.0f, 50.0f, 18.0f,
 };
diff --git a/src/d/actor/d_a_obj_glowSphere.cpp b/src/d/actor/d_a_obj_glowSphere.cpp
index 77b0ae9e69..4f668fd53d 100644
--- a/src/d/actor/d_a_obj_glowSphere.cpp
+++ b/src/d/actor/d_a_obj_glowSphere.cpp
@@ -22,14 +22,14 @@ static DUSK_CONSTEXPR cull_box l_cull_box = {
     {30.0f, 60.0f, 30.0f}
 };
 
-const dCcD_SrcGObjInf daGlwSph_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daGlwSph_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0x10000, 0x11}, {0x19}}},
     {dCcD_SE_SWORD, 0, 0, 0, 0x0},
     {dCcD_SE_STONE, 0, 0, 0, 0x2},
     {0},
 };
 
-dCcD_SrcSph daGlwSph_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daGlwSph_c::mCcDSph = {
     daGlwSph_c::mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
@@ -45,7 +45,7 @@ static GXColor l_envColor[] = {
     /* Blue   */ {0x00, 0x32, 0xFF, 0xFF},
 };
 
-_GlSph_Mng_c daGlwSph_c::mSphMng;
+DUSK_GAME_DATA _GlSph_Mng_c daGlwSph_c::mSphMng;
 
 _GlSph_Mng_c& daGlwSph_c::getSphMng() {
     return mSphMng;
@@ -415,9 +415,9 @@ BOOL _GlSph_Mng_c::_chkAllGet_main() {
     return TRUE;
 }
 
-u16 _GlSph_Mng_c::mSphSe;
+DUSK_GAME_DATA u16 _GlSph_Mng_c::mSphSe;
 
-s16 _GlSph_Mng_c::mSeClrTmr;
+DUSK_GAME_DATA s16 _GlSph_Mng_c::mSeClrTmr;
 
 void _GlSph_Mng_c::SphSeProc() {
     if (mSeClrTmr > 0) {
diff --git a/src/d/actor/d_a_obj_gpTaru.cpp b/src/d/actor/d_a_obj_gpTaru.cpp
index e0668984c2..08185aebbe 100644
--- a/src/d/actor/d_a_obj_gpTaru.cpp
+++ b/src/d/actor/d_a_obj_gpTaru.cpp
@@ -59,7 +59,7 @@ int daGpTaru_c::CreateHeap() {
     return 1;
 }
 
-dCcD_SrcCyl daGpTaru_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daGpTaru_c::mCcDCyl = {
     daGpTaru_c::mCcDObjInfo,
     {
         {
@@ -70,7 +70,7 @@ dCcD_SrcCyl daGpTaru_c::mCcDCyl = {
     }  // mCylAttr
 };
 
-const dCcD_SrcGObjInf daGpTaru_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daGpTaru_c::mCcDObjInfo = {
     {0, {{0, 0, 0x1F}, {0xD8FAFDBF, 0x11}, {0x79}}},
     {dCcD_SE_NONE, 0, 1, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 2},
diff --git a/src/d/actor/d_a_obj_gra2.cpp b/src/d/actor/d_a_obj_gra2.cpp
index c8ad09dda2..97036418fc 100644
--- a/src/d/actor/d_a_obj_gra2.cpp
+++ b/src/d/actor/d_a_obj_gra2.cpp
@@ -5,14 +5,13 @@
 
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
-#include "d/actor/d_a_npc4.h"
 #include "d/actor/d_a_obj_gra2.h"
+#include "d/actor/d_a_npc4.h"
 #include "d/actor/d_a_tag_gra.h"
 #include "d/d_bg_w.h"
 #include "d/d_cc_uty.h"
-#include "d/d_com_inf_actor.h"
 #include "d/d_com_inf_game.h"
-#include "dusk/string.hpp"
+#include "d/d_com_inf_actor.h"
 #if DEBUG
 #include "d/d_debug_viewer.h"
 #endif
@@ -21,11 +20,15 @@
 #include "Z2AudioLib/Z2Instances.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
+
 class daObj_GrA_Param_c {
 public:
     virtual ~daObj_GrA_Param_c() {}
 
-    static const daObj_GrA_HIO_Param_c m;
+    static DUSK_GAME_DATA const daObj_GrA_HIO_Param_c m;
 };
 
 #if DEBUG
@@ -308,7 +311,7 @@ cPhs_Step daObj_GrA_c::create() {
     return phase;
 }
 
-daObj_GrA_HIO_Param_c const daObj_GrA_Param_c::m = {
+DUSK_GAME_DATA daObj_GrA_HIO_Param_c const daObj_GrA_Param_c::m = {
     85.0f,
     -4.0f,
     1.0f,
@@ -2083,7 +2086,7 @@ static int daObj_GrA_IsDelete(void* i_this) {
 
 AUDIO_INSTANCES;
 
-daObj_GrA_c::MotionFunc daObj_GrA_c::mBaseMotionList[22] = {
+DUSK_GAME_DATA daObj_GrA_c::MotionFunc daObj_GrA_c::mBaseMotionList[22] = {
     &daObj_GrA_c::base000,
     &daObj_GrA_c::base001,
     &daObj_GrA_c::base003,
@@ -2108,7 +2111,7 @@ daObj_GrA_c::MotionFunc daObj_GrA_c::mBaseMotionList[22] = {
     &daObj_GrA_c::base026,
 };
 
-daObj_GrA_c::MotionFunc daObj_GrA_c::mFaceMotionList[14] = {
+DUSK_GAME_DATA daObj_GrA_c::MotionFunc daObj_GrA_c::mFaceMotionList[14] = {
     &daObj_GrA_c::face000,
     &daObj_GrA_c::face003,
     &daObj_GrA_c::face004,
diff --git a/src/d/actor/d_a_obj_gra_rock.cpp b/src/d/actor/d_a_obj_gra_rock.cpp
index a2cfb0ad17..045d2fcc0e 100644
--- a/src/d/actor/d_a_obj_gra_rock.cpp
+++ b/src/d/actor/d_a_obj_gra_rock.cpp
@@ -16,7 +16,7 @@ static void dummy() {
     cLib_calcTimer<s16>(0);
 }
 
-dCcD_SrcCyl const daObjGraRock_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl const daObjGraRock_c::mCcDCyl = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0x2020, 0x11}, 0x0}}, // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
diff --git a/src/d/actor/d_a_obj_grave_stone.cpp b/src/d/actor/d_a_obj_grave_stone.cpp
index 3e2daf2d30..7902e5361b 100644
--- a/src/d/actor/d_a_obj_grave_stone.cpp
+++ b/src/d/actor/d_a_obj_grave_stone.cpp
@@ -12,14 +12,14 @@
 
 static char const* l_arcName = "H_Haka";
 
-dCcD_SrcGObjInf const daGraveStone_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daGraveStone_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0, 0}, {0x79}}},
     {0, 0, 0, 0, 0},
     {0, 0, 0, 0, 0},
     {0},
 };
 
-dCcD_SrcCyl const daGraveStone_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl const daGraveStone_c::mCcDCyl = {
     {
         {0, {{0, 0, 0}, {0, 0}, {0x79}}},
         {0, 0, 0, 0, 0},
diff --git a/src/d/actor/d_a_obj_hakai_brl.cpp b/src/d/actor/d_a_obj_hakai_brl.cpp
index 618c4adb95..c4ac094354 100644
--- a/src/d/actor/d_a_obj_hakai_brl.cpp
+++ b/src/d/actor/d_a_obj_hakai_brl.cpp
@@ -82,7 +82,7 @@ int daObjHBarrel_c::execute() {
     return 1;
 }
 
-dCcD_SrcCyl const daObjHBarrel_c::s_CcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl const daObjHBarrel_c::s_CcDCyl = {
     {
         {0x0, {{0x0, 0x0, 0xd}, {0xd8fafdff, 0x11}, 0x79}},  // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0},                  // mGObjAt
diff --git a/src/d/actor/d_a_obj_hakai_ftr.cpp b/src/d/actor/d_a_obj_hakai_ftr.cpp
index c0efb5af88..0f03a00934 100644
--- a/src/d/actor/d_a_obj_hakai_ftr.cpp
+++ b/src/d/actor/d_a_obj_hakai_ftr.cpp
@@ -99,7 +99,7 @@ int daObjHFtr_c::draw() {
     return 1;
 }
 
-dCcD_SrcCyl const daObjHFtr_c::s_CcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl const daObjHFtr_c::s_CcDCyl = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0x400020, 0x11}, 0x0}},  // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0},               // mGObjAt
diff --git a/src/d/actor/d_a_obj_hasu2.cpp b/src/d/actor/d_a_obj_hasu2.cpp
index 3ca19f9727..f10f5a7dab 100644
--- a/src/d/actor/d_a_obj_hasu2.cpp
+++ b/src/d/actor/d_a_obj_hasu2.cpp
@@ -176,7 +176,7 @@ static int daObjMHasu_MoveBGDraw(nObjMHasu::daObjMHasu_c* i_this) {
     return i_this->MoveBGDraw();
 }
 
-actor_method_class daObjMHasu_METHODS = {
+DUSK_GAME_DATA actor_method_class daObjMHasu_METHODS = {
     (process_method_func)&daObjMHasu_create1st,
     (process_method_func)&daObjMHasu_MoveBGDelete,
     (process_method_func)&daObjMHasu_MoveBGExecute,
diff --git a/src/d/actor/d_a_obj_itamato.cpp b/src/d/actor/d_a_obj_itamato.cpp
index 5fdce10cf5..dd795e362b 100644
--- a/src/d/actor/d_a_obj_itamato.cpp
+++ b/src/d/actor/d_a_obj_itamato.cpp
@@ -11,7 +11,7 @@
 #include "JSystem/JHostIO/JORFile.h"
 #include <cstring>
 
-daObj_ItaMato_HIOParam const daObj_ItaMato_Param_c::m = {
+DUSK_GAME_DATA daObj_ItaMato_HIOParam const daObj_ItaMato_Param_c::m = {
     110.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_obj_item.cpp b/src/d/actor/d_a_obj_item.cpp
index c71111ba63..cfd7963207 100644
--- a/src/d/actor/d_a_obj_item.cpp
+++ b/src/d/actor/d_a_obj_item.cpp
@@ -17,7 +17,7 @@
 #include "m_Do/m_Do_mtx.h"
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 #endif
 
 static f32 Reflect(cXyz* i_vec, cBgS_PolyInfo const& i_polyinfo, f32 i_scale) {
@@ -36,7 +36,7 @@ static f32 Reflect(cXyz* i_vec, cBgS_PolyInfo const& i_polyinfo, f32 i_scale) {
 }
 
 #if TARGET_PC
-static void d_a_obj_item_interp_callback(bool isSimFrame, void* pUserWork) {
+static void d_a_obj_item_interp_callback(void* pUserWork) {
     daItem_c* item = static_cast<daItem_c*>(pUserWork);
     if (item == NULL || item->mpModel == NULL || !item->chkDraw()) {
         return;
@@ -158,8 +158,8 @@ void daItem_c::CreateInit() {
     mCcCyl.SetCoHitCallback(itemGetCoCallBack);
     mCcCyl.SetTgHitCallback(itemGetTgCallBack);
 
-    f32 cylHeight = dItem_data::getH(m_itemNo);
-    f32 cylRadius = dItem_data::getR(m_itemNo);
+    f32 cylHeight = DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo));
+    f32 cylRadius = DUSK_IF_ELSE(getCollisionR(), dItem_data::getR(m_itemNo));
 
     if (scale.x > 1.0f) {
         cylHeight *= scale.x;
@@ -206,7 +206,7 @@ void daItem_c::CreateInit() {
     initBaseMtx();
     animPlay(1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);
 
-    if (m_itemNo == dItemNo_BOOMERANG_e) {
+    if (DUSK_IF_ELSE(mOriginalItemNo, m_itemNo) == dItemNo_BOOMERANG_e) {
         itemGetNextExecute();
     } else if ((m_itemNo == dItemNo_ORANGE_RUPEE_e || m_itemNo == dItemNo_SILVER_RUPEE_e) &&
                mSparkleEmtr.getEmitter() == NULL)
@@ -264,6 +264,18 @@ int daItem_c::_daItem_create() {
         shape_angle.z = 0;
         shape_angle.x = 0;
 
+#if TARGET_PC
+        const u32 params = fopAcM_GetParam(this);
+        mOriginalItemNo = params & 0xFF;
+        mItemGiveTag = dusk::mods::item_give_tag_freestanding(daItem_prm::getItemBitNo(this));
+        const auto [item, displayItem, _] =
+            dusk::mods::item_check_resolve(mItemGiveTag, mOriginalItemNo, this);
+        mItemOverridden = item != mOriginalItemNo;
+        setDisplayItemNo(displayItem);
+        if (mItemOverridden) {
+            fopAcM_SetParam(this, (params & 0xFFFFFF00) | item);
+        }
+#endif
         field_0x95d = true;
     }
 
@@ -276,7 +288,11 @@ int daItem_c::_daItem_create() {
     BOOL flag = dItem_data::chkFlag(m_itemNo, 2);
 
 #if DEBUG
+#if TARGET_PC
+    if (dItem_fieldModelArc(getDisplayItemNo()) == NULL) {
+#else
     if (dItem_data::getFieldArc(m_itemNo) == NULL) {
+#endif
         // "Item Num<%d>: No Resource Archive specified!!\n"
         OS_REPORT_ERROR("アイテム番号<%d>:リソースのアーカイブ指定がありません！！\n", m_itemNo);
         return cPhs_ERROR_e;
@@ -308,10 +324,22 @@ int daItem_c::_daItem_create() {
     if (flag) {
         CreateInit();
     } else {
+#if TARGET_PC
+        const u8 displayItemNo = getDisplayItemNo();
+        phase_state = dComIfG_resLoad(&mPhase, dItem_fieldModelArc(displayItemNo));
+#else
         phase_state = dComIfG_resLoad(&mPhase, dItem_data::getFieldArc(m_itemNo));
+#endif
         if (phase_state == cPhs_COMPLEATE_e) {
+#if TARGET_PC
+            const bool useModelFallback = dItem_data::getFieldArc(displayItemNo) == NULL;
+            if (!fopAcM_entrySolidHeap(this,
+                    useModelFallback ? CheckItemCreateHeap : CheckFieldItemCreateHeap,
+                    useModelFallback ? 0x4000 : dItem_data::getFieldHeapSize(displayItemNo)))
+#else
             if (!fopAcM_entrySolidHeap(this, CheckFieldItemCreateHeap,
                                        dItem_data::getFieldHeapSize(m_itemNo)))
+#endif
             {
                 return cPhs_ERROR_e;
             }
@@ -328,7 +356,7 @@ int daItem_c::_daItem_execute() {
     CountTimer();
 
     eyePos = current.pos;
-    eyePos.y += (f32)dItem_data::getH(m_itemNo) / 2;
+    eyePos.y += (f32)DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo)) / 2;
 
     attention_info.position = current.pos;
 
@@ -384,7 +412,7 @@ int daItem_c::_daItem_draw() {
     }
 
 #if TARGET_PC
-    dusk::frame_interp::add_interpolation_callback(&d_a_obj_item_interp_callback, this);
+    dusk::interp::add_interpolation_callback(&d_a_obj_item_interp_callback, this);
 #endif
 
     if (chkDraw()) {
@@ -401,7 +429,11 @@ int daItem_c::_daItem_delete() {
         mSparkleEmtr.remove();
     }
 
+#if TARGET_PC
+    DeleteBase(dItem_fieldModelArc(getDisplayItemNo()));
+#else
     DeleteBase(dItem_data::getFieldArc(m_itemNo));
+#endif
     return 1;
 }
 
@@ -507,9 +539,19 @@ void daItem_c::procInitGetDemoEvent() {
     fopAcM_orderItemEvent(this, 0, 0);
     eventInfo.onCondition(dEvtCnd_CANGETITEM_e);
 
-    m_item_id = fopAcM_createItemForTrBoxDemo(&current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this),
-                                              NULL, NULL);
+#if TARGET_PC
+    const u8 displayItemNo = m_itemNo;
+    const auto itemCheck = dusk::mods::item_check_commit(mItemGiveTag, mOriginalItemNo, this);
+    m_itemNo = itemCheck.itemNo;
+    mItemGiveTag = itemCheck.tag;
+    mItemOverridden = m_itemNo != mOriginalItemNo;
+#endif
+    m_item_id = fopAcM_createItemForTrBoxDemo(
+        &current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this), NULL, NULL IF_DUSK_ARG(mItemGiveTag));
     JUT_ASSERT(0, m_item_id != fpcM_ERROR_PROCESS_ID_e);
+#if TARGET_PC
+    m_itemNo = displayItemNo;
+#endif
 
     setStatus(STATUS_WAIT_GET_DEMO_EVENT_e);
 }
@@ -521,7 +563,7 @@ void daItem_c::procWaitGetDemoEvent() {
             dComIfGp_event_setItemPartnerId(m_item_id);
         }
     } else {
-        if (m_itemNo == dItemNo_BOOMERANG_e) {
+        if (DUSK_IF_ELSE(mOriginalItemNo, m_itemNo) == dItemNo_BOOMERANG_e) {
             fopAcM_orderItemEvent(this, 0, 0);
             eventInfo.onCondition(dEvtCnd_CANGETITEM_e);
             return;
@@ -537,7 +579,9 @@ void daItem_c::procWaitGetDemoEvent() {
 
             procInitSimpleGetDemo();
             itemGet();
-            if (!haveItem) {
+            if (!haveItem IF_DUSK(&&(!mItemOverridden || (m_itemNo >= dItemNo_GREEN_RUPEE_e &&
+                                                             m_itemNo <= dItemNo_SILVER_RUPEE_e))))
+            {
                 dComIfGs_offItemFirstBit(m_itemNo);
             }
         } else {
@@ -559,8 +603,8 @@ void daItem_c::procInitBoomerangCarry() {
     scale = mItemScale;
     mBoomerangMove.initOffset(&current.pos);
 
-    u8 height = dItem_data::getH(m_itemNo);
-    u8 radius = dItem_data::getR(m_itemNo);
+    u8 height = DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo));
+    u8 radius = DUSK_IF_ELSE(getCollisionR(), dItem_data::getR(m_itemNo));
     mCcCyl.SetR((f32)radius * 2.0f);
     mCcCyl.SetH((f32)height * 2.0f);
     mCcCyl.OnCoSPrmBit(1);
@@ -743,32 +787,44 @@ void daItem_c::mode_wait() {
         mAcch.SetGrndNone();
     }
 
-    switch (m_itemNo) {
-    case dItemNo_HEART_e:
-        itemActionForHeart();
-        break;
-    case dItemNo_ARROW_10_e:
-    case dItemNo_ARROW_20_e:
-    case dItemNo_ARROW_30_e:
-    case dItemNo_ARROW_1_e:
-    case dItemNo_PACHINKO_SHOT_e:
-    case dItemNo_LIGHT_ARROW_e:
-        itemActionForArrow();
-        break;
-    case dItemNo_BOOMERANG_e:
+#if TARGET_PC
+    if (mOriginalItemNo == dItemNo_BOOMERANG_e) {
         itemActionForBoomerang();
-        break;
-    case dItemNo_GREEN_RUPEE_e:
-    case dItemNo_BLUE_RUPEE_e:
-    case dItemNo_YELLOW_RUPEE_e:
-    case dItemNo_RED_RUPEE_e:
-    case dItemNo_PURPLE_RUPEE_e:
-    case dItemNo_ORANGE_RUPEE_e:
-    case dItemNo_SILVER_RUPEE_e:
-    default:
-        itemActionForRupee();
-        break;
+    } else {
+#endif
+        switch (m_itemNo) {
+        case dItemNo_HEART_e:
+            itemActionForHeart();
+            break;
+        case dItemNo_ARROW_10_e:
+        case dItemNo_ARROW_20_e:
+        case dItemNo_ARROW_30_e:
+        case dItemNo_ARROW_1_e:
+        case dItemNo_PACHINKO_SHOT_e:
+        case dItemNo_LIGHT_ARROW_e:
+            itemActionForArrow();
+            break;
+        case dItemNo_BOOMERANG_e:
+            // The boomerang check is already handled above, so if we got here, it's guaranteed to be
+            // an override. Fallthrough to the rupee action
+#if !TARGET_PC
+            itemActionForBoomerang();
+            break;
+#endif
+        case dItemNo_GREEN_RUPEE_e:
+        case dItemNo_BLUE_RUPEE_e:
+        case dItemNo_YELLOW_RUPEE_e:
+        case dItemNo_RED_RUPEE_e:
+        case dItemNo_PURPLE_RUPEE_e:
+        case dItemNo_ORANGE_RUPEE_e:
+        case dItemNo_SILVER_RUPEE_e:
+        default:
+            itemActionForRupee();
+            break;
+        }
+#if TARGET_PC
     }
+#endif
 
     if (field_0x9c0 == 0 && mAcch.ChkWaterHit() && mAcch.m_wtr.GetHeight() > current.pos.y) {
         mode_water_init();
@@ -824,49 +880,64 @@ void daItem_c::itemGetNextExecute() {
         setFlag(FLAG_INIT_GET_ITEM_e);
         BOOL haveItem = false;
 
-        switch (m_itemNo) {
-        case dItemNo_HEART_e:
-        case dItemNo_GREEN_RUPEE_e:
-        case dItemNo_ARROW_10_e:
-        case dItemNo_ARROW_20_e:
-        case dItemNo_ARROW_30_e:
-        case dItemNo_ARROW_1_e:
-            procInitSimpleGetDemo();
-            itemGet();
-            break;
-        case dItemNo_BLUE_RUPEE_e:
-        case dItemNo_YELLOW_RUPEE_e:
-        case dItemNo_RED_RUPEE_e:
-        case dItemNo_PURPLE_RUPEE_e:
-        case dItemNo_ORANGE_RUPEE_e:
-        case dItemNo_SILVER_RUPEE_e:
-        case dItemNo_PACHINKO_SHOT_e:
-            if (daPy_getPlayerActorClass()->checkCanoeRide() ||
-                daPy_getPlayerActorClass()->checkHorseRide())
-            {
-                if (checkItemGet(m_itemNo, 1)) {
-                    haveItem = true;
-                }
-                procInitSimpleGetDemo();
-                itemGet();
-
-                if (!haveItem) {
-                    dComIfGs_offItemFirstBit(m_itemNo);
-                }
-            } else if (!checkItemGet(m_itemNo, 1)) {
-                procInitGetDemoEvent();
-            } else {
-                procInitSimpleGetDemo();
-                itemGet();
-            }
-            break;
-        case dItemNo_BOOMERANG_e:
+#if TARGET_PC
+        // Always call demo event for the original boomerang check
+        if (mOriginalItemNo == dItemNo_BOOMERANG_e) {
             procInitGetDemoEvent();
-            break;
-        default:
-            // "[daItem_c] Get process not defined[%d]\n"
-            OS_REPORT_ERROR("[daItem_c]ゲット処理が定義されていません[%d]\n", m_itemNo);
+        } else {
+#endif
+            switch (m_itemNo) {
+            case dItemNo_HEART_e:
+            case dItemNo_GREEN_RUPEE_e:
+            case dItemNo_ARROW_10_e:
+            case dItemNo_ARROW_20_e:
+            case dItemNo_ARROW_30_e:
+            case dItemNo_ARROW_1_e:
+                procInitSimpleGetDemo();
+                itemGet();
+                break;
+            case dItemNo_BLUE_RUPEE_e:
+            case dItemNo_YELLOW_RUPEE_e:
+            case dItemNo_RED_RUPEE_e:
+            case dItemNo_PURPLE_RUPEE_e:
+            case dItemNo_ORANGE_RUPEE_e:
+            case dItemNo_SILVER_RUPEE_e:
+            case dItemNo_PACHINKO_SHOT_e:
+                if (daPy_getPlayerActorClass()->checkCanoeRide() ||
+                    daPy_getPlayerActorClass()->checkHorseRide())
+                {
+                    if (checkItemGet(m_itemNo, 1)) {
+                        haveItem = true;
+                    }
+                    procInitSimpleGetDemo();
+                    itemGet();
+
+                    if (!haveItem) {
+                        dComIfGs_offItemFirstBit(m_itemNo);
+                    }
+                } else if (!checkItemGet(m_itemNo, 1)) {
+                    procInitGetDemoEvent();
+                } else {
+                    procInitSimpleGetDemo();
+                    itemGet();
+                }
+                break;
+            case dItemNo_BOOMERANG_e:
+                procInitGetDemoEvent();
+                break;
+            default:
+#if TARGET_PC
+                if (mItemOverridden) {
+                    procInitGetDemoEvent();
+                    break;
+                }
+#endif
+                // "[daItem_c] Get process not defined[%d]\n"
+                OS_REPORT_ERROR("[daItem_c]ゲット処理が定義されていません[%d]\n", m_itemNo);
+            }
+#if TARGET_PC
         }
+#endif
 
         fopAcM_onItem(this, mItemBitNo);
         mCcCyl.SetTgType(0);
@@ -877,40 +948,54 @@ void daItem_c::itemGetNextExecute() {
 }
 
 void daItem_c::itemGet() {
+#if TARGET_PC
+    const u8 displayItemNo = m_itemNo;
+    const auto itemCheck = dusk::mods::item_check_commit(mItemGiveTag, mOriginalItemNo, this);
+    m_itemNo = itemCheck.itemNo;
+    mItemGiveTag = itemCheck.tag;
+    mItemOverridden = m_itemNo != mOriginalItemNo;
+#endif
     switch (m_itemNo) {
     case dItemNo_HEART_e:
         mDoAud_seStart(Z2SE_HEART_PIECE_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_GREEN_RUPEE_e:
         mDoAud_seStart(Z2SE_GREEN_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_BLUE_RUPEE_e:
         mDoAud_seStart(Z2SE_BLUE_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_YELLOW_RUPEE_e:
         mDoAud_seStart(Z2SE_BLUE_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_RED_RUPEE_e:
         mDoAud_seStart(Z2SE_RED_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_PURPLE_RUPEE_e:
         mDoAud_seStart(Z2SE_RED_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_ORANGE_RUPEE_e:
         mDoAud_seStart(Z2SE_RED_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_SILVER_RUPEE_e:
         mDoAud_seStart(Z2SE_RED_LUPY_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
         break;
     case dItemNo_BOOMERANG_e:
+#if TARGET_PC
+        if (mItemOverridden) {
+            mDoAud_seStart(Z2SE_CONSUMP_ITEM_GET, NULL, 0, 0);
+            execItemGet(m_itemNo, mItemGiveTag, this);
+            break;
+        }
+#endif
         break;
     case dItemNo_ARROW_10_e:
     case dItemNo_ARROW_20_e:
@@ -918,12 +1003,22 @@ void daItem_c::itemGet() {
     case dItemNo_ARROW_1_e:
     case dItemNo_PACHINKO_SHOT_e:
         mDoAud_seStart(Z2SE_CONSUMP_ITEM_GET, NULL, 0, 0);
-        execItemGet(m_itemNo);
+        execItemGet(m_itemNo IF_DUSK_ARG(mItemGiveTag) IF_DUSK_ARG(this));
     default:
+#if TARGET_PC
+        if (mItemOverridden) {
+            mDoAud_seStart(Z2SE_CONSUMP_ITEM_GET, NULL, 0, 0);
+            execItemGet(m_itemNo, mItemGiveTag, this);
+            break;
+        }
+#endif
         // "[daItem_c] Get process not defined[%d]\n"
         OS_REPORT_ERROR("[daItem_c]ゲット処理が定義されていません[%d]\n", m_itemNo);
         break;
     }
+#if TARGET_PC
+    m_itemNo = displayItemNo;
+#endif
 }
 
 BOOL daItem_c::checkCountTimer() {
@@ -1086,7 +1181,7 @@ void daItem_c::set_bound_se() {
     }
 }
 
-s32 daItem_c::m_timer_max = 10000;
+DUSK_GAME_DATA s32 daItem_c::m_timer_max = 10000;
 
 int daItem_c::CountTimer() {
     m_timer++;
@@ -1198,7 +1293,7 @@ void daItem_c::initScale() {
     }
 }
 
-procFunc daItem_c::mFuncPtr[] = {
+DUSK_GAME_DATA procFunc daItem_c::mFuncPtr[] = {
     &daItem_c::procMainNormal,        &daItem_c::procMainEnemyCarry,
     &daItem_c::procMainSimpleGetDemo, &daItem_c::procWaitGetDemoEvent,
     &daItem_c::procMainGetDemoEvent,  &daItem_c::procMainBoomerangCarry,
@@ -1206,7 +1301,7 @@ procFunc daItem_c::mFuncPtr[] = {
     &daItem_c::procMainForceGet,      NULL,
 };
 
-const dCcD_SrcCyl daItem_c::m_cyl_src = {
+DUSK_GAME_DATA const dCcD_SrcCyl daItem_c::m_cyl_src = {
     {
         {0, {{0, 0, 0}, {0xFFFFFFFF, 17}, 0x59}},
         {dCcD_SE_NONE, 0, 0, 0, {0}},
@@ -1230,7 +1325,7 @@ void daItem_c::initSpeed(BOOL i_noTypeChk) {
     u8 type = daItem_prm::getType(this);
 
     if (!i_noTypeChk) {
-        if (type == TYPE_WAIT_e || type == TYPE_BOOM_HIT_e || m_itemNo == dItemNo_BOOMERANG_e) {
+        if (type == TYPE_WAIT_e || type == TYPE_BOOM_HIT_e || DUSK_IF_ELSE(mOriginalItemNo, m_itemNo) == dItemNo_BOOMERANG_e) {
             y_speed = 0.0f;
             speedf = 0.0f;
         } else if (type == TYPE_LAUNCH_NO_RND_e || type == TYPE_FIXED_PLACE_e) {
diff --git a/src/d/actor/d_a_obj_kago.cpp b/src/d/actor/d_a_obj_kago.cpp
index c8a68de52f..7335c4ac35 100644
--- a/src/d/actor/d_a_obj_kago.cpp
+++ b/src/d/actor/d_a_obj_kago.cpp
@@ -15,7 +15,7 @@
 #include "f_op/f_op_actor_mng.h"
 #include <cstring>
 
-daObj_Kago_HIOParam const daObj_Kago_Param_c::m = {
+DUSK_GAME_DATA daObj_Kago_HIOParam const daObj_Kago_Param_c::m = {
     0.0f,
     -5.0f,
     1.0f,
diff --git a/src/d/actor/d_a_obj_kazeneko.cpp b/src/d/actor/d_a_obj_kazeneko.cpp
index 3b1e8766ec..cee30e6d4f 100644
--- a/src/d/actor/d_a_obj_kazeneko.cpp
+++ b/src/d/actor/d_a_obj_kazeneko.cpp
@@ -12,7 +12,7 @@
 #include "d/d_com_inf_game.h"
 #include "f_op/f_op_actor_mng.h"
 
-KazoNekoAttr const daObjKazeNeko_c::M_attr = {
+DUSK_GAME_DATA KazoNekoAttr const daObjKazeNeko_c::M_attr = {
     30.0f, 120.0f, 3000.0f, 7000.0f, 90.0f, 
     1800.0f, 180.0f, 27.0f, 15.0f,
     1, 0x70, 0x6400, 0x190000,
diff --git a/src/d/actor/d_a_obj_kbacket.cpp b/src/d/actor/d_a_obj_kbacket.cpp
index 65c60b74d3..371f03fbd4 100644
--- a/src/d/actor/d_a_obj_kbacket.cpp
+++ b/src/d/actor/d_a_obj_kbacket.cpp
@@ -17,7 +17,7 @@ static s32 l_bmdData[4] = { 8, 0, 9, 0 };
 
 static DUSK_CONST char* l_resNameList[1] = {"Kakashi"};
 
-const daObj_KBacket_HIOParam daObj_KBacket_Param_c::m = {
+DUSK_GAME_DATA const daObj_KBacket_HIOParam daObj_KBacket_Param_c::m = {
     0.0f, -5.0f, 1.0f, 400.0f, 73.0f, 30.0f, 30.0f, 30.0f, 37.0f, 45.0f, 0.0f
 };
 
diff --git a/src/d/actor/d_a_obj_keyhole.cpp b/src/d/actor/d_a_obj_keyhole.cpp
index d56f39f40b..8b120f77e3 100644
--- a/src/d/actor/d_a_obj_keyhole.cpp
+++ b/src/d/actor/d_a_obj_keyhole.cpp
@@ -10,9 +10,6 @@
 #include "d/d_s_play.h"
 #include "d/actor/d_a_player.h"
 #include "Z2AudioLib/Z2Instances.h"
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#endif
 
 daObj_Keyhole_HIO_c::daObj_Keyhole_HIO_c() {
     id = -1;
@@ -56,21 +53,6 @@ static int daObj_Keyhole_Draw(obj_keyhole_class* i_this) {
     for (int i = 0; i < 6; i++) {
         kh_chain_s* chain_s = &i_this->chain_s[i];
         for (int j = 0; j < i_this->chain_num; j++) {
-#if TARGET_PC
-            if (dusk::frame_interp::is_enabled() && i_this->mChainInterpPrevValid && i_this->mChainInterpCurrValid) {
-                const f32 alpha = dusk::frame_interp::get_interpolation_step();
-                Mtx mtx;
-                const f32* p0 = (const f32*)i_this->mChainInterpPrev[i][j];
-                const f32* p1 = (const f32*)i_this->mChainInterpCurr[i][j];
-                f32* dst = (f32*)mtx;
-                for (int k = 0; k < 12; k++) {
-                    dst[k] = p0[k] + (p1[k] - p0[k]) * alpha;
-                }
-                chain_s->model[j]->setBaseTRMtx(mtx);
-                g_env_light.setLightTevColorType_MAJI(chain_s->model[j], &actor->tevStr);
-                mDoExt_modelUpdateDL(chain_s->model[j]);
-            } else
-#endif
             dComIfGp_entrySimpleModel(chain_s->model[j], fopAcM_GetRoomNo(actor));
         }
     }
@@ -388,21 +370,6 @@ static void chain_move(obj_keyhole_class* i_this) {
             ANGLE_ADD(sp8, TREG_S(0) + 0x3D00);
         }
     }
-
-#if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (i_this->mChainInterpCurrValid) {
-            memcpy(i_this->mChainInterpPrev, i_this->mChainInterpCurr, sizeof(i_this->mChainInterpCurr));
-            i_this->mChainInterpPrevValid = true;
-        }
-        for (int i = 0; i < 6; i++) {
-            for (int j = 0; j < i_this->chain_num; j++) {
-                MTXCopy(i_this->chain_s[i].model[j]->getBaseTRMtx(), i_this->mChainInterpCurr[i][j]);
-            }
-        }
-        i_this->mChainInterpCurrValid = true;
-    }
-#endif
 }
 
 static void open(obj_keyhole_class* i_this) {
@@ -783,11 +750,6 @@ static int daObj_Keyhole_Create(fopAc_ac_c* a_this) {
             return cPhs_ERROR_e;
         }
 
-#if TARGET_PC
-        i_this->mChainInterpPrevValid = false;
-        i_this->mChainInterpCurrValid = false;
-#endif
-
         OS_REPORT("//////////////OBJ_KEYHOLE SET 2 !!\n");
 
         if (i_this->arg0 == 3) {
diff --git a/src/d/actor/d_a_obj_klift00.cpp b/src/d/actor/d_a_obj_klift00.cpp
index fbccb64edb..8a0eb5e38e 100644
--- a/src/d/actor/d_a_obj_klift00.cpp
+++ b/src/d/actor/d_a_obj_klift00.cpp
@@ -11,8 +11,20 @@
 #include "d/d_bg_w.h"
 #include "d/d_cc_uty.h"
 #include "d/d_com_inf_game.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
+
+#if TARGET_PC
+#include "dusk/interp/dual_buffer.h"
+#include "dusk/interp/frame_interpolation.h"
+
+static const int CHAIN_INTERP_MAX = 64;
+
+namespace {
+struct KLiftInterp {
+    cXyz draw[CHAIN_INTERP_MAX];
+    dusk::interp::DualBuffer<cXyz, CHAIN_INTERP_MAX> chain{draw};
+};
+}  // namespace
+#endif
 
 struct daObjKLift00_HIO_c : public mDoHIO_entry_c {
     daObjKLift00_HIO_c();
@@ -297,11 +309,6 @@ int daObjKLift00_c::Create() {
     if(getLock())
         mStopSwingingFrames = 5;
 
-#if TARGET_PC
-    mChainInterpPrevValid = false;
-    mChainInterpCurrValid = false;
-#endif
-
     return 1;
 }
 
@@ -444,23 +451,20 @@ int daObjKLift00_c::Execute(Mtx** i_mtx) {
 }
 
 #if TARGET_PC
-static void klift00_interp_callback(bool isSimFrame, void* pUserWork) {
-    static_cast<daObjKLift00_c*>(pUserWork)->onInterpCallback();
+static void klift00_interp_post(void* pUserWork) {
+    static_cast<daObjKLift00_c*>(pUserWork)->onInterpPresentation();
 }
 
-void daObjKLift00_c::onInterpCallback() {
-    if (!mChainInterpPrevValid || !mChainInterpCurrValid) {
-        return;
-    }
-
-    const f32 alpha = dusk::frame_interp::get_interpolation_step();
-    cXyz savedPositions[64];
+void daObjKLift00_c::onInterpPresentation() {
+    cXyz savedPositions[CHAIN_INTERP_MAX];
 
     for (int i = 0; i < mNumChains; i++) {
         savedPositions[i] = mChainPositions[i].mCurrentPos;
-        const cXyz& p0 = mChainInterpPrev[i];
-        const cXyz& p1 = mChainInterpCurr[i];
-        mChainPositions[i].mCurrentPos = p0 + (p1 - p0) * alpha;
+    }
+
+    auto& interp = dusk::interp::get<KLiftInterp>(this);
+    for (int i = 0; i < mNumChains; i++) {
+        mChainPositions[i].mCurrentPos = interp.draw[i];
     }
 
     setMtx();
@@ -493,18 +497,12 @@ int daObjKLift00_c::Draw() {
     dComIfGd_setList();
 
 #if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        if (mChainInterpCurrValid) {
-            memcpy(mChainInterpPrev, mChainInterpCurr, mNumChains * sizeof(cXyz));
-            mChainInterpPrevValid = true;
-        }
-
+    if (dusk::interp::is_enabled() && mNumChains > 0 && mNumChains <= CHAIN_INTERP_MAX) {
+        cXyz curr[CHAIN_INTERP_MAX];
         for (int i = 0; i < mNumChains; i++) {
-            mChainInterpCurr[i] = mChainPositions[i].mCurrentPos;
+            curr[i] = mChainPositions[i].mCurrentPos;
         }
-        
-        mChainInterpCurrValid = true;
-        dusk::frame_interp::add_interpolation_callback(&klift00_interp_callback, this);
+        dusk::interp::get<KLiftInterp>(this).chain.capture_and_schedule(curr, mNumChains, &klift00_interp_post, this);
     }
 #endif
 
diff --git a/src/d/actor/d_a_obj_ktOnFire.cpp b/src/d/actor/d_a_obj_ktOnFire.cpp
index e8c27304e7..000a185e64 100644
--- a/src/d/actor/d_a_obj_ktOnFire.cpp
+++ b/src/d/actor/d_a_obj_ktOnFire.cpp
@@ -25,14 +25,14 @@ static DUSK_CONSTEXPR cull_box l_cull_box = {
     {50.0f, 100.0f, 50.0f},
 };
 
-const dCcD_SrcGObjInf daKtOnFire_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daKtOnFire_c::mCcDObjInfo = {
     {0x0, {{0x200, 0x0, 0x13}, {0xD8FBFFFF, 0x11}, 0x0}}, // mObj
     {dCcD_SE_SWORD, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
     {dCcD_SE_STONE, 0x0, 0x0, 0x0, 0x0}, // mGObjTg
     {0x0}, // mGObjCo
 };
 
-dCcD_SrcCyl daKtOnFire_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daKtOnFire_c::mCcDCyl = {
     mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_kwheel00.cpp b/src/d/actor/d_a_obj_kwheel00.cpp
index b543bbb0cf..bc39975ebc 100644
--- a/src/d/actor/d_a_obj_kwheel00.cpp
+++ b/src/d/actor/d_a_obj_kwheel00.cpp
@@ -127,7 +127,7 @@ static dCcD_SrcSph l_sphSrc = {
     } // mSphAttr
 };
 
-u16 l_se_angle[4] = {0, 0x3FFF, 0x7FFF, 0xBFFF}; // {0°, 90°, 180°, 270°}
+DUSK_GAME_DATA u16 l_se_angle[4] = {0, 0x3FFF, 0x7FFF, 0xBFFF}; // {0°, 90°, 180°, 270°}
 
 int daObjKWheel00_c::Create() {
     mpModel->setBaseTRMtx(mTransformMtx);
diff --git a/src/d/actor/d_a_obj_kznkarm.cpp b/src/d/actor/d_a_obj_kznkarm.cpp
index 9499b05226..fd026b14d1 100644
--- a/src/d/actor/d_a_obj_kznkarm.cpp
+++ b/src/d/actor/d_a_obj_kznkarm.cpp
@@ -73,7 +73,7 @@ void daObjKznkarm_Hio_c::genMessage(JORMContext* ctx) {
 
 #endif
 
- daObjKznkarm_Attr_c const daObjKznkarm_c::M_attr = {
+ DUSK_GAME_DATA daObjKznkarm_Attr_c const daObjKznkarm_c::M_attr = {
     -5.0f, -30.0f, 0.6f, 0.94f,
      40.0f, 40.0f, -60.0f,
     -6.0f, -6.0f, -60.0f, 0.0f,
@@ -82,7 +82,7 @@ void daObjKznkarm_Hio_c::genMessage(JORMContext* ctx) {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_arcName = "J_Kazami";
 
-daObjKznkarm_c::actionFunc daObjKznkarm_c::ActionTable[4][2] = {
+DUSK_GAME_DATA daObjKznkarm_c::actionFunc daObjKznkarm_c::ActionTable[4][2] = {
     &daObjKznkarm_c::initBroken,
     &daObjKznkarm_c::executeBroken,
     &daObjKznkarm_c::initCarry,
diff --git a/src/d/actor/d_a_obj_ladder.cpp b/src/d/actor/d_a_obj_ladder.cpp
index 8d95a53558..1bd7e54786 100644
--- a/src/d/actor/d_a_obj_ladder.cpp
+++ b/src/d/actor/d_a_obj_ladder.cpp
@@ -171,7 +171,7 @@ Hio_c L_hio;
 
 }
 
-char const Act_c::M_arcname[5] = "Mhsg";
+DUSK_GAME_DATA char const Act_c::M_arcname[5] = "Mhsg";
 
 int Act_c::CreateHeap() {
     J3DModelData* model_data = (J3DModelData*)dComIfG_getObjectRes(M_arcname, attr_type(mType).field_0x0);
@@ -344,7 +344,7 @@ void Act_c::mode_fell_init() {
 void Act_c::mode_fell() {
 }
 
-Mtx Act_c::M_tmp_mtx;
+DUSK_GAME_DATA Mtx Act_c::M_tmp_mtx;
 
 void Act_c::set_mtx() {
     mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
diff --git a/src/d/actor/d_a_obj_laundry.cpp b/src/d/actor/d_a_obj_laundry.cpp
index 85fc350e8e..355ca08ddd 100644
--- a/src/d/actor/d_a_obj_laundry.cpp
+++ b/src/d/actor/d_a_obj_laundry.cpp
@@ -11,7 +11,7 @@
 #include "d/d_com_inf_game.h"
 #include "d/d_kankyo_wether.h"
 
-daObjLdy_Attr_c const daObjLdy_c::mAttr = {5.0f, 30.0f, 130.0f, -50.0f, 0.15f, 0.45f, 0.3f, 1000.0f,
+DUSK_GAME_DATA daObjLdy_Attr_c const daObjLdy_c::mAttr = {5.0f, 30.0f, 130.0f, -50.0f, 0.15f, 0.45f, 0.3f, 1000.0f,
                                            0.0f, 0.0f,  0.0f,   0.0f,   0,     10,    0};
 
 void daObjLdy_c::create_init() {
diff --git a/src/d/actor/d_a_obj_laundry_rope.cpp b/src/d/actor/d_a_obj_laundry_rope.cpp
index fd45526bae..5da01533e4 100644
--- a/src/d/actor/d_a_obj_laundry_rope.cpp
+++ b/src/d/actor/d_a_obj_laundry_rope.cpp
@@ -13,7 +13,7 @@
 #include "d/d_kankyo_wether.h"
 #include "d/d_path.h"
 
-daObjLndRope_Attr_c const daObjLndRope_c::mAttr = {-5.0f, 0.2f, 0.5f, 0.8f, 0.0f};
+DUSK_GAME_DATA daObjLndRope_Attr_c const daObjLndRope_c::mAttr = {-5.0f, 0.2f, 0.5f, 0.8f, 0.0f};
 
 static const s8 l_laundryList[13] = {-1, -1, 3, 0, -1, 1, 1, -1, 2, 2, -1, 2, -1};
 
diff --git a/src/d/actor/d_a_obj_life_container.cpp b/src/d/actor/d_a_obj_life_container.cpp
index 22706ba447..85553cda28 100644
--- a/src/d/actor/d_a_obj_life_container.cpp
+++ b/src/d/actor/d_a_obj_life_container.cpp
@@ -6,6 +6,7 @@
 #include "d/dolzel_rel.h" // IWYU pragma: keep
 
 #include "d/actor/d_a_obj_life_container.h"
+#include "d/d_a_itembase_static.h"
 #include "d/d_com_inf_game.h"
 #include "d/actor/d_a_player.h"
 #include "d/d_item_data.h"
@@ -87,8 +88,8 @@ int daObjLife_c::Create() {
     mCcCyl.SetStts(&mCcStts);
     mCcCyl.SetCoHitCallback(lifeGetCoCallBack);
     mCcCyl.SetTgHitCallback(lifeGetTgCallBack);
-    mCcCyl.SetR(dItem_data::getR(m_itemNo));
-    mCcCyl.SetH(dItem_data::getH(m_itemNo));
+    mCcCyl.SetR(DUSK_IF_ELSE(getCollisionR(), dItem_data::getR(m_itemNo)));
+    mCcCyl.SetH(DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo)));
 
     fopAcM_SetCullSize(this, fopAc_CULLSPHERE_0_e);
     fopAcM_SetGravity(this, -3.2f);
@@ -97,6 +98,21 @@ int daObjLife_c::Create() {
     field_0x94c = 0.7f;
     mRotateSpeed = 7000;
 
+#if TARGET_PC
+    // Restore speeds that were skipped if created from a boss with create instead of fastCreate
+    auto bossItemSpeeds = dusk::mods::get_boss_item_actor_speeds();
+    if (bossItemSpeeds.f != 0.f || bossItemSpeeds.y != 0.f) {
+        mOverrideHover = false;
+        speedF = bossItemSpeeds.f;
+        speed.y = bossItemSpeeds.y;
+        dusk::mods::set_boss_item_actor_speeds(0.f, 0.f);
+    }
+
+    if (mOverrideHover) {
+        fopAcM_SetGravity(this, 0.0f);
+        mRotateSpeed = 550;
+    }
+#endif
     setEffect();
     mSound.init(&current.pos, 1);
     return 1;
@@ -140,6 +156,41 @@ int daObjLife_c::create() {
         home.angle.x = home.angle.z = 0;
         current.angle.x = current.angle.z = 0;
         shape_angle.x = shape_angle.z = 0;
+#if TARGET_PC
+        const u32 params = fopAcM_GetParam(this);
+        const u8 parameterItemNo = params & 0xFF;
+        if (mItemGiveOriginalNo == dItemNo_NONE_e) {
+            mOriginalItemNo = parameterItemNo;
+            mItemGiveTag = dusk::mods::item_give_tag_freestanding(getSaveBitNo());
+            const auto [item, displayItem, was_resolved] =
+                dusk::mods::item_check_resolve(mItemGiveTag, mOriginalItemNo, this);
+            setDisplayItemNo(displayItem);
+            mItemOverridden = was_resolved;
+            if (mItemOverridden) {
+                fopAcM_SetParam(this, (params & 0xFFFFFF00) | item);
+            }
+        } else if (mGoldenWolfItem) {
+            mOriginalItemNo = mItemGiveOriginalNo;
+            mItemGiveTag = dusk::mods::item_give_tag_golden_wolf(static_cast<u16>(field_0x938));
+            const auto [item, displayItem, was_resolved] =
+                dusk::mods::item_check_resolve(mItemGiveTag, mOriginalItemNo, this);
+            setDisplayItemNo(displayItem);
+            mItemOverridden = was_resolved;
+            if (item != parameterItemNo) {
+                fopAcM_SetParam(this, (params & 0xFFFFFF00) | item);
+            }
+        } else {
+            mOriginalItemNo = mItemGiveOriginalNo;
+            setDisplayItemNo(
+                dusk::mods::item_check_resolve(mItemGiveTag, parameterItemNo, this)
+                    .display_item);
+            mItemOverridden = parameterItemNo != mOriginalItemNo;
+        }
+        mOverrideHover =
+            mItemOverridden &&
+            (mOriginalItemNo == dItemNo_UTAWA_HEART_e ||
+                (mOriginalItemNo >= dItemNo_M_BEETLE_e && mOriginalItemNo <= dItemNo_F_MAYFLY_e));
+#endif
         mIsPrmsInit = true;
     }
 
@@ -153,15 +204,28 @@ int daObjLife_c::create() {
         return cPhs_ERROR_e;
     }
 
-    if (m_itemNo == dItemNo_UTAWA_HEART_e && dComIfGs_isStageLife()) {
+    if (m_itemNo == dItemNo_UTAWA_HEART_e && dComIfGs_isStageLife() IF_DUSK(&&!mItemOverridden)) {
         return cPhs_ERROR_e;
     }
 
+#if TARGET_PC
+    // Resolved items may have no field model; display their get-demo model instead.
+    const u8 displayItemNo = getDisplayItemNo();
+    const bool useGetModel = dItem_data::getFieldArc(displayItemNo) == NULL;
+    int phase_state = dComIfG_resLoad(&mPhase, dItem_fieldModelArc(displayItemNo));
+    if (phase_state == cPhs_COMPLEATE_e) {
+        if (!fopAcM_entrySolidHeap(
+                this, useGetModel ? CheckItemCreateHeap : CheckFieldItemCreateHeap, 0x4000))
+        {
+            return cPhs_ERROR_e;
+        }
+#else
     int phase_state = dComIfG_resLoad(&mPhase, dItem_data::getFieldArc(m_itemNo));
     if (phase_state == cPhs_COMPLEATE_e) {
         if (!fopAcM_entrySolidHeap(this, CheckFieldItemCreateHeap, 0x4000)) {
             return cPhs_ERROR_e;
         }
+#endif
 
         if (!Create()) {
             return cPhs_ERROR_e;
@@ -296,8 +360,19 @@ int daObjLife_c::initActionOrderGetDemo() {
     fopAcM_orderItemEvent(this, 0, 0);
     eventInfo.onCondition(dEvtCnd_CANGETITEM_e);
 
-    mItemId = fopAcM_createItemForTrBoxDemo(&current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this), NULL, NULL);
+#if TARGET_PC
+    const u8 displayItemNo = m_itemNo;
+    const auto itemCheck = dusk::mods::item_check_commit(mItemGiveTag, mOriginalItemNo, this);
+    m_itemNo = itemCheck.itemNo;
+    mItemGiveTag = itemCheck.tag;
+    mItemOverridden = m_itemNo != mOriginalItemNo;
+#endif
+    mItemId = fopAcM_createItemForTrBoxDemo(
+        &current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this), NULL, NULL IF_DUSK_ARG(mItemGiveTag));
     JUT_ASSERT(699, mItemId != fpcM_ERROR_PROCESS_ID_e);
+#if TARGET_PC
+    m_itemNo = displayItemNo;
+#endif
 
     setStatus(STATUS_ORDER_GET_DEMO_e);
     return 1;
@@ -360,8 +435,8 @@ int daObjLife_c::actionInitBoomerangCarry() {
     mCcCyl.OnTgSPrmBit(1);
     mCcCyl.OnCoSPrmBit(1);
 
-    f32 height = dItem_data::getH(m_itemNo) * 4.0f;
-    f32 radius = dItem_data::getR(m_itemNo) * 4.0f;
+    f32 height = DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo)) * 4.0f;
+    f32 radius = DUSK_IF_ELSE(getCollisionR(), dItem_data::getR(m_itemNo)) * 4.0f;
     mCcCyl.SetR(radius);
     mCcCyl.SetH(height);
 
@@ -482,7 +557,11 @@ int daObjLife_c::_delete() {
     endEffect00();
     endEffect02();
 
+#if TARGET_PC
+    DeleteBase(dItem_fieldModelArc(getDisplayItemNo()));
+#else
     DeleteBase(dItem_data::getFieldArc(m_itemNo));
+#endif
     return 1;
 }
 
diff --git a/src/d/actor/d_a_obj_lv1Candle00.cpp b/src/d/actor/d_a_obj_lv1Candle00.cpp
index aaa3a8ccc4..64a8f7c904 100644
--- a/src/d/actor/d_a_obj_lv1Candle00.cpp
+++ b/src/d/actor/d_a_obj_lv1Candle00.cpp
@@ -10,7 +10,7 @@
 
 static daLv1Cdl00_HIO_c l_HIO;
 
-dCcD_SrcGObjInf const daLv1Cdl00_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daLv1Cdl00_c::mCcDObjInfo = {
     {
         0, {
             {0x200, 0, 0x13},
@@ -23,7 +23,7 @@ dCcD_SrcGObjInf const daLv1Cdl00_c::mCcDObjInfo = {
     {0},
 };
 
-dCcD_SrcCyl daLv1Cdl00_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv1Cdl00_c::mCcDCyl = {
     daLv1Cdl00_c::mCcDObjInfo,
     {
         { {0.0f, 0.0f, 0.0f}, 0, 0}
diff --git a/src/d/actor/d_a_obj_lv1Candle01.cpp b/src/d/actor/d_a_obj_lv1Candle01.cpp
index 0d6fdaa337..a910141bb1 100644
--- a/src/d/actor/d_a_obj_lv1Candle01.cpp
+++ b/src/d/actor/d_a_obj_lv1Candle01.cpp
@@ -10,7 +10,7 @@
 
 static daLv1Cdl01_HIO_c l_HIO;
 
-dCcD_SrcGObjInf const daLv1Cdl01_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daLv1Cdl01_c::mCcDObjInfo = {
     {
         0, {
             {0, 0, 0},
@@ -23,7 +23,7 @@ dCcD_SrcGObjInf const daLv1Cdl01_c::mCcDObjInfo = {
     {0},
 };
 
-dCcD_SrcCyl daLv1Cdl01_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv1Cdl01_c::mCcDCyl = {
     daLv1Cdl01_c::mCcDObjInfo,
     {
         { {0.0f, 0.0f, 0.0f}, 0, 0}
diff --git a/src/d/actor/d_a_obj_lv2Candle.cpp b/src/d/actor/d_a_obj_lv2Candle.cpp
index 0abdc763b2..7b3a511d3b 100644
--- a/src/d/actor/d_a_obj_lv2Candle.cpp
+++ b/src/d/actor/d_a_obj_lv2Candle.cpp
@@ -35,7 +35,7 @@ daLv2Candle_HIO_c::daLv2Candle_HIO_c() {
     mColor2B = 0x42;
 }
 
-dCcD_SrcGObjInf const daLv2Candle_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daLv2Candle_c::mCcDObjInfo = {
     {
         0, {
             {0x200, 0, 0x13},
@@ -48,7 +48,7 @@ dCcD_SrcGObjInf const daLv2Candle_c::mCcDObjInfo = {
     {0},
 };
 
-dCcD_SrcCyl daLv2Candle_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv2Candle_c::mCcDCyl = {
     daLv2Candle_c::mCcDObjInfo,
     {
         { {0.0f, 0.0f, 0.0f}, 0, 0}
diff --git a/src/d/actor/d_a_obj_lv3Candle.cpp b/src/d/actor/d_a_obj_lv3Candle.cpp
index 58e8cb3185..6f12a81bd3 100644
--- a/src/d/actor/d_a_obj_lv3Candle.cpp
+++ b/src/d/actor/d_a_obj_lv3Candle.cpp
@@ -34,14 +34,14 @@ void daLv3Candle_HIO_c::genMessage(JORMContext* mctx) {
 }
 #endif
 
-dCcD_SrcGObjInf const daLv3Candle_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daLv3Candle_c::mCcDObjInfo = {
     {0, {{0x200, 0, 0x13}, {0xd8fbfdff, 0x1f}, {0x79}}},
     {1, 0, 0, 0, 0},
     {0xa, 0, 0, 0, 6},
     {0},
 };
 
-dCcD_SrcSph daLv3Candle_c::mCcDSph = {daLv3Candle_c::mCcDObjInfo, {{{0.0f, 0.0f, 0.0f}, 0.0f}}};
+DUSK_GAME_DATA dCcD_SrcSph daLv3Candle_c::mCcDSph = {daLv3Candle_c::mCcDObjInfo, {{{0.0f, 0.0f, 0.0f}, 0.0f}}};
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_resNameIdx[] = {"L3candl", "L3candl2"};
 
diff --git a/src/d/actor/d_a_obj_lv4chandelier.cpp b/src/d/actor/d_a_obj_lv4chandelier.cpp
index 9ab47345d4..56f9aa93c1 100644
--- a/src/d/actor/d_a_obj_lv4chandelier.cpp
+++ b/src/d/actor/d_a_obj_lv4chandelier.cpp
@@ -12,10 +12,6 @@
 #include "d/d_cc_d.h"
 #include "d/d_cc_uty.h"
 
-#ifndef __MWERKS__
-#include "dusk/math.h"
-#endif
-
 #if DEBUG
 class daObjLv4Chan_HIO_c : public mDoHIO_entry_c {
 public:
diff --git a/src/d/actor/d_a_obj_lv5FloorBoard.cpp b/src/d/actor/d_a_obj_lv5FloorBoard.cpp
index db7416dc5a..4dbd3cfe5c 100644
--- a/src/d/actor/d_a_obj_lv5FloorBoard.cpp
+++ b/src/d/actor/d_a_obj_lv5FloorBoard.cpp
@@ -76,14 +76,14 @@ int daFlorBoad_c::Execute(Mtx** param_0) {
 
 static daFlorBoad_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daFlorBoad_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daFlorBoad_c::mCcDObjInfo = {
     {0, {{0, 1, 0}, {0x400020, 0x11}, {0}}},
     {dCcD_SE_SWORD, 0, 0, 2, 1},
     {dCcD_SE_STONE, 0, 0, 0, 6},
     {0},
 };
 
-dCcD_SrcCyl daFlorBoad_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daFlorBoad_c::mCcDCyl = {
     daFlorBoad_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_lv5IceWall.cpp b/src/d/actor/d_a_obj_lv5IceWall.cpp
index d1d2eb29a0..f514f80a98 100644
--- a/src/d/actor/d_a_obj_lv5IceWall.cpp
+++ b/src/d/actor/d_a_obj_lv5IceWall.cpp
@@ -50,14 +50,14 @@ int daIceWall_c::CreateHeap() {
 
 static daIceWall_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daIceWall_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daIceWall_c::mCcDObjInfo = {
     {0, {{0x100, 1, 0}, {0x400000, 0x11}, {0}}},
     {dCcD_SE_SWORD, 0, 0, 2, 1},
     {dCcD_SE_STONE, 0, 0, 0, 0x2006},
     {0},
 };
 
-dCcD_SrcCyl daIceWall_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daIceWall_c::mCcDCyl = {
     daIceWall_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_lv5SwIce.cpp b/src/d/actor/d_a_obj_lv5SwIce.cpp
index 62171dc2bb..8c474aa125 100644
--- a/src/d/actor/d_a_obj_lv5SwIce.cpp
+++ b/src/d/actor/d_a_obj_lv5SwIce.cpp
@@ -70,14 +70,14 @@ int daLv5SwIce_c::Execute(Mtx** param_0) {
 
 static daLv5SwIce_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daLv5SwIce_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daLv5SwIce_c::mCcDObjInfo = {
     {0, {{0x100, 1, 0}, {0x400000, 0x11}, {0}}},
     {dCcD_SE_SWORD, 0, 0, 2, 1},
     {dCcD_SE_STONE, 0, 0, 0, 0x6},
     {0},
 };
 
-dCcD_SrcCyl daLv5SwIce_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv5SwIce_c::mCcDCyl = {
     daLv5SwIce_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_lv6ChangeGate.cpp b/src/d/actor/d_a_obj_lv6ChangeGate.cpp
index 59638a4d45..3a3ae79af5 100644
--- a/src/d/actor/d_a_obj_lv6ChangeGate.cpp
+++ b/src/d/actor/d_a_obj_lv6ChangeGate.cpp
@@ -28,14 +28,14 @@ daLv6ChangeGate_HIO_c::daLv6ChangeGate_HIO_c() {
 
 static daLv6ChangeGate_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daLv6ChangeGate_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daLv6ChangeGate_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0x400, 0x11}, {0x79}}},
     {dCcD_SE_SWORD, 0, 0, 0, 0},
     {dCcD_SE_STONE, 0, 0, 0, 0},
     {0},
 };
 
-dCcD_SrcCyl daLv6ChangeGate_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv6ChangeGate_c::mCcDCyl = {
     mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f}
diff --git a/src/d/actor/d_a_obj_lv6FurikoTrap.cpp b/src/d/actor/d_a_obj_lv6FurikoTrap.cpp
index 0aab579c51..bd31d398c6 100644
--- a/src/d/actor/d_a_obj_lv6FurikoTrap.cpp
+++ b/src/d/actor/d_a_obj_lv6FurikoTrap.cpp
@@ -24,13 +24,13 @@ void daLv6FurikoTrap_HIO_c::genMessage(JORMContext* context) {
 
 static daLv6FurikoTrap_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daLv6FurikoTrap_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daLv6FurikoTrap_c::mCcDObjInfo = {
     {0, {{0x800, 1, 0x1f}, {0, 0}, {0x79}}},
     {1, 0, 1, 0, 1},
     {0xa, 5, 0, 0, 0},
     {0},
 };
-dCcD_SrcSph daLv6FurikoTrap_c::mCcDSph = {mCcDObjInfo};
+DUSK_GAME_DATA dCcD_SrcSph daLv6FurikoTrap_c::mCcDSph = {mCcDObjInfo};
 
 void daLv6FurikoTrap_c::setBaseMtx() {
     mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
diff --git a/src/d/actor/d_a_obj_lv6SwGate.cpp b/src/d/actor/d_a_obj_lv6SwGate.cpp
index 14e0bc4bb6..cdcc97efde 100644
--- a/src/d/actor/d_a_obj_lv6SwGate.cpp
+++ b/src/d/actor/d_a_obj_lv6SwGate.cpp
@@ -31,11 +31,11 @@ void daLv6SwGate_HIO_c::genMessage(JORMContext* context)
 
 static daLv6SwGate_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daLv6SwGate_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daLv6SwGate_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0x400, 0x11}, {0x79}}}, {1, 0, 0, 0, 0}, {0xA, 0, 0, 0, 0}, {0}
 };
 
-dCcD_SrcCyl daLv6SwGate_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv6SwGate_c::mCcDCyl = {
     mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_lv6TogeRoll.cpp b/src/d/actor/d_a_obj_lv6TogeRoll.cpp
index f4e4816f8d..694b3242cd 100644
--- a/src/d/actor/d_a_obj_lv6TogeRoll.cpp
+++ b/src/d/actor/d_a_obj_lv6TogeRoll.cpp
@@ -10,14 +10,14 @@
 
 static daTogeRoll_HIO_c l_HIO;
 
-dCcD_SrcSph daTogeRoll_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daTogeRoll_c::mCcDSph = {
     daTogeRoll_c::mCcDObjInfo,  // mObjInf
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
     }  // mSphAttr
 };
 
-dCcD_SrcCps daTogeRoll_c::mCcDCps = {
+DUSK_GAME_DATA dCcD_SrcCps daTogeRoll_c::mCcDCps = {
     daTogeRoll_c::mCcDObjInfo2,  // mObjInf
     {
         {{0.0f, 0.0f, 0.0f}, {0.0f, 1100.0f, 0.0f}, 150.0f},  // mCps
@@ -50,21 +50,21 @@ int daTogeRoll_c::CreateHeap() {
     return 1;
 }
 
-dCcD_SrcGObjInf const daTogeRoll_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daTogeRoll_c::mCcDObjInfo = {
     {0, {{0x800, 0x1, 0x1f}, {0xdafbfdff, 0x1f}, {0x79}}},
     {1, 0, 1, 0, 1},
     {0xa, 5, 0, 0, 0},
     {0},
 };
 
-dCcD_SrcGObjInf const daTogeRoll_c::mCcDObjInfo2 = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daTogeRoll_c::mCcDObjInfo2 = {
     {0, {{0, 0, 0}, {0xdafbfdff, 0x1f}, {0}}},
     {1, 0, 0, 0, 0},
     {0xa, 1, 0, 0, 2},
     {0},
 };
 
-f32 const daTogeRoll_c::mSpeed[] = {
+DUSK_GAME_DATA f32 const daTogeRoll_c::mSpeed[] = {
     10.0f, 16.6666666f, 23.3333333f, 25.0f,      26.6666666f, 28.3333333f,
     30.0f, 31.6666666f, 33.3333333f, 40.0f,      46.6666666f, 53.3333333f,
     60.0f, 66.6666666f, 83.3333333f, 3.3333333f,
diff --git a/src/d/actor/d_a_obj_lv6TogeTrap.cpp b/src/d/actor/d_a_obj_lv6TogeTrap.cpp
index b5244139f2..16399a899b 100644
--- a/src/d/actor/d_a_obj_lv6TogeTrap.cpp
+++ b/src/d/actor/d_a_obj_lv6TogeTrap.cpp
@@ -51,28 +51,28 @@ daLv6TogeTrap_HIO_c::daLv6TogeTrap_HIO_c() {
 
 static daLv6TogeTrap_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daLv6TogeTrap_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daLv6TogeTrap_c::mCcDObjInfo = {
     {0, {{0x800, 0x1, 0x1F}, {0xD8FBFDFF, 0x11}, {0x79}}},
     {dCcD_SE_SWORD, 0, 1, 0, 1},
     {dCcD_SE_STONE, 5, 0, 0, 0},
     {0},
 };
 
-const dCcD_SrcGObjInf daLv6TogeTrap_c::mCcDObjInfo2 = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daLv6TogeTrap_c::mCcDObjInfo2 = {
     {0, {{0x0, 0x0, 0}, {0xDAFBFDFF, 0x11}, {0x0}}},
     {dCcD_SE_SWORD, 0, 0, 0, 0},
     {dCcD_SE_STONE, 1, 0, 0, 2},
     {0},
 };
 
-dCcD_SrcSph daLv6TogeTrap_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daLv6TogeTrap_c::mCcDSph = {
     daLv6TogeTrap_c::mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
     }  // mSphAttr
 };
 
-dCcD_SrcCyl daLv6TogeTrap_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daLv6TogeTrap_c::mCcDCyl = {
     daLv6TogeTrap_c::mCcDObjInfo2,
     {
         {
@@ -89,7 +89,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNameIdx[3] = {
     "L9Toge",
 };
 
-const f32 daLv6TogeTrap_c::mSpeed[16] = {
+DUSK_GAME_DATA const f32 daLv6TogeTrap_c::mSpeed[16] = {
     10.0f,
     16.666666f,
     23.333334f,
diff --git a/src/d/actor/d_a_obj_lv8Lift.cpp b/src/d/actor/d_a_obj_lv8Lift.cpp
index a598830e74..b77e098487 100644
--- a/src/d/actor/d_a_obj_lv8Lift.cpp
+++ b/src/d/actor/d_a_obj_lv8Lift.cpp
@@ -11,7 +11,7 @@
 #include "d/d_bg_w.h"
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 #endif
 
 daL8Lift_HIO_c::daL8Lift_HIO_c() {
@@ -37,7 +37,7 @@ void daL8Lift_c::setBaseMtx() {
     mpModel->setBaseTRMtx(mDoMtx_stack_c::now);
 }
 
-f32 const daL8Lift_c::mSpeed[16] = {
+DUSK_GAME_DATA f32 const daL8Lift_c::mSpeed[16] = {
     5.0f, 6.6666665f, 8.333333f, 10.0f, 11.666667f, 13.333333f,
     15.0f, 16.666666f, 18.333334f, 20.0f, 21.666666, 23.333334,
     25.0f, 26.666666f, 28.333334f, 3.3333333f
@@ -385,7 +385,7 @@ void daL8Lift_c::setNextPoint() {
 }
 
 #if TARGET_PC
-void daL8Lift_interp_callback(bool isSimFrame, void* pUserWork) {
+void daL8Lift_interp_callback(void* pUserWork) {
     daL8Lift_c* lift = static_cast<daL8Lift_c*>(pUserWork);
     if (lift == NULL || lift->mpModel == NULL) {
         return;
@@ -419,7 +419,7 @@ void daL8Lift_interp_callback(bool isSimFrame, void* pUserWork) {
 
 int daL8Lift_c::Draw() {
 #if TARGET_PC
-    dusk::frame_interp::add_interpolation_callback(&daL8Lift_interp_callback, this);
+    dusk::interp::add_interpolation_callback(&daL8Lift_interp_callback, this);
 #endif
 
     g_env_light.settingTevStruct(16, &current.pos, &tevStr);
diff --git a/src/d/actor/d_a_obj_lv8OptiLift.cpp b/src/d/actor/d_a_obj_lv8OptiLift.cpp
index 50b84ac981..b63b0979f8 100644
--- a/src/d/actor/d_a_obj_lv8OptiLift.cpp
+++ b/src/d/actor/d_a_obj_lv8OptiLift.cpp
@@ -12,7 +12,7 @@
 #include "d/d_path.h"
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 #endif
 
 daOptiLift_HIO_c::daOptiLift_HIO_c() {
@@ -38,7 +38,7 @@ void daOptiLift_c::setBaseMtx() {
     mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
 }
 
-const f32 daOptiLift_c::mSpeed[] = {
+DUSK_GAME_DATA const f32 daOptiLift_c::mSpeed[] = {
     5.0f,       6.6666665f, 8.333333f,  10.0f,      11.666667f, 13.333333f, 15.0f,      16.666666f,
     18.333334f, 20.0f,      21.666666f, 23.333334f, 25.0f,      26.666666f, 28.333334f, 3.3333333f,
 };
@@ -417,7 +417,7 @@ void daOptiLift_c::setNextPoint() {
 }
 
 #if TARGET_PC
-static void daOptiLift_interp_callback(bool isSimFrame, void* pUserWork) {
+static void daOptiLift_interp_callback(void* pUserWork) {
     daOptiLift_c* lift = static_cast<daOptiLift_c*>(pUserWork);
     if (lift == NULL || lift->mpModel == NULL) {
         return;
@@ -451,7 +451,7 @@ static void daOptiLift_interp_callback(bool isSimFrame, void* pUserWork) {
 
 int daOptiLift_c::Draw() {
 #if TARGET_PC
-    dusk::frame_interp::add_interpolation_callback(&daOptiLift_interp_callback, this);
+    dusk::interp::add_interpolation_callback(&daOptiLift_interp_callback, this);
 #endif
 
     g_env_light.settingTevStruct(0x10, &current.pos, &tevStr);
diff --git a/src/d/actor/d_a_obj_magLift.cpp b/src/d/actor/d_a_obj_magLift.cpp
index f9ddc34be0..0ff6961815 100644
--- a/src/d/actor/d_a_obj_magLift.cpp
+++ b/src/d/actor/d_a_obj_magLift.cpp
@@ -37,7 +37,7 @@ int daMagLift_c::CreateHeap() {
     return 1;
 }
 
-const f32 daMagLift_c::mSpeed[16] = {
+DUSK_GAME_DATA const f32 daMagLift_c::mSpeed[16] = {
     5.0f,       6.6666665f, 8.333333f,  10.0f,      11.666667f, 13.333333f, 15.0f,      16.666666f,
     18.333334f, 20.0f,      21.666666f, 23.333334f, 25.0f,      26.666666f, 28.333334f, 3.3333333f,
 };
diff --git a/src/d/actor/d_a_obj_maki.cpp b/src/d/actor/d_a_obj_maki.cpp
index 7d4ac8e32a..c5a8530405 100644
--- a/src/d/actor/d_a_obj_maki.cpp
+++ b/src/d/actor/d_a_obj_maki.cpp
@@ -132,7 +132,7 @@ int daObj_Maki_IsDelete(obj_maki_class* i_this) {
     return true;
 }
 
-u8 lbl_567_bss_8;
+DUSK_GAME_DATA u8 lbl_567_bss_8;
 
 int daObj_Maki_Delete(obj_maki_class* i_this) {
     dComIfG_resDelete(&i_this->mPhase, "Obj_maki");
@@ -237,7 +237,7 @@ cPhs_Step daObj_Maki_Create(fopAc_ac_c* i_this) {
     return phase;
 }
 
-actor_method_class l_daObj_Maki_Method = {
+DUSK_GAME_DATA actor_method_class l_daObj_Maki_Method = {
     (process_method_func)daObj_Maki_Create,  (process_method_func)daObj_Maki_Delete,
     (process_method_func)daObj_Maki_Execute, (process_method_func)daObj_Maki_IsDelete,
     (process_method_func)daObj_Maki_Draw,
diff --git a/src/d/actor/d_a_obj_master_sword.cpp b/src/d/actor/d_a_obj_master_sword.cpp
index e0b741fe18..444b7356e3 100644
--- a/src/d/actor/d_a_obj_master_sword.cpp
+++ b/src/d/actor/d_a_obj_master_sword.cpp
@@ -1,6 +1,6 @@
 /**
  * @file d_a_obj_master_sword.cpp
- * 
+ *
 */
 
 #include "d/dolzel_rel.h" // IWYU pragma: keep
@@ -10,7 +10,14 @@
 #include "d/d_com_inf_game.h"
 #include "d/d_meter2_info.h"
 
-daObjMasterSword_Attr_c const daObjMasterSword_c::mAttr = {1.0f};
+#if TARGET_PC
+#include "dusk/mods/item.hpp"
+#include "mods/items.h"
+
+#include "d/d_item.h"
+#endif
+
+DUSK_GAME_DATA daObjMasterSword_Attr_c const daObjMasterSword_c::mAttr = {1.0f};
 
 void daObjMasterSword_c::initBaseMtx() {
     fopAcM_SetMtx(this, mpModel->getBaseTRMtx());
@@ -80,7 +87,7 @@ static int daObjMasterSword_Create(fopAc_ac_c* i_this) {
     return static_cast<daObjMasterSword_c*>(i_this)->create();
 }
 
-actionFunc daObjMasterSword_c::ActionTable[] = {
+DUSK_GAME_DATA actionFunc daObjMasterSword_c::ActionTable[] = {
     &daObjMasterSword_c::initWait, &daObjMasterSword_c::executeWait,
 };
 
@@ -186,11 +193,39 @@ int daObjMasterSword_c::execute() {
     mBrk.play();
 
     if (dComIfGs_isTmpBit(dSv_event_tmp_flag_c::tempBitLabels[73])) {
+#if TARGET_PC
+        const auto masterSword = dusk::mods::item_check_commit(
+            ITEM_CHECK_MASTER_SWORD, dItemNo_MASTER_SWORD_e, this);
+        if (!masterSword.was_resolved) {
+            dComIfGs_onItemFirstBit(dItemNo_MASTER_SWORD_e);
+            dMeter2Info_setSword(dItemNo_MASTER_SWORD_e, false);
+            dComIfGs_setSelectEquipSword(dItemNo_MASTER_SWORD_e);
+            dusk::mods::item_check_complete(masterSword, this);
+        } else if (masterSword.itemNo == dItemNo_NONE_e) {
+            dusk::mods::item_check_complete(masterSword, this);
+        } else {
+            dusk::mods::item_check_enqueue(masterSword, dusk::mods::ItemGiveMode::Demo);
+        }
+
+        dComIfGp_setItemLifeCount(dComIfGs_getMaxLife(), 0);
+
+        const auto shadowCrystal = dusk::mods::item_check_commit(
+            ITEM_CHECK_SHADOW_CRYSTAL, dItemNo_SHADOW_CRYSTAL_e, this);
+        if (!shadowCrystal.was_resolved) {
+            execItemGet(shadowCrystal.itemNo, shadowCrystal.tag, this);
+        } else if (shadowCrystal.itemNo == dItemNo_NONE_e) {
+            dusk::mods::item_check_complete(shadowCrystal, this);
+        } else {
+            dusk::mods::item_check_enqueue(shadowCrystal, dusk::mods::ItemGiveMode::Demo);
+        }
+
+#else
         dComIfGs_onItemFirstBit(dItemNo_MASTER_SWORD_e);
         dMeter2Info_setSword(dItemNo_MASTER_SWORD_e, false);
         dComIfGs_setSelectEquipSword(dItemNo_MASTER_SWORD_e);
 
         dComIfGp_setItemLifeCount(dComIfGs_getMaxLife(), 0);
+#endif
         dComIfGs_onEventBit(dSv_event_flag_c::saveBitLabels[getFlagNo()]);
         fopAcM_delete(this);
     }
diff --git a/src/d/actor/d_a_obj_mhole.cpp b/src/d/actor/d_a_obj_mhole.cpp
index 0667afd39e..239e935301 100644
--- a/src/d/actor/d_a_obj_mhole.cpp
+++ b/src/d/actor/d_a_obj_mhole.cpp
@@ -25,7 +25,7 @@ static f32 const l_size[2] = {150.0f, 370.0f};
 
 static char const* l_arcName[2] = {"ef_MgnF_L", "ef_MgnF_S"};
 
-dCcD_SrcCps l_cps_src = {
+DUSK_GAME_DATA dCcD_SrcCps l_cps_src = {
     {
         {0x0, {{AT_TYPE_40000, 0x0, 0x1d}, {0x0, 0x0}, 0x0}},  // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x6},                    // mGObjAt
diff --git a/src/d/actor/d_a_obj_mie.cpp b/src/d/actor/d_a_obj_mie.cpp
index d6790c3637..ab96679de6 100644
--- a/src/d/actor/d_a_obj_mie.cpp
+++ b/src/d/actor/d_a_obj_mie.cpp
@@ -23,7 +23,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNameList[2] = {
     "pouyaA",
 };
 
-daObj_Mie_HIOParam const daObj_Mie_Param_c::m = {
+DUSK_GAME_DATA daObj_Mie_HIOParam const daObj_Mie_Param_c::m = {
     0.0f, -4.0f, 1.0f, 100.0f, 255.0f, 20.0f, 10.0f, 14.0f, 37.0f, 50.0f, 18.0f,
 };
 
diff --git a/src/d/actor/d_a_obj_mirror_6pole.cpp b/src/d/actor/d_a_obj_mirror_6pole.cpp
index 5887fffc22..41b755850f 100644
--- a/src/d/actor/d_a_obj_mirror_6pole.cpp
+++ b/src/d/actor/d_a_obj_mirror_6pole.cpp
@@ -11,7 +11,7 @@
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_arcName = "MR-6Pole";
 
-const actionFunc daObjMirror6Pole_c::ActionTable[][2] = {
+DUSK_GAME_DATA const actionFunc daObjMirror6Pole_c::ActionTable[][2] = {
     {&daObjMirror6Pole_c::initWait, &daObjMirror6Pole_c::executeWait},
     {&daObjMirror6Pole_c::initDemo, &daObjMirror6Pole_c::executeDemo},
 };
diff --git a/src/d/actor/d_a_obj_mirror_screw.cpp b/src/d/actor/d_a_obj_mirror_screw.cpp
index a9948e8b75..ec5b698bd5 100644
--- a/src/d/actor/d_a_obj_mirror_screw.cpp
+++ b/src/d/actor/d_a_obj_mirror_screw.cpp
@@ -11,7 +11,7 @@
 
 static char const* l_arcName = "MR-Screw";
 
-daObjMirrorScrew_c::attr const daObjMirrorScrew_c::M_attr = {
+DUSK_GAME_DATA daObjMirrorScrew_c::attr const daObjMirrorScrew_c::M_attr = {
     -2710.0f,  // mDownDist
     0.6f,      // mRotSpeedThreshold
     45,        // mSpinCount
@@ -20,7 +20,7 @@ daObjMirrorScrew_c::attr const daObjMirrorScrew_c::M_attr = {
     -3.375f,   // mDownSpeed
 };
 
-daObjMirrorScrew_actionFunc daObjMirrorScrew_c::ActionTable[2][2] = {
+DUSK_GAME_DATA daObjMirrorScrew_actionFunc daObjMirrorScrew_c::ActionTable[2][2] = {
     {
         &daObjMirrorScrew_c::initWait,
         &daObjMirrorScrew_c::executeWait,
diff --git a/src/d/actor/d_a_obj_movebox.cpp b/src/d/actor/d_a_obj_movebox.cpp
index 7e685080c9..729ac8c702 100644
--- a/src/d/actor/d_a_obj_movebox.cpp
+++ b/src/d/actor/d_a_obj_movebox.cpp
@@ -99,12 +99,12 @@ void daObjMovebox::Hio_c::genMessage(JORMContext* context) {
 
 #endif
 
-const daObjMovebox::BgcSrc_c daObjMovebox::Bgc_c::M_lin5[] = {
+DUSK_GAME_DATA const daObjMovebox::BgcSrc_c daObjMovebox::Bgc_c::M_lin5[] = {
     {0.0f, 0.0f, 0.0f, 0.0f},   {-0.5f, -0.5f, 1.0f, 1.0f}, {0.5f, -0.5f, -1.0f, 1.0f},
     {0.5f, 0.5f, -1.0f, -1.0f}, {-0.5f, 0.5f, 1.0f, -1.0f},
 };
 
-const daObjMovebox::BgcSrc_c daObjMovebox::Bgc_c::M_lin20[] = {
+DUSK_GAME_DATA const daObjMovebox::BgcSrc_c daObjMovebox::Bgc_c::M_lin20[] = {
     {0.0f, 0.0f, 0.0f, 0.0f},    {-0.25f, -0.25f, 0.0f, 0.0f}, {-0.5f, -0.5f, 1.0f, 1.0f},
     {0.0f, -0.5f, -1.0f, 1.0f},  {0.0f, 0.0f, -1.0f, -1.0f},   {-0.5f, 0.0f, 1.0f, -1.0f},
     {0.25f, -0.25f, 0.0f, 0.0f}, {0.0f, -0.5f, 1.0f, 1.0f},    {0.5f, -0.5f, -1.0f, 1.0f},
@@ -128,7 +128,7 @@ daObjMovebox::Bgc_c::Bgc_c() {
     mState = STATE_0_e;
 }
 
-dBgS_ObjGndChk daObjMovebox::Bgc_c::M_gnd_work[23];
+DUSK_GAME_DATA dBgS_ObjGndChk daObjMovebox::Bgc_c::M_gnd_work[23];
 
 void daObjMovebox::Bgc_c::gnd_pos(const daObjMovebox::Act_c* i_actor,
                                   const daObjMovebox::BgcSrc_c* i_bgcSrc, int i_checkNum,
@@ -165,7 +165,7 @@ void daObjMovebox::Bgc_c::gnd_pos(const daObjMovebox::Act_c* i_actor,
     }
 }
 
-dBgS_WtrChk daObjMovebox::Bgc_c::M_wrt_work;
+DUSK_GAME_DATA dBgS_WtrChk daObjMovebox::Bgc_c::M_wrt_work;
 
 
 void daObjMovebox::Bgc_c::wrt_pos(cXyz const& param_0) {
@@ -186,7 +186,7 @@ void daObjMovebox::Bgc_c::wrt_pos(cXyz const& param_0) {
     }
 }
 
-dBgS_ObjLinChk daObjMovebox::Bgc_c::M_wall_work[23];
+DUSK_GAME_DATA dBgS_ObjLinChk daObjMovebox::Bgc_c::M_wall_work[23];
 
 
 void daObjMovebox::Bgc_c::wall_pos(daObjMovebox::Act_c const* i_actor,
@@ -409,11 +409,11 @@ void daObjMovebox::Act_c::prmX_init() {
     shape_angle.x = 0;
 }
 
-const char* const daObjMovebox::Act_c::M_arcname[8] = {
+DUSK_GAME_DATA const char* const daObjMovebox::Act_c::M_arcname[8] = {
     "Kkiba_00", "Osiblk", "H_Box20", "A_SMBlock", "P_Lv4blk", "P_Lv4blk2", "H_OsiHaka", "dummy4",
 };
 
-const dCcD_SrcCyl daObjMovebox::Act_c::M_cyl_src = {
+DUSK_GAME_DATA const dCcD_SrcCyl daObjMovebox::Act_c::M_cyl_src = {
     {
         0,
         {{0, 0, 0}, {0xD8FAFDBF, 0x11}, {0x78}},  // mObj
@@ -430,7 +430,7 @@ const dCcD_SrcCyl daObjMovebox::Act_c::M_cyl_src = {
     }
 };
 
-const daObjMovebox::Attr_c daObjMovebox::Act_c::M_attr[8] = {
+DUSK_GAME_DATA const daObjMovebox::Attr_c daObjMovebox::Act_c::M_attr[8] = {
     {
         // Timing
         6,      14,     10,     6,      14,     10,
diff --git a/src/d/actor/d_a_obj_nagaisu.cpp b/src/d/actor/d_a_obj_nagaisu.cpp
index 6341843ae4..7465f7c928 100644
--- a/src/d/actor/d_a_obj_nagaisu.cpp
+++ b/src/d/actor/d_a_obj_nagaisu.cpp
@@ -40,7 +40,7 @@ int daObjNagaisu_c::createHeap() {
     return 1;
 }
 
-const int daObjNagaisu_c::REMOVE_ISU_IDX[] = {
+DUSK_GAME_DATA const int daObjNagaisu_c::REMOVE_ISU_IDX[] = {
     6,
     7,
     11,
@@ -50,7 +50,7 @@ const int daObjNagaisu_c::REMOVE_ISU_IDX[] = {
     29,
 };
 
-const dCcD_SrcCyl daObjIsuChild_c::s_CcDCyl = {
+DUSK_GAME_DATA const dCcD_SrcCyl daObjIsuChild_c::s_CcDCyl = {
     {
         {0, {{0, 0, 0}, {0x400020, 0x11}, 0}},
         {dCcD_SE_NONE, 0, 0, 0, 0},
diff --git a/src/d/actor/d_a_obj_nameplate.cpp b/src/d/actor/d_a_obj_nameplate.cpp
index 56bb13f9ec..50ee106c38 100644
--- a/src/d/actor/d_a_obj_nameplate.cpp
+++ b/src/d/actor/d_a_obj_nameplate.cpp
@@ -13,7 +13,7 @@
 #include "SSystem/SComponent/c_math.h"
 
 // clang-format off
-daObjNameplate_c::M_attrs const daObjNameplate_c::M_attr = {
+DUSK_GAME_DATA daObjNameplate_c::M_attrs const daObjNameplate_c::M_attr = {
     50.0f,
     2500.0f,
     400.0f,
@@ -228,7 +228,7 @@ void daObjNameplate_c::messageProc() {
     }
 }
 
-char DUSK_CONST* DUSK_CONST daObjNameplate_c::l_arcName = "J_Hyosatu";
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daObjNameplate_c::l_arcName = "J_Hyosatu";
 
 int daObjNameplate_c::createHeap() {
     J3DModelData* modelData = (J3DModelData*)dComIfG_getObjectRes(l_arcName, "J_Hyousatu.bmd");
diff --git a/src/d/actor/d_a_obj_nougu.cpp b/src/d/actor/d_a_obj_nougu.cpp
index 2a81bb3033..e7aeaeb17f 100644
--- a/src/d/actor/d_a_obj_nougu.cpp
+++ b/src/d/actor/d_a_obj_nougu.cpp
@@ -9,7 +9,7 @@
 #include "d/actor/d_a_npc.h"
 #include "SSystem/SComponent/c_counter.h"
 
-dCcD_SrcSph daObj_Nougu_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daObj_Nougu_c::mCcDSph = {
     daNpcT_c::mCcDObjData,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}
@@ -18,7 +18,7 @@ dCcD_SrcSph daObj_Nougu_c::mCcDSph = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_resName = "Jagar4";
 
-const daObj_Nougu_HIOParam daObj_Nougu_Param_c::m = {
+DUSK_GAME_DATA const daObj_Nougu_HIOParam daObj_Nougu_Param_c::m = {
     0.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_obj_oiltubo.cpp b/src/d/actor/d_a_obj_oiltubo.cpp
index 553eed640c..31573e59b1 100644
--- a/src/d/actor/d_a_obj_oiltubo.cpp
+++ b/src/d/actor/d_a_obj_oiltubo.cpp
@@ -15,7 +15,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_bbmdFileName = "x_oiltubo_00b.bmd";
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_bbtkFileName = "x_oiltubo_00b.btk";
 
-dCcD_SrcCyl DUSK_CONST daObj_Oiltubo_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl DUSK_CONST daObj_Oiltubo_c::mCcDCyl = {
     daObj_Oiltubo_c::mCcDObjInfo,
     {
         {
@@ -41,7 +41,7 @@ int daObj_Oiltubo_c::create() {
     return phase_state;
 }
 
-const dCcD_SrcGObjInf daObj_Oiltubo_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daObj_Oiltubo_c::mCcDObjInfo = {
     {0x0, {{0x0, 0x0, 0x0}, {0xd8fbfdff, 0x1F}, 0x79}},  // mObj
     {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0},                  // mGObjAt
     {dCcD_SE_NONE, 0x2, 0x0, 0x0, 0x1},                  // mGObjTg
diff --git a/src/d/actor/d_a_obj_onsenTaru.cpp b/src/d/actor/d_a_obj_onsenTaru.cpp
index 62890f85b8..28175f54a0 100644
--- a/src/d/actor/d_a_obj_onsenTaru.cpp
+++ b/src/d/actor/d_a_obj_onsenTaru.cpp
@@ -20,14 +20,14 @@ daOnsTaru_HIO_c::daOnsTaru_HIO_c() {
 
 static daOnsTaru_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daOnsTaru_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daOnsTaru_c::mCcDObjInfo = {
     {0, {{8, 0, 0x1F}, {0xD8FADDAF, 0x1F}, {0x79}}},
     {dCcD_SE_NONE, 0, 1, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 2},
     {0},
 };
 
-dCcD_SrcCyl daOnsTaru_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daOnsTaru_c::mCcDCyl = {
     daOnsTaru_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_ornament_cloth.cpp b/src/d/actor/d_a_obj_ornament_cloth.cpp
index f5931ebd43..f1181b2d0a 100644
--- a/src/d/actor/d_a_obj_ornament_cloth.cpp
+++ b/src/d/actor/d_a_obj_ornament_cloth.cpp
@@ -58,7 +58,7 @@ public:
 };
 #endif
 
-daObjOnCloth_Attr_c const daObjOnCloth_c::M_attr = {
+DUSK_GAME_DATA daObjOnCloth_Attr_c const daObjOnCloth_c::M_attr = {
     8.0f,
     -40.0f,
     0.3f,
diff --git a/src/d/actor/d_a_obj_picture.cpp b/src/d/actor/d_a_obj_picture.cpp
index 3cf8765962..67b89627d2 100644
--- a/src/d/actor/d_a_obj_picture.cpp
+++ b/src/d/actor/d_a_obj_picture.cpp
@@ -517,7 +517,7 @@ static int daObjPicture_draw(daObjPicture_c* i_this) {
 #if DEBUG
 const
 #endif
-dCcD_SrcCps daObjPicture_c::s_CcDCps = {
+DUSK_GAME_DATA dCcD_SrcCps daObjPicture_c::s_CcDCps = {
     {
         {0x0, {{0x0, 0x0, 0x0}, {0x20A0, 0x11}, 0x0}}, // mObj
         {dCcD_SE_SWORD, 0x0, 0x0, 0x0, 0x0}, // mGObjAt
@@ -532,7 +532,7 @@ dCcD_SrcCps daObjPicture_c::s_CcDCps = {
 #if DEBUG
 const
 #endif
-dCcD_SrcCyl daObjPicture_c::s_CcDCyl_pic_at = {
+DUSK_GAME_DATA dCcD_SrcCyl daObjPicture_c::s_CcDCyl_pic_at = {
     {
         {0x0, {{0x400, 0x1, 0x11}, {0x0, 0x11}, 0x79}},  // mObj
         {dCcD_SE_NONE, 0x0, 0x0, 0x0, 0x0},              // mGObjAt
diff --git a/src/d/actor/d_a_obj_pleaf.cpp b/src/d/actor/d_a_obj_pleaf.cpp
index 3510a08111..afc230dade 100644
--- a/src/d/actor/d_a_obj_pleaf.cpp
+++ b/src/d/actor/d_a_obj_pleaf.cpp
@@ -9,7 +9,7 @@
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_resName = "J_Hatake";
 
-daObj_Pleaf_HIOParam const daObj_Pleaf_Param_c::m = {0, -3.0f, 1.0f, 900.0f};
+DUSK_GAME_DATA daObj_Pleaf_HIOParam const daObj_Pleaf_Param_c::m = {0, -3.0f, 1.0f, 900.0f};
 
 static OBJ_PLEAF_HIO_CLASS l_HIO;
 
diff --git a/src/d/actor/d_a_obj_pumpkin.cpp b/src/d/actor/d_a_obj_pumpkin.cpp
index 0ad30174ae..c5c3d01504 100644
--- a/src/d/actor/d_a_obj_pumpkin.cpp
+++ b/src/d/actor/d_a_obj_pumpkin.cpp
@@ -17,7 +17,7 @@
 #include <cstring>
 #endif
 
-const daObj_Pumpkin_HIOParam daObj_Pumpkin_Param_c::m = {
+DUSK_GAME_DATA const daObj_Pumpkin_HIOParam daObj_Pumpkin_Param_c::m = {
     0.0f,
     -5.0f,
     1.4f,
diff --git a/src/d/actor/d_a_obj_rotTrap.cpp b/src/d/actor/d_a_obj_rotTrap.cpp
index 1c8a711b49..d298db61be 100644
--- a/src/d/actor/d_a_obj_rotTrap.cpp
+++ b/src/d/actor/d_a_obj_rotTrap.cpp
@@ -19,14 +19,14 @@ daRotTrap_HIO_c::daRotTrap_HIO_c() {
 
 static daRotTrap_HIO_c l_HIO;
 
-dCcD_SrcGObjInf const daRotTrap_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daRotTrap_c::mCcDObjInfo = {
     {0, {{AT_TYPE_800, 0x1, 0x1F}, {0x0, 0x0}, {0}}},
     {dCcD_SE_SWORD, 0, 1, 0, 0},
     {dCcD_SE_STONE, 0, 0, 0, 0},
     {0}
 };
 
-dCcD_SrcCyl daRotTrap_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daRotTrap_c::mCcDCyl = {
     mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f}
diff --git a/src/d/actor/d_a_obj_sakuita.cpp b/src/d/actor/d_a_obj_sakuita.cpp
index f2f8d14348..8092f2d853 100644
--- a/src/d/actor/d_a_obj_sakuita.cpp
+++ b/src/d/actor/d_a_obj_sakuita.cpp
@@ -51,7 +51,7 @@ void daObjSakuita_Hio_c::dt() {
 static daObjSakuita_Hio_c M_hio;
 #endif
 
-daObjSakuita_Attr_c const daObjSakuita_c::M_attr = {
+DUSK_GAME_DATA daObjSakuita_Attr_c const daObjSakuita_c::M_attr = {
     20.0f, 12.0f, 70.0f, -50.0f, 0.8f, 0.5f, -6.0f, 900.0f, 20000.0f, 100.0f, 0x1400, 0x14,
 };
 
diff --git a/src/d/actor/d_a_obj_sakuita_rope.cpp b/src/d/actor/d_a_obj_sakuita_rope.cpp
index d0328440c0..40bfd7cfcf 100644
--- a/src/d/actor/d_a_obj_sakuita_rope.cpp
+++ b/src/d/actor/d_a_obj_sakuita_rope.cpp
@@ -61,7 +61,7 @@ int Sakuita_c::setModelData(J3DModelData* i_modelData) {
     return 1;
 }
 
-daObjItaRope_Attr_c const daObjItaRope_c::M_attr = {
+DUSK_GAME_DATA daObjItaRope_Attr_c const daObjItaRope_c::M_attr = {
     -5.0f, 0.2f, 0.5f, 0.8f, 0,
 };
 
diff --git a/src/d/actor/d_a_obj_scannon.cpp b/src/d/actor/d_a_obj_scannon.cpp
index 7e93898a1d..ceb4399463 100644
--- a/src/d/actor/d_a_obj_scannon.cpp
+++ b/src/d/actor/d_a_obj_scannon.cpp
@@ -436,7 +436,7 @@ void daSCannon_c::exeModeOrderEvt() {
     eventInfo.onCondition(dEvtCnd_CANDEMO_e);
 }
 
-void (daSCannon_c::*DUSK_CONST daSCannon_c::s_exeProc[])() = {
+DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST daSCannon_c::s_exeProc[])() = {
     &daSCannon_c::exeModeWait,
     &daSCannon_c::exeModeOrderEvt,
     &daSCannon_c::exeModeActionEvt,
@@ -465,22 +465,22 @@ DUSK_CONSTEXPR char DUSK_CONST* CUT_TYPE_TABLE_FIRE_SECOND[4] = {
     "FINISH",
 };
 
-void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_WarpEnd[][2])() = {
+DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_WarpEnd[][2])() = {
     {&daSCannon_c::demoInitWarpEndWait, &daSCannon_c::demoExeWarpEndWait},
     {&daSCannon_c::demoInitWarpEndMove, &daSCannon_c::demoExeWarpEndMove},
 };
 
-void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_FireTks[][2])() = {
+DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_FireTks[][2])() = {
     {NULL, NULL},
     {NULL, NULL},
     {NULL, NULL},
 };
 
-void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_FireFirst[][2])() = {
+DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_FireFirst[][2])() = {
     {&daSCannon_c::demoInitLinkIn, &daSCannon_c::demoExeLinkIn},
 };
 
-void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_FireSecond[][2])() = {
+DUSK_GAME_DATA void (daSCannon_c::*DUSK_CONST daSCannon_c::s_demoExeProc_FireSecond[][2])() = {
     {&daSCannon_c::demoInitSet, &daSCannon_c::demoExeSet},
     {&daSCannon_c::demoInitMove, &daSCannon_c::demoExeMove},
     {&daSCannon_c::demoInitFire, &daSCannon_c::demoExeFire},
@@ -525,7 +525,7 @@ void daSCannon_c::exeModeActionEvt() {
 
 void daSCannon_c::exeModeEnd() {}
 
-const daSCannon_c::demoTable_s daSCannon_c::s_demoTable[] = {
+DUSK_GAME_DATA const daSCannon_c::demoTable_s daSCannon_c::s_demoTable[] = {
     {s_demoExeProc_WarpEnd, CUT_TYPE_TABLE_WARP_END, 2},
     {s_demoExeProc_FireFirst, CUT_TYPE_TABLE_FIRE_FIRST, 1},
     {s_demoExeProc_FireTks, CUT_TYPE_TABLE_FIRE_TKS, 3},
diff --git a/src/d/actor/d_a_obj_scannon_crs.cpp b/src/d/actor/d_a_obj_scannon_crs.cpp
index e422fd9a2c..033cf92dd4 100644
--- a/src/d/actor/d_a_obj_scannon_crs.cpp
+++ b/src/d/actor/d_a_obj_scannon_crs.cpp
@@ -267,7 +267,7 @@ void daSCannonCrs_c::exeModeWarpEvt(daMidna_c* i_midna_p) {
 
 void daSCannonCrs_c::exeModeEnd(daMidna_c* i_midna_p) {}
 
-void (daSCannonCrs_c::*daSCannonCrs_c::s_exeProc[])(daMidna_c*) = {
+DUSK_GAME_DATA void (daSCannonCrs_c::*daSCannonCrs_c::s_exeProc[])(daMidna_c*) = {
     &daSCannonCrs_c::exeModeWait,
     &daSCannonCrs_c::exeModePreWait,
     &daSCannonCrs_c::exeModeOrderEvt,
diff --git a/src/d/actor/d_a_obj_scannon_ten.cpp b/src/d/actor/d_a_obj_scannon_ten.cpp
index 63f8d370b2..4794b783e2 100644
--- a/src/d/actor/d_a_obj_scannon_ten.cpp
+++ b/src/d/actor/d_a_obj_scannon_ten.cpp
@@ -148,14 +148,14 @@ int daObjSCannonTen_c::execute() {
     return 1;
 }
 
-const daObjSCannonTen_c::ExeProc daObjSCannonTen_c::s_exeProc[] = {
+DUSK_GAME_DATA const daObjSCannonTen_c::ExeProc daObjSCannonTen_c::s_exeProc[] = {
     &daObjSCannonTen_c::exeModeWait,
     &daObjSCannonTen_c::exeModeOrderEvt,
     &daObjSCannonTen_c::exeModeActionEvt,
     &daObjSCannonTen_c::exeModeEnd,
 };
 
-const daObjSCannonTen_c::ExeProc daObjSCannonTen_c::s_demoExeProc[][2] = {
+DUSK_GAME_DATA const daObjSCannonTen_c::ExeProc daObjSCannonTen_c::s_demoExeProc[][2] = {
     {&daObjSCannonTen_c::demoInitLinkIn, &daObjSCannonTen_c::demoExeLinkIn},
     {&daObjSCannonTen_c::demoInitSet, &daObjSCannonTen_c::demoExeSet},
     {&daObjSCannonTen_c::demoInitMove, &daObjSCannonTen_c::demoExeMove},
diff --git a/src/d/actor/d_a_obj_sekidoor.cpp b/src/d/actor/d_a_obj_sekidoor.cpp
index 3431397a9f..52784fbc4e 100644
--- a/src/d/actor/d_a_obj_sekidoor.cpp
+++ b/src/d/actor/d_a_obj_sekidoor.cpp
@@ -22,7 +22,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNameList[2] = {"", "SekiDoor"};
 
 static OBJ_SEKIDOOR_HIO_CLASS l_HIO;
 
-const daObj_SekiDoor_HIOParam daObj_SekiDoor_Param_c::m = {0};
+DUSK_GAME_DATA const daObj_SekiDoor_HIOParam daObj_SekiDoor_Param_c::m = {0};
 
 static const f32 reference_posy = 460.0f;
 
diff --git a/src/d/actor/d_a_obj_sekizo.cpp b/src/d/actor/d_a_obj_sekizo.cpp
index bf464b3fcc..9c1fe8abb2 100644
--- a/src/d/actor/d_a_obj_sekizo.cpp
+++ b/src/d/actor/d_a_obj_sekizo.cpp
@@ -23,7 +23,7 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resNameList[2] = {"", "Sekizo"};
 
 static u8 lit_3800[12];
 
-daObj_Sekizo_HIOParam const daObj_Sekizo_Param_c::m = {};
+DUSK_GAME_DATA daObj_Sekizo_HIOParam const daObj_Sekizo_Param_c::m = {};
 
 static OBJ_SEKIZO_HIO_CLASS l_HIO;
 
diff --git a/src/d/actor/d_a_obj_sekizoa.cpp b/src/d/actor/d_a_obj_sekizoa.cpp
index 7f34ca6fd1..fece4d9773 100644
--- a/src/d/actor/d_a_obj_sekizoa.cpp
+++ b/src/d/actor/d_a_obj_sekizoa.cpp
@@ -8,11 +8,12 @@
 #include "d/actor/d_a_tag_kmsg.h"
 #include <types.h>
 #include <cstring>
-
-#include "dusk/string.hpp"
 #include "f_op/f_op_actor_mng.h"
 #include "f_op/f_op_msg.h"
 
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static DUSK_CONSTEXPR daNpc_GetParam1 l_bmdData[9] = {
     {36, 1}, {36, 1}, {35, 1}, {37, 1}, {38, 1}, {3, 2}, {3, 2}, {4, 2}, {5, 2},
@@ -98,11 +99,11 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {21, -1, 1}, {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0},  {22, 4, 1},  {-1, 0, 0},  {-1, 0, 0},
     {-1, 0, 0},  {23, 0, 0},  {-1, 0, 0},  {-1, 0, 0},  {-1, 0, 0}};
 
-char DUSK_CONST* DUSK_CONST daObj_Sekizoa_c::mCutNameList[9] = {
+DUSK_GAME_DATA char DUSK_CONST* DUSK_CONST daObj_Sekizoa_c::mCutNameList[9] = {
     "", "START", "START", "TURN", "JUMP", "GOAL", "EXIT", "FREE", "EXTINCTION",
 };
 
-daObj_Sekizoa_c::cutFunc DUSK_CONST daObj_Sekizoa_c::mCutList[9] = {
+DUSK_GAME_DATA daObj_Sekizoa_c::cutFunc DUSK_CONST daObj_Sekizoa_c::mCutList[9] = {
     NULL,
     &daObj_Sekizoa_c::cutStart,
     &daObj_Sekizoa_c::cutStart,
@@ -118,7 +119,7 @@ static DUSK_CONSTEXPR cXyz l_srcPosR(-600.0f, 1000.0f, 1800.0f);
 
 static DUSK_CONSTEXPR cXyz l_srcPosL(600.0f, 1000.0f, 1800.0f);
 
-daObj_Sekizoa_HIOParam const daObj_Sekizoa_Param_c::m = {
+DUSK_GAME_DATA daObj_Sekizoa_HIOParam const daObj_Sekizoa_Param_c::m = {
     600.0f, -10.0f, 1.0f,   1100.0f, 255.0f,   550.0f, 100.0f, 70.0f, 0.0f, 0.0f, 30.0f,
     0.0f,   30.0f,  -30.0f, 45.0f,   -45.0f,   0.6f,   8.0f,   0x3,   0x6,  0x5,  0x6,
     0.0f,   0.0f,   0.0f,   0.0f,    0x3C0008, 0.0f,   0.0f,   4.0f,  0.0f, 0.0f, 0.0f,
diff --git a/src/d/actor/d_a_obj_shield.cpp b/src/d/actor/d_a_obj_shield.cpp
index 3941011043..5cc63c9a89 100644
--- a/src/d/actor/d_a_obj_shield.cpp
+++ b/src/d/actor/d_a_obj_shield.cpp
@@ -109,6 +109,7 @@ int daItemShield_c::__CreateHeap() {
 int daItemShield_c::create() {
     fopAcM_ct(this, daItemShield_c);
     m_itemNo = dItemNo_WOOD_SHIELD_e;
+    DUSK_ITEM_CHECK_PREVIEW("ordon_shield", m_itemNo, this);
     if (fopAcM_isSwitch(this, getSwBit2())) {
         OS_REPORT("木の盾：もう取ったので出ません\n");
         return cPhs_ERROR_e;
@@ -240,8 +241,9 @@ int daItemShield_c::initActionOrderGetDemo() {
     daItemBase_c::hide();
     fopAcM_orderItemEvent(this, 0, 0);
     eventInfo.onCondition(dEvtCnd_CANGETITEM_e);
-    mItemId =
-        fopAcM_createItemForTrBoxDemo(&current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this), 0, 0);
+    mItemId = fopAcM_createItemForTrBoxDemo(&current.pos,
+        DUSK_ITEM_CHECK_EXPR("ordon_shield", dItemNo_WOOD_SHIELD_e, this), -1,
+        fopAcM_GetRoomNo(this), 0, 0 DUSK_GIVE_TAG("ordon_shield"));
     JUT_ASSERT(682, mItemId != fpcM_ERROR_PROCESS_ID_e)
     setStatus(STATUS_ORDERGETDEMO);
     return 1;
diff --git a/src/d/actor/d_a_obj_smallkey.cpp b/src/d/actor/d_a_obj_smallkey.cpp
index 9bf8face57..1fd6025ce6 100644
--- a/src/d/actor/d_a_obj_smallkey.cpp
+++ b/src/d/actor/d_a_obj_smallkey.cpp
@@ -1,6 +1,6 @@
 /**
  * @file d_a_obj_smallkey.cpp
- * 
+ *
 */
 
 #include "d/dolzel_rel.h" // IWYU pragma: keep
@@ -119,9 +119,9 @@ int daKey_c::Create() {
     mCcCyl.SetStts(&mCcStts);
     mCcCyl.SetCoHitCallback(keyGetCoCallBack);
     mCcCyl.SetTgHitCallback(keyGetTgCallBack);
-    mCcCyl.SetR(dItem_data::getR(m_itemNo));
-    mCcCyl.SetH(dItem_data::getH(m_itemNo));
-    
+    mCcCyl.SetR(DUSK_IF_ELSE(getCollisionR(), dItem_data::getR(m_itemNo)));
+    mCcCyl.SetH(DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo)));
+
     fopAcM_SetCullSize(this, fopAc_CULLSPHERE_0_e);
 
     if (getSwNo() == 0xFF) {
@@ -155,7 +155,21 @@ int daKey_c::create() {
         mIsPrmInit = TRUE;
     }
 
+#if TARGET_PC
+    mItemGiveTag = dusk::mods::item_give_tag_freestanding(getSaveBitNo());
+    const auto [item, displayItem, _] =
+        dusk::mods::item_check_resolve(mItemGiveTag, dItemNo_SMALL_KEY_e, this);
+    m_itemNo = item;
+    if (m_itemNo == dItemNo_NONE_e) {
+        // Keep the pickup visible until the empty check is collected.
+        m_itemNo = dItemNo_SMALL_KEY_e;
+        setDisplayItemNo(dItemNo_NONE_e);
+    } else {
+        setDisplayItemNo(displayItem);
+    }
+#else
     m_itemNo = dItemNo_SMALL_KEY_e;
+#endif
 
     if (strcmp(dComIfGp_getStartStageName(), "F_SP118") == 0) {
         OS_REPORT(" SMKEY 0\n");
@@ -170,9 +184,21 @@ int daKey_c::create() {
         return cPhs_ERROR_e;
     }
 
+#if TARGET_PC
+    const u8 displayItemNo = getDisplayItemNo();
+    int phase_state = dComIfG_resLoad(&mPhase, dItem_fieldModelArc(displayItemNo));
+#else
     int phase_state = dComIfG_resLoad(&mPhase, dItem_data::getFieldArc(m_itemNo));
+#endif
     if (phase_state == cPhs_COMPLEATE_e) {
+#if TARGET_PC
+        const bool useModelFallback = dItem_data::getFieldArc(displayItemNo) == NULL;
+        if (!fopAcM_entrySolidHeap(
+                this, useModelFallback ? CheckItemCreateHeap : CheckFieldItemCreateHeap, 0x4000))
+        {
+#else
         if (!fopAcM_entrySolidHeap(this, CheckFieldItemCreateHeap, 0x840)) {
+#endif
             return cPhs_ERROR_e;
         }
 
@@ -317,10 +343,26 @@ int daKey_c::initActionOrderGetDemo() {
     hide();
     effectStop();
 
+#if TARGET_PC
+    const auto itemCheck =
+        dusk::mods::item_check_commit(mItemGiveTag, dItemNo_SMALL_KEY_e, this);
+    m_itemNo = itemCheck.itemNo;
+    if (m_itemNo == dItemNo_NONE_e) {
+        dusk::mods::item_check_complete(itemCheck, this);
+        dComIfGs_onTbox(getSaveBitNo());
+        dTres_c::offStatus(getSaveBitNo(), 1);
+        dComIfGp_event_reset();
+        fopAcM_delete(this);
+        return 1;
+    }
+#endif
+
     fopAcM_orderItemEvent(this, 0, 0);
     eventInfo.onCondition(8);
 
-    mItemId = fopAcM_createItemForTrBoxDemo(&current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this), NULL, NULL);
+    mItemId = fopAcM_createItemForTrBoxDemo(
+        &current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this), NULL,
+        NULL IF_DUSK_ARG(itemCheck.tag));
     JUT_ASSERT(699, mItemId != fpcM_ERROR_PROCESS_ID_e);
 
     setStatus(STATUS_ORDER_GET_DEMO_e);
@@ -387,8 +429,8 @@ int daKey_c::actionInitBoomerangCarry() {
     mCcCyl.OnTgSPrmBit(1);
     mCcCyl.OnCoSPrmBit(1);
 
-    u8 height = dItem_data::getH(m_itemNo);
-    u8 radius = dItem_data::getR(m_itemNo);
+    u8 height = DUSK_IF_ELSE(getCollisionH(), dItem_data::getH(m_itemNo));
+    u8 radius = DUSK_IF_ELSE(getCollisionR(), dItem_data::getR(m_itemNo));
 
     mCcCyl.SetR(4.0f * radius);
     mCcCyl.SetH(4.0f * height);
@@ -527,7 +569,11 @@ int daKey_c::draw() {
 
 int daKey_c::_delete() {
     effectStop();
+#if TARGET_PC
+    DeleteBase(dItem_fieldModelArc(getDisplayItemNo()));
+#else
     DeleteBase(dItem_data::getFieldArc(m_itemNo));
+#endif
     return 1;
 }
 
diff --git a/src/d/actor/d_a_obj_smtile.cpp b/src/d/actor/d_a_obj_smtile.cpp
index 7b43dfe031..3a2346fde9 100644
--- a/src/d/actor/d_a_obj_smtile.cpp
+++ b/src/d/actor/d_a_obj_smtile.cpp
@@ -29,7 +29,7 @@ static s8 l_tileMoveData[21][4] = {
 
 static OBJ_SMTILE_HIO_CLASS l_HIO;
 
-daObj_SMTile_HIOParam const daObj_SMTile_Param_c::m = {600.0f, 20.0f};
+DUSK_GAME_DATA daObj_SMTile_HIOParam const daObj_SMTile_Param_c::m = {600.0f, 20.0f};
 
 #if DEBUG
 daObj_SMTile_HIO_c::daObj_SMTile_HIO_c() {
diff --git a/src/d/actor/d_a_obj_ss_drink.cpp b/src/d/actor/d_a_obj_ss_drink.cpp
index 7d3f02f6d3..6a44f3d786 100644
--- a/src/d/actor/d_a_obj_ss_drink.cpp
+++ b/src/d/actor/d_a_obj_ss_drink.cpp
@@ -15,14 +15,14 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_resFileName = "Obj_btl";
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_bmdName = "al_bottle.bmd";
 
-dCcD_SrcGObjInf const daObj_SSDrink_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daObj_SSDrink_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0, 0}, {0x79}}},
     {0, 0, 0, 0, {0}},
     {0, 0, 0, 0, {0}},
     {{0}},
 };
 
-dCcD_SrcCyl DUSK_CONST daObj_SSDrink_c::mCcDCyl = {mCcDObjInfo, {}};
+DUSK_GAME_DATA dCcD_SrcCyl DUSK_CONST daObj_SSDrink_c::mCcDCyl = {mCcDObjInfo, {}};
 
 daObj_SSDrink_c::~daObj_SSDrink_c() {
     dComIfG_resDelete(&mPhase, getResName());
diff --git a/src/d/actor/d_a_obj_ss_item.cpp b/src/d/actor/d_a_obj_ss_item.cpp
index 7a9664ae1f..102223c21b 100644
--- a/src/d/actor/d_a_obj_ss_item.cpp
+++ b/src/d/actor/d_a_obj_ss_item.cpp
@@ -25,14 +25,14 @@ static DUSK_CONSTEXPR char DUSK_CONST* l_bmdFileName[] = {
     "pumpkin.bmd",
 };
 
-dCcD_SrcGObjInf const daObj_SSItem_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daObj_SSItem_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0, 0}, {0x79}}},
     {0, 0, 0, 0, {0}},
     {0, 0, 0, 0, {0}},
     {{0}},
 };
 
-dCcD_SrcCyl DUSK_CONST daObj_SSItem_c::mCcDCyl = {mCcDObjInfo, {}};
+DUSK_GAME_DATA dCcD_SrcCyl DUSK_CONST daObj_SSItem_c::mCcDCyl = {mCcDObjInfo, {}};
 
 daObj_SSItem_c::~daObj_SSItem_c() {
     dComIfG_resDelete(&mPhase, getResName());
diff --git a/src/d/actor/d_a_obj_stairBlock.cpp b/src/d/actor/d_a_obj_stairBlock.cpp
index d3f07e7992..1ea8fb75dd 100644
--- a/src/d/actor/d_a_obj_stairBlock.cpp
+++ b/src/d/actor/d_a_obj_stairBlock.cpp
@@ -22,7 +22,7 @@ void daStairBlock_c::setBaseMtx() {
     }
 }
 
-const dCcD_SrcGObjInf daStairBlock_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daStairBlock_c::mCcDObjInfo = {
     {0, {0, 0, 0, {0x0, 0x0}, {0x19}}},
     {dCcD_SE_NONE, 0, 0, 0, 0x0},
     {dCcD_SE_NONE, 0, 0, 0, 0x0},
@@ -166,7 +166,7 @@ static int daStairBlock_Create(fopAc_ac_c* i_this) {
     return static_cast<daStairBlock_c*>(i_this)->create();
 }
 
-dCcD_SrcSph daStairBlock_c::mCcDSph = {daStairBlock_c::mCcDObjInfo, {{{0.0f, 0.0f, 0.0f}, 4.0f}}};
+DUSK_GAME_DATA dCcD_SrcSph daStairBlock_c::mCcDSph = {daStairBlock_c::mCcDObjInfo, {{{0.0f, 0.0f, 0.0f}, 4.0f}}};
 
 static DUSK_CONST actor_method_class l_daStairBlock_Method = {
     (process_method_func)daStairBlock_Create,  (process_method_func)daStairBlock_Delete,
diff --git a/src/d/actor/d_a_obj_stick.cpp b/src/d/actor/d_a_obj_stick.cpp
index 71f69e58a8..95bb4d95c5 100644
--- a/src/d/actor/d_a_obj_stick.cpp
+++ b/src/d/actor/d_a_obj_stick.cpp
@@ -11,11 +11,11 @@
 #include "m_Do/m_Do_ext.h"
 #include "d/actor/d_a_npc.h"
 
-const daObj_Stick_HIOParam daObj_Stick_Param_c::m = {
+DUSK_GAME_DATA const daObj_Stick_HIOParam daObj_Stick_Param_c::m = {
     0.0f, -3.0f, 1.0f, 100.0f
 };
 
-dCcD_SrcSph daObj_Stick_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daObj_Stick_c::mCcDSph = {
     daNpcT_c::mCcDObjData,                                               // mObjInf
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f}  // mSph
diff --git a/src/d/actor/d_a_obj_sword.cpp b/src/d/actor/d_a_obj_sword.cpp
index b346c4232e..f87d078512 100644
--- a/src/d/actor/d_a_obj_sword.cpp
+++ b/src/d/actor/d_a_obj_sword.cpp
@@ -37,6 +37,7 @@ int daObjSword_c::Create() {
 cPhs_Step daObjSword_c::create() {
     fopAcM_ct(this, daObjSword_c);
     m_itemNo = 0x28;
+    DUSK_ITEM_CHECK_PREVIEW("ordon_sword", m_itemNo, this);
     if (fopAcM_isItem(this, getItemBit())) {
         return cPhs_ERROR_e;
     }
@@ -71,8 +72,9 @@ int daObjSword_c::initActionOrderGetDemo() {
     hide();
     fopAcM_orderItemEvent(this, 0, 0);
     eventInfo.onCondition(8);
-    mProcID = fopAcM_createItemForTrBoxDemo(&current.pos, m_itemNo, -1, fopAcM_GetRoomNo(this),
-                                            NULL, NULL);
+    mProcID =
+        fopAcM_createItemForTrBoxDemo(&current.pos, DUSK_ITEM_CHECK_EXPR("ordon_sword", 0x28, this),
+            -1, fopAcM_GetRoomNo(this), NULL, NULL DUSK_GIVE_TAG("ordon_sword"));
     setStatus(1);
     return 1;
 }
diff --git a/src/d/actor/d_a_obj_swpush.cpp b/src/d/actor/d_a_obj_swpush.cpp
index 5cdf0f4372..c901a4ef98 100644
--- a/src/d/actor/d_a_obj_swpush.cpp
+++ b/src/d/actor/d_a_obj_swpush.cpp
@@ -54,11 +54,11 @@ BOOL daObjSwpush::Act_c::solidHeapCB(fopAc_ac_c* a_this) {
     return static_cast<daObjSwpush::Act_c*>(a_this)->create_heap();
 }
 
-s16 const daObjSwpush::Act_c::M_bmd[3] = {BMDR_KBOTA_00, BMDR_S_LV3BOTA, BMDR_S_LV6BOTA};
+DUSK_GAME_DATA s16 const daObjSwpush::Act_c::M_bmd[3] = {BMDR_KBOTA_00, BMDR_S_LV3BOTA, BMDR_S_LV6BOTA};
 
-s16 const daObjSwpush::Act_c::M_dzb[3] = {DZB_KBOTA_00, DZB_KBOTA2_00, DZB_KBOTA3_00};
+DUSK_GAME_DATA s16 const daObjSwpush::Act_c::M_dzb[3] = {DZB_KBOTA_00, DZB_KBOTA2_00, DZB_KBOTA3_00};
 
-DUSK_CONST char* daObjSwpush::Act_c::M_arcname[3] = {
+DUSK_GAME_DATA DUSK_CONST char* daObjSwpush::Act_c::M_arcname[3] = {
     "Kbota_00",
     "S_lv3bota",
     "S_lv6bota",
@@ -117,9 +117,9 @@ cPhs_Step daObjSwpush::Act_c::create_res_load() {
     return cPhs_COMPLEATE_e;
 }
 
-u32 const daObjSwpush::Act_c::M_heap_size[3] = {0x1000, 0x1000, 0x1000};
+DUSK_GAME_DATA u32 const daObjSwpush::Act_c::M_heap_size[3] = {0x1000, 0x1000, 0x1000};
 
-daObjSwpush::Hio_c::Attr_c const daObjSwpush::Act_c::M_attr[5] = {
+DUSK_GAME_DATA daObjSwpush::Hio_c::Attr_c const daObjSwpush::Act_c::M_attr[5] = {
     {
         (AttrFlag_e)(FLAG_STAY_PRESSED | FLAG_OBEY_SAVE),
         1.0f,
@@ -198,7 +198,7 @@ daObjSwpush::Hio_c::Attr_c const daObjSwpush::Act_c::M_attr[5] = {
 
 };
 
-u8 const daObjSwpush::Act_c::M_op_vtx[4] = {0x0D, 0x0B, 0x0A, 0x0C};
+DUSK_GAME_DATA u8 const daObjSwpush::Act_c::M_op_vtx[4] = {0x0D, 0x0B, 0x0A, 0x0C};
 
 cPhs_Step daObjSwpush::Act_c::Mthd_Create() {
     fopAcM_ct(this, daObjSwpush::Act_c);
diff --git a/src/d/actor/d_a_obj_swpush2.cpp b/src/d/actor/d_a_obj_swpush2.cpp
index bf13e741c0..10dce4e85b 100644
--- a/src/d/actor/d_a_obj_swpush2.cpp
+++ b/src/d/actor/d_a_obj_swpush2.cpp
@@ -71,9 +71,9 @@ int daObjSwpush2::Act_c::solidHeapCB(fopAc_ac_c* i_this) {
     return ((daObjSwpush2::Act_c*)i_this)->create_heap();
 }
 
-const char daObjSwpush2::Act_c::M_arcname[9] = "K_swmn00";
+DUSK_GAME_DATA const char daObjSwpush2::Act_c::M_arcname[9] = "K_swmn00";
 
-const daObjSwpush2::Attr_c daObjSwpush2::Act_c::M_attr[4] = {
+DUSK_GAME_DATA const daObjSwpush2::Attr_c daObjSwpush2::Act_c::M_attr[4] = {
     {
         0x2000,
         daObjSwpush2::AttrFlag_e(AttrFlag_UNK_0x1_e | AttrFlag_UNK_0x2_e),
diff --git a/src/d/actor/d_a_obj_syRock.cpp b/src/d/actor/d_a_obj_syRock.cpp
index 5cabf2f30a..44d8c42741 100644
--- a/src/d/actor/d_a_obj_syRock.cpp
+++ b/src/d/actor/d_a_obj_syRock.cpp
@@ -36,7 +36,7 @@ public:
 
 static daSyRock_HIO_c l_HIO;
 
-dCcD_SrcCyl daSyRock_c::mCcDCyl = {mCcDObjInfo};
+DUSK_GAME_DATA dCcD_SrcCyl daSyRock_c::mCcDCyl = {mCcDObjInfo};
 
 daSyRock_HIO_c::daSyRock_HIO_c() {
     mShakeAmplitude = 450.0f;
@@ -151,7 +151,7 @@ int daSyRock_c::CreateHeap() {
     return 1;
 }
 
-dCcD_SrcGObjInf const daSyRock_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daSyRock_c::mCcDObjInfo = {
     {0x0, {{AT_TYPE_BOMB, 0x1, 0x1F}, {AT_TYPE_IRON_BALL | AT_TYPE_BOMB, 0x11}, 0x79}},    // mObj
     {dCcD_SE_SWORD, 0x0, 0x1, dCcD_MTRL_NONE, 0x0},      // mGObjAt
     {dCcD_SE_STONE, 0x0, 0x0, dCcD_MTRL_NONE, 0x2},      // mGObjTg
diff --git a/src/d/actor/d_a_obj_taFence.cpp b/src/d/actor/d_a_obj_taFence.cpp
index 4958e8a52f..d298641a4f 100644
--- a/src/d/actor/d_a_obj_taFence.cpp
+++ b/src/d/actor/d_a_obj_taFence.cpp
@@ -106,14 +106,14 @@ int daTaFence_c::CreateHeap() {
     return 1;
 }
 
-const dCcD_SrcGObjInf daTaFence_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daTaFence_c::mCcDObjInfo = {
     {0, {{0x0, 0x0, 0x0}, {0x400032, 0x11}, {0x0}}},
     {dCcD_SE_SWORD, 0, 0, 0, 0},
     {dCcD_SE_STONE, 0, 0, 0, 0},
     {0},
 };
 
-dCcD_SrcCyl daTaFence_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daTaFence_c::mCcDCyl = {
     daTaFence_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_tks.cpp b/src/d/actor/d_a_obj_tks.cpp
index 505a1bd09c..df6a596804 100644
--- a/src/d/actor/d_a_obj_tks.cpp
+++ b/src/d/actor/d_a_obj_tks.cpp
@@ -59,7 +59,7 @@ daObjTks_c::~daObjTks_c() {
 #endif
 }
 
-const daObjTks_HIOParam daObjTks_Param_c::m = {
+DUSK_GAME_DATA const daObjTks_HIOParam daObjTks_Param_c::m = {
     90.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_obj_togeTrap.cpp b/src/d/actor/d_a_obj_togeTrap.cpp
index 2ea6767dfc..479bdece95 100644
--- a/src/d/actor/d_a_obj_togeTrap.cpp
+++ b/src/d/actor/d_a_obj_togeTrap.cpp
@@ -22,14 +22,14 @@ daTogeTrap_HIO_c::daTogeTrap_HIO_c() {
 
 static daTogeTrap_HIO_c l_HIO;
 
-const dCcD_SrcGObjInf daTogeTrap_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daTogeTrap_c::mCcDObjInfo = {
     {0, {{2, 1, 0x1D}, {0x480028, 0x11}, {0}}},
     {dCcD_SE_SWORD, 0, 0, 0, 0},
     {dCcD_SE_STONE, 0, 0, 0, 0},
     {0},
 };
 
-dCcD_SrcCyl daTogeTrap_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daTogeTrap_c::mCcDCyl = {
     daTogeTrap_c::mCcDObjInfo,
     {
         {
diff --git a/src/d/actor/d_a_obj_waterPillar.cpp b/src/d/actor/d_a_obj_waterPillar.cpp
index 522b82a634..1e65f3adf9 100644
--- a/src/d/actor/d_a_obj_waterPillar.cpp
+++ b/src/d/actor/d_a_obj_waterPillar.cpp
@@ -130,13 +130,13 @@ int daWtPillar_c::createHeapCallBack(fopAc_ac_c* i_this) {
     return actor->CreateHeap();
 }
 
-const dCcD_SrcGObjInf daWtPillar_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daWtPillar_c::mCcDObjInfo = {
     {0x0, {{AT_TYPE_100, 0x0, 0x1D}, {AT_TYPE_0, 0x0}, 0x0}},    // mObj
     {dCcD_SE_SWORD, 0x0, 0x0, dCcD_MTRL_NONE, 0x0},      // mGObjAt
     {dCcD_SE_STONE, 0x0, 0x0, dCcD_MTRL_NONE, 0x0},      // mGObjTg
     {},  // mGObjCo
 };
-const dCcD_SrcGObjInf daWtPillar_c::mCcDObjCoInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daWtPillar_c::mCcDObjCoInfo = {
     {0x0, {{AT_TYPE_0, 0x0, 0x0}, {0x00, 0x0}, 0x79}},    // mObj
     {dCcD_SE_SWORD, 0x0, 0x0, dCcD_MTRL_NONE, 0x0},      // mGObjAt
     {dCcD_SE_STONE, 0x0, 0x0, dCcD_MTRL_NONE, 0x0},      // mGObjTg
@@ -145,17 +145,17 @@ const dCcD_SrcGObjInf daWtPillar_c::mCcDObjCoInfo = {
 
 static daWtPillar_HIO_c l_HIO;
 
-cull_box l_cull_box = {
+DUSK_GAME_DATA cull_box l_cull_box = {
     {-30.0f, -10.0f, -30.0f},
     {30.0f, 60.0f, 30.0f}
 };
 
-dCcD_SrcCps daWtPillar_c::mCcDCps = {
+DUSK_GAME_DATA dCcD_SrcCps daWtPillar_c::mCcDCps = {
     daWtPillar_c::mCcDObjInfo,
     { { {0.0f, 0.0f, 0.0f}, {0.0f,1100.0f, 0.0f}, 150.0f }}
 };
 
-dCcD_SrcCyl daWtPillar_c::mCcDCyl = {daWtPillar_c::mCcDObjCoInfo};
+DUSK_GAME_DATA dCcD_SrcCyl daWtPillar_c::mCcDCyl = {daWtPillar_c::mCcDObjCoInfo};
 
 int daWtPillar_c::CreateHeap() {
     J3DModelData* modelData = static_cast<J3DModelData*>(dComIfG_getObjectRes("efWater", 8));
@@ -694,7 +694,7 @@ int daWtPillar_Create(fopAc_ac_c* i_this) {
     return actor->create();
 }
 
-actor_method_class l_daWtPillar_Method = {
+DUSK_GAME_DATA actor_method_class l_daWtPillar_Method = {
     (process_method_func)daWtPillar_Create,
     (process_method_func)daWtPillar_Delete,
     (process_method_func)daWtPillar_Execute,
diff --git a/src/d/actor/d_a_obj_waterfall.cpp b/src/d/actor/d_a_obj_waterfall.cpp
index 0987eec4a1..a7707f36b9 100644
--- a/src/d/actor/d_a_obj_waterfall.cpp
+++ b/src/d/actor/d_a_obj_waterfall.cpp
@@ -27,7 +27,7 @@ static int daObjWaterFall_Create(fopAc_ac_c* i_this);
 static fopAc_ac_c* target_info[MAX_TARGET_INFO_COUNT]; // Mutually exclusive list of bomb/arrow actors to be potentially deleted
 static int target_info_count;
 
-const char* l_arcName = "sample";
+DUSK_GAME_DATA const char* l_arcName = "sample";
 
 #if DEBUG
 static DUSK_CONSTEXPR cull_box l_cull_box = {
diff --git a/src/d/actor/d_a_obj_wdStick.cpp b/src/d/actor/d_a_obj_wdStick.cpp
index d18cc67ee2..57a3f8b7b8 100644
--- a/src/d/actor/d_a_obj_wdStick.cpp
+++ b/src/d/actor/d_a_obj_wdStick.cpp
@@ -14,7 +14,7 @@
 
 static daWdStick_HIO_c l_HIO;
 
-dCcD_SrcSph daWdStick_c::mCcDSph = {daWdStick_c::mCcDObjInfo, {{{0.0f, 0.0f, 0.0f}, 4.0f}}};
+DUSK_GAME_DATA dCcD_SrcSph daWdStick_c::mCcDSph = {daWdStick_c::mCcDObjInfo, {{{0.0f, 0.0f, 0.0f}, 4.0f}}};
 
 daWdStick_HIO_c::daWdStick_HIO_c() {
     field_0x04 = 60;
@@ -37,7 +37,7 @@ int daWdStick_c::CreateHeap() {
     return mModel != 0 ? 1 : 0;
 }
 
-dCcD_SrcGObjInf const daWdStick_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daWdStick_c::mCcDObjInfo = {
     {0, {{0x200, 0, 0x1f}, {0xd8fbffff, 0x1f}, {0x0}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 4},
diff --git a/src/d/actor/d_a_obj_wood_statue.cpp b/src/d/actor/d_a_obj_wood_statue.cpp
index 7c6d69d576..9656036235 100644
--- a/src/d/actor/d_a_obj_wood_statue.cpp
+++ b/src/d/actor/d_a_obj_wood_statue.cpp
@@ -255,8 +255,9 @@ int daObjWStatue_c::initActionOrderGetDemo() {
     s16 eventIdx = dComIfGp_getEventManager().getEventIdx(this, "DEFAULT_GETITEM", 0xff);
     dComIfGp_getEvent()->reset(this);
     fopAcM_orderChangeEventId(this, eventIdx, 1, 0xffff);
-    mItemId = fopAcM_createItemForTrBoxDemo(&current.pos, m_itemNo, 0xffffffff,
-                                            fopAcM_GetRoomNo(this), 0, 0);
+    mItemId = fopAcM_createItemForTrBoxDemo(&current.pos,
+        DUSK_ITEM_CHECK_EXPR("wood_statue", m_itemNo, this), 0xffffffff, fopAcM_GetRoomNo(this),
+        0, 0 DUSK_GIVE_TAG("wood_statue"));
     JUT_ASSERT(544, mItemId != fpcM_ERROR_PROCESS_ID_e);
     setStatus(STATUS_ORDER_GET_DEMO);
     return 1;
diff --git a/src/d/actor/d_a_obj_yel_bag.cpp b/src/d/actor/d_a_obj_yel_bag.cpp
index 1b7b7c8374..baacdbd934 100644
--- a/src/d/actor/d_a_obj_yel_bag.cpp
+++ b/src/d/actor/d_a_obj_yel_bag.cpp
@@ -27,7 +27,7 @@ static DUSK_CONSTEXPR int DUSK_CONST* l_loadRes_list[2] = {
 
 static DUSK_CONSTEXPR char DUSK_CONST* l_resNames[] = {"yel_bag"};
 
-dCcD_SrcCyl daObj_YBag_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daObj_YBag_c::mCcDCyl = {
     daNpcT_c::mCcDObjData,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f}
@@ -69,14 +69,14 @@ daObj_YBag_c::~daObj_YBag_c() {
 #endif
 }
 
-const dCcD_SrcGObjInf daObj_YBag_c::mCcDObjInfo = {
+DUSK_GAME_DATA const dCcD_SrcGObjInf daObj_YBag_c::mCcDObjInfo = {
     {0, {{0, 0, 0}, {0, 0x00}, {0x79}}},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {dCcD_SE_NONE, 0, 0, 0, 0},
     {0},
 };
 
-daObj_YBag_HIOParam const daObj_YBag_Param_c::m = {
+DUSK_GAME_DATA daObj_YBag_HIOParam const daObj_YBag_Param_c::m = {
     0.0f, -4.0f, 1.0f, 400.0f, 255.0f, 10.0f, 4.0f, 10.0f, 
     41.0f, 32.0f, 3.0f,
 };
diff --git a/src/d/actor/d_a_obj_yobikusa.cpp b/src/d/actor/d_a_obj_yobikusa.cpp
index fd2a53f24e..32e9ba4145 100644
--- a/src/d/actor/d_a_obj_yobikusa.cpp
+++ b/src/d/actor/d_a_obj_yobikusa.cpp
@@ -16,7 +16,7 @@ static const char* l_arcName1 = "J_Tobi";
 
 static const char* l_arcName2 = "J_Umak";
 
-daObjYobikusa_c::actionFuncEntry daObjYobikusa_c::ActionTable[] = {
+DUSK_GAME_DATA daObjYobikusa_c::actionFuncEntry daObjYobikusa_c::ActionTable[] = {
     {&daObjYobikusa_c::initSwingWind, &daObjYobikusa_c::executeSwingWind},
     {&daObjYobikusa_c::initPushDown, &daObjYobikusa_c::executePushDown},
     {&daObjYobikusa_c::initPickLeaf, &daObjYobikusa_c::executePickLeaf},
@@ -39,7 +39,7 @@ void daObjYobikusa_c::initSwingWind() {
     mMode = MODE_SWING_WIND;
 }
 
-daObjYobikusa_c::attributes const daObjYobikusa_c::M_attr = {
+DUSK_GAME_DATA daObjYobikusa_c::attributes const daObjYobikusa_c::M_attr = {
     1000.0f, 4000.0f, 0.0f, 1500.0f, 500.0f, 1152.0f, 512.0f, 200.0f, 400.0f,
     0.02f,   0.0f,    0.0f, 5000.0f, 150.0f, 1024,    64,     10000,  6582};
 
diff --git a/src/d/actor/d_a_obj_zcloth.cpp b/src/d/actor/d_a_obj_zcloth.cpp
index 49580d2589..74a957fa8d 100644
--- a/src/d/actor/d_a_obj_zcloth.cpp
+++ b/src/d/actor/d_a_obj_zcloth.cpp
@@ -32,6 +32,7 @@ int daObjZCloth_c::Create() {
 int daObjZCloth_c::create() {
     fopAcM_ct(this, daObjZCloth_c);
     m_itemNo = 0x31;
+    DUSK_ITEM_CHECK_PREVIEW("zora_armor", m_itemNo, this);
     int phase = dComIfG_resLoad(&mPhase, dItem_data::getFieldArc(m_itemNo));
     if (phase == cPhs_COMPLEATE_e) {
         if (!fopAcM_entrySolidHeap(this, (heapCallbackFunc)CheckFieldItemCreateHeap, 0x2fb0)) {
diff --git a/src/d/actor/d_a_obj_zrTurara.cpp b/src/d/actor/d_a_obj_zrTurara.cpp
index f4a94de7ec..93feb1a70e 100644
--- a/src/d/actor/d_a_obj_zrTurara.cpp
+++ b/src/d/actor/d_a_obj_zrTurara.cpp
@@ -19,7 +19,7 @@ daZrTurara_HIO_c::daZrTurara_HIO_c() {
 
 static daZrTurara_HIO_c l_HIO;
 
-dCcD_SrcGObjInf const daZrTurara_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daZrTurara_c::mCcDObjInfo = {
     {0, {
         {0, 0, 0},
         {0x20, 0x11},
@@ -30,7 +30,7 @@ dCcD_SrcGObjInf const daZrTurara_c::mCcDObjInfo = {
     {0}
 };
 
-dCcD_SrcCyl daZrTurara_c::mCcDCyl = {
+DUSK_GAME_DATA dCcD_SrcCyl daZrTurara_c::mCcDCyl = {
     mCcDObjInfo,
     {
         {{0.0f, 0.0f, 0.0f}, 0.0f, 0.0f}
diff --git a/src/d/actor/d_a_obj_zrTuraraRock.cpp b/src/d/actor/d_a_obj_zrTuraraRock.cpp
index 45f58dd543..8b3a2d6dd3 100644
--- a/src/d/actor/d_a_obj_zrTuraraRock.cpp
+++ b/src/d/actor/d_a_obj_zrTuraraRock.cpp
@@ -23,7 +23,7 @@ daZrTuraRc_HIO_c::daZrTuraRc_HIO_c() {
     field_0x1c = 5.0f;
 }
 
-dCcD_SrcGObjInf const daZrTuraRc_c::mCcDObjInfo = {
+DUSK_GAME_DATA dCcD_SrcGObjInf const daZrTuraRc_c::mCcDObjInfo = {
     {0, {
         {0x20, 1, 0x1F},
         {0, 0},
@@ -34,7 +34,7 @@ dCcD_SrcGObjInf const daZrTuraRc_c::mCcDObjInfo = {
     {0}
 };
 
-dCcD_SrcSph daZrTuraRc_c::mCcDSph = {
+DUSK_GAME_DATA dCcD_SrcSph daZrTuraRc_c::mCcDSph = {
     mCcDObjInfo,
     {{{0.0f, 0.0f, 0.0f}, 0.0f}}
 };
diff --git a/src/d/actor/d_a_passer_mng.cpp b/src/d/actor/d_a_passer_mng.cpp
index aa7af1f5bb..ecdcd419ba 100644
--- a/src/d/actor/d_a_passer_mng.cpp
+++ b/src/d/actor/d_a_passer_mng.cpp
@@ -67,7 +67,7 @@ static SizedGroup<7> const groupD = {
     {0x01000014, 0x21000015, 0x00000016, 0x1100000C, 0x5000000E, 0x4000000F, 0x0100000D},
 };
 
-const daPasserMng_c::Group* daPasserMng_c::mGroupTbl[4] = {
+DUSK_GAME_DATA const daPasserMng_c::Group* daPasserMng_c::mGroupTbl[4] = {
     (const Group*)&groupA,
     (const Group*)&groupB,
     (const Group*)&groupC,
diff --git a/src/d/actor/d_a_peru.cpp b/src/d/actor/d_a_peru.cpp
index 6ef259209a..578e235601 100644
--- a/src/d/actor/d_a_peru.cpp
+++ b/src/d/actor/d_a_peru.cpp
@@ -70,19 +70,19 @@ static DUSK_CONSTEXPR daNpcT_MotionSeqMngr_c::sequenceStepData_c l_motionSequenc
     {3, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0}, {4, -1, 0}, {-1, 0, 0}, {-1, 0, 0}, {-1, 0, 0},
 };
 
-const char* daPeru_c::mCutNameList[3] = {
+DUSK_GAME_DATA const char* daPeru_c::mCutNameList[3] = {
     "",
     "PERU_APPEAR",
     "PERU_APPEAR_SKIP",
 };
 
-daPeru_c::cutAppearFunc daPeru_c::mCutList[3] = {
+DUSK_GAME_DATA daPeru_c::cutAppearFunc daPeru_c::mCutList[3] = {
     NULL,
     &daPeru_c::cutAppear,
     &daPeru_c::cutAppear_skip,
 };
 
-daPeru_HIOParam const daPeru_Param_c::m = {
+DUSK_GAME_DATA daPeru_HIOParam const daPeru_Param_c::m = {
     60.0f,
     -3.0f,
     1.0f,
diff --git a/src/d/actor/d_a_player.cpp b/src/d/actor/d_a_player.cpp
index e2cb035811..e10f7e490c 100644
--- a/src/d/actor/d_a_player.cpp
+++ b/src/d/actor/d_a_player.cpp
@@ -64,11 +64,11 @@ void daPy_boomerangMove_c::initOffset(const cXyz* i_pos) {
     field_0x0 = 0;
 }
 
-daMidna_c* daPy_py_c::m_midnaActor;
+DUSK_GAME_DATA daMidna_c* daPy_py_c::m_midnaActor;
 
-s16 daPy_boomerangMove_c::m_dropAngleY;
+DUSK_GAME_DATA s16 daPy_boomerangMove_c::m_dropAngleY;
 
-s16 daPy_boomerangMove_c::m_eventKeepFlg;
+DUSK_GAME_DATA s16 daPy_boomerangMove_c::m_eventKeepFlg;
 
 int daPy_boomerangMove_c::posMove(cXyz* o_pos, s16* o_rotY, fopAc_ac_c* i_objActor, s16 i_rotStep) {
     daBoomerang_c* boomerang_p = daPy_py_c::getThrowBoomerangActor();
@@ -224,6 +224,12 @@ daPy_anmHeap_c::~daPy_anmHeap_c() {
     if (mAnimeHeap != NULL) {
         mDoExt_destroySolidHeap(mAnimeHeap);
     }
+#if TARGET_PC
+    freeTempBuffers();
+    if (mOwnedBuffer != NULL) {
+        JKRFreeToSysHeap(mOwnedBuffer);
+    }
+#endif
 }
 
 void daPy_anmHeap_c::initData() {
@@ -237,6 +243,56 @@ void* daPy_anmHeap_c::mallocBuffer() {
     return mBuffer;
 }
 
+#if TARGET_PC
+constexpr u32 kAlignment = 0x20;
+
+void daPy_anmHeap_c::reserveBuffer(u16 i_resId) {
+    // Ensure mBuffer is large enough to hold the resource
+    u32 size = daPy_getAnmResourceSize(i_resId, mBufferSize);
+    if (size <= mBufferSize) {
+        return;
+    }
+
+    // If not, replace it with a new buffer allocated from the system heap. Callers still copy
+    // archive data in on every load: setAnmTransform bswaps key tables in place, so we can't point
+    // it at the archive's cached copy directly.
+    u8* buffer = static_cast<u8*>(JKRAllocFromSysHeap(size, kAlignment));
+    JUT_ASSERT(__LINE__, buffer != NULL);
+    if (mOwnedBuffer != NULL) {
+        JKRFreeToSysHeap(mOwnedBuffer);
+    }
+    mOwnedBuffer = buffer;  // Mark it as owned so we release it later
+    mBuffer = buffer;
+    mBufferSize = size;
+}
+
+void* daPy_anmHeap_c::allocTempBuffer(u16 i_resId, u32* io_size) {
+    // Check if the resource can fit in io_size
+    u32 size = daPy_getAnmResourceSize(i_resId, *io_size);
+    if (size <= *io_size) {
+        return JKR_NEW_ARRAY_ARGS(u8, *io_size, kAlignment);
+    }
+
+    // If not, allocate a new temp buffer from the system heap, plus kAlignment extra bytes.
+    // We stash a pointer to the next buffer at the beginning, forming a chain so we can free
+    // them all later.
+    void** temp = static_cast<void**>(JKRAllocFromSysHeap(kAlignment + size, kAlignment));
+    JUT_ASSERT(__LINE__, temp != NULL);
+    *temp = mTempBuffers;
+    mTempBuffers = temp;
+    *io_size = size;
+    return reinterpret_cast<u8*>(temp) + kAlignment;
+}
+
+void daPy_anmHeap_c::freeTempBuffers() {
+    while (mTempBuffers != NULL) {
+        void** temp = mTempBuffers;
+        mTempBuffers = static_cast<void**>(*temp);
+        JKRFreeToSysHeap(temp);
+    }
+}
+#endif
+
 void daPy_anmHeap_c::createHeap(daPy_anmHeap_c::daAlinkHEAP_TYPE i_heapType, const char* name) {
     u32 size;
 
@@ -310,6 +366,7 @@ void* daPy_anmHeap_c::loadData(u16 i_resId) {
     };
 
     if (mArcNo == 0xFFFF) {
+        IF_DUSK(reserveBuffer(i_resId);)
         JKRReadIdxResource(mBuffer, mBufferSize, i_resId, dComIfGp_getAnmArchive());
         #if DEBUG
         daPy_aramBufferCheck(mBuffer, mBufferSize);
@@ -363,31 +420,12 @@ void* daPy_anmHeap_c::loadDataDemoRID(u16 i_resID, u16 i_arcNo) {
 
 JKRHeap* daPy_anmHeap_c::setAnimeHeap() {
     mAnimeHeap->freeAll();
+    IF_DUSK(freeTempBuffers();)
     return mDoExt_setCurrentHeap(mAnimeHeap);
 }
 
 #if !PLATFORM_WII
-#if TARGET_PC
-#include "dusk/dvd_asset.hpp"
-using GameVersion = dusk::version::GameVersion;
-static const u8* l_sightDL_get() { 
-    static u8 buf[0x89];
-    static bool _ = (
-        dusk::LoadDolAsset(
-            buf,
-{
-            {GameVersion::GcnUsa, 0x803BA0C0},
-            {GameVersion::GcnPal, 0x803BBDA0},
-            {GameVersion::GcnJpn, 0x803B4220}
-            },
-            0x89
-        ),
-        true
-    );
-    return buf;
-}
-#define l_sightDL (l_sightDL_get())
-#else
+#if !TARGET_PC
 #include "assets/l_sightDL__d_a_player.h"
 #endif
 
@@ -431,7 +469,33 @@ void daPy_sightPacket_c::draw() {
     GXLoadPosMtxImm(mProjMtx, GX_PNMTX0);
     GXSetCurrentMtx(0);
     GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
+#if TARGET_PC
+    GXSetNumTexGens(1);
+    GXSetNumTevStages(1);
+    GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
+    GXSetCullMode(GX_CULL_NONE);
+    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_C1, GX_CC_C0, GX_CC_TEXC, GX_CC_ZERO);
+    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
+    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
+    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
+    GXSetZMode(GX_FALSE, GX_LEQUAL, GX_FALSE);
+    GXSetColorUpdate(GX_TRUE);
+    GXSetAlphaUpdate(GX_FALSE);
+    GXSetDither(GX_TRUE);
+    GXBegin(GX_TRIANGLESTRIP, GX_VTXFMT0, 4);
+    GXPosition3u8(1, 1, 0);
+    GXTexCoord2u8(1, 1);
+    GXPosition3u8(255, 1, 0);
+    GXTexCoord2u8(0, 1);
+    GXPosition3u8(1, 255, 0);
+    GXTexCoord2u8(1, 0);
+    GXPosition3u8(255, 255, 0);
+    GXTexCoord2u8(0, 0);
+    GXEnd();
+#else
     GXCallDisplayList(l_sightDL, 0x80);
+#endif
     J3DShape::resetVcdVatCache();
 }
 
diff --git a/src/d/actor/d_a_shop_item.cpp b/src/d/actor/d_a_shop_item.cpp
index 568128757f..edd16b9ecf 100644
--- a/src/d/actor/d_a_shop_item.cpp
+++ b/src/d/actor/d_a_shop_item.cpp
@@ -11,6 +11,20 @@
 #include "m_Do/m_Do_lib.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "d/d_item_data.h"
+
+const ResourceData& daShopItem_c::getResourceData() const {
+    if (mItemOverridden) {
+        return mOverrideData;
+    }
+    return mData[mShopItemID];
+}
+#define SHOP_RESOURCE_DATA getResourceData()
+#else
+#define SHOP_RESOURCE_DATA mData[mShopItemID]
+#endif
+
 const char* daShopItem_c::getShopArcname() {
     switch (m_itemNo) {
     case dItemNo_NONE_e:
@@ -88,10 +102,35 @@ const char* daShopItem_c::getShopArcname() {
         return NULL;
     }
 
-    return mData[mShopItemID].get_arcName();
+#if TARGET_PC
+    if (m_itemNo != dItemNo_NONE_e && mItemGiveOriginalNo == dItemNo_NONE_e) {
+        mItemGiveOriginalNo = m_itemNo;
+        mItemGiveTag = dusk::mods::item_give_tag_shop(mItemGiveOriginalNo);
+        const auto [_, displayItem, was_resolved] =
+            dusk::mods::item_check_resolve(mItemGiveTag, mItemGiveOriginalNo, this);
+        setDisplayItemNo(displayItem);
+        mItemOverridden = displayItem != mItemGiveOriginalNo;
+        if (mItemOverridden) {
+            mOverrideData = mData[mShopItemID];
+            mOverrideData.mArcName = dItem_data::getArcName(displayItem);
+            mOverrideData.mBmdName = dItem_data::getBmdName(displayItem);
+            mOverrideData.mBtkName = dItem_data::getBtkName(displayItem);
+            mOverrideData.mBckName = dItem_data::getBckName(displayItem);
+            mOverrideData.mBrkName = dItem_data::getBrkName(displayItem);
+            mOverrideData.mBtpName = dItem_data::getBtpName(displayItem);
+            mOverrideData.mTevFrm = dItem_data::getTevFrm(displayItem);
+            mOverrideData.mBtpFrm = -1;
+            mOverrideData.mFlag = static_cast<u32>(-1);
+            mOverrideData.mOffsetY = mShopItemID == SHOP_ITEMNO_ARMOR ? 60.0f : 15.0f;
+            mOverrideData.mScale = 1.0f;
+        }
+    }
+#endif
+
+    return SHOP_RESOURCE_DATA.get_arcName();
 }
 
-const f32 daShopItem_c::m_cullfar_max = 5000.0f;
+DUSK_GAME_DATA const f32 daShopItem_c::m_cullfar_max = 5000.0f;
 
 u16 daShopItem_c::getHeapSize() {
     static const u16 HeapSizeTbl[] = {
@@ -104,6 +143,11 @@ u16 daShopItem_c::getHeapSize() {
     OS_REPORT("ShopItemID [%u]\n", a_ShopItemID);
     ASSERT(a_ShopItemID < SHOP_ITEMNO_MAX);
 
+#if TARGET_PC
+    if (mItemOverridden) {
+        return 0x8000;
+    }
+#endif
     return HeapSizeTbl[a_ShopItemID];
 }
 
@@ -119,11 +163,11 @@ void daShopItem_c::CreateInit() {
 
     if (strcmp("R_SP109", dComIfGp_getStartStageName()) == 0 && dComIfGp_getStartStageRoomNo() == 1)
     {
-        scale.set(mData[mShopItemID].get_scale() * 0.8f, mData[mShopItemID].get_scale() * 0.8f,
-                  mData[mShopItemID].get_scale() * 0.8f);
+        scale.set(SHOP_RESOURCE_DATA.get_scale() * 0.8f, SHOP_RESOURCE_DATA.get_scale() * 0.8f,
+            SHOP_RESOURCE_DATA.get_scale() * 0.8f);
     } else {
-        scale.set(mData[mShopItemID].get_scale(), mData[mShopItemID].get_scale(),
-                  mData[mShopItemID].get_scale());
+        scale.set(SHOP_RESOURCE_DATA.get_scale(), SHOP_RESOURCE_DATA.get_scale(),
+            SHOP_RESOURCE_DATA.get_scale());
     }
 
     home.pos = current.pos;
@@ -137,8 +181,8 @@ void daShopItem_c::set_mtx() {
     if (daShopItem_prm::getGroup(this) == 15) {
         mDoMtx_stack_c::transS(current.pos.x, current.pos.y, current.pos.z);
     } else {
-        mDoMtx_stack_c::transS(current.pos.x, current.pos.y + mData[mShopItemID].get_offsetY(),
-                               current.pos.z);
+        mDoMtx_stack_c::transS(
+            current.pos.x, current.pos.y + SHOP_RESOURCE_DATA.get_offsetY(), current.pos.z);
     }
 
     MTXCopy(mDoMtx_stack_c::get(), mMtx);
@@ -147,8 +191,8 @@ void daShopItem_c::set_mtx() {
     if (daShopItem_prm::getGroup(this) == 15) {
         mDoMtx_stack_c::ZXYrotM(-11300, 32700, 7300);
     } else {
-        mDoMtx_stack_c::ZXYrotM(mAngleX + mData[mShopItemID].get_angleX(),
-                                mData[mShopItemID].get_angleY(), mData[mShopItemID].get_angleZ());
+        mDoMtx_stack_c::ZXYrotM(mAngleX + SHOP_RESOURCE_DATA.get_angleX(),
+            SHOP_RESOURCE_DATA.get_angleY(), SHOP_RESOURCE_DATA.get_angleZ());
     }
 
     mDoMtx_stack_c::ZXYrotM(current.angle.x, current.angle.y, current.angle.z);
@@ -156,7 +200,7 @@ void daShopItem_c::set_mtx() {
     if (daShopItem_prm::getGroup(this) == 15) {
         mDoMtx_stack_c::XrotM(0);
     } else {
-        mDoMtx_stack_c::XrotM(mData[mShopItemID].get_angleOffsetX());
+        mDoMtx_stack_c::XrotM(SHOP_RESOURCE_DATA.get_angleOffsetX());
     }
 
     mpModel->setBaseTRMtx(mDoMtx_stack_c::get());
@@ -190,29 +234,31 @@ void daShopItem_c::setShadow() {
 }
 
 BOOL daShopItem_c::chkFlag(int i_flag) {
-    return mData[mShopItemID].get_flag() & i_flag;
+    return SHOP_RESOURCE_DATA.get_flag() & i_flag;
 }
 
 s8 daShopItem_c::getTevFrm() {
-    return mData[mShopItemID].get_tevfrm();
+    return SHOP_RESOURCE_DATA.get_tevfrm();
 }
 
 s8 daShopItem_c::getBtpFrm() {
-    return mData[mShopItemID].get_btpfrm();
+    return SHOP_RESOURCE_DATA.get_btpfrm();
 }
 
 u8 daShopItem_c::getShadowSize() {
-    return mData[mShopItemID].get_shadowSize();
+    return SHOP_RESOURCE_DATA.get_shadowSize();
 }
 
 u8 daShopItem_c::getCollisionH() {
-    return mData[mShopItemID].get_collisionH();
+    return SHOP_RESOURCE_DATA.get_collisionH();
 }
 
 u8 daShopItem_c::getCollisionR() {
-    return mData[mShopItemID].get_collisionR();
+    return SHOP_RESOURCE_DATA.get_collisionR();
 }
 
+#undef SHOP_RESOURCE_DATA
+
 int daShopItem_c::_create() {
     fopAcM_ct(this, daShopItem_c);
 
diff --git a/src/d/actor/d_a_tag_TWgate.cpp b/src/d/actor/d_a_tag_TWgate.cpp
index 4f06c69899..642eab8a23 100644
--- a/src/d/actor/d_a_tag_TWgate.cpp
+++ b/src/d/actor/d_a_tag_TWgate.cpp
@@ -24,7 +24,7 @@ struct daTagTWGate_zevParam {
     /* 0x1B */ s8 mLayer;
 };
 
-daTagTWGate_Attr_c const daTagTWGate_c::mAttr = {};
+DUSK_GAME_DATA daTagTWGate_Attr_c const daTagTWGate_c::mAttr = {};
 
 #if DEBUG
 daTagTWGate_Hio_c daTagTWGate_c::mHio;
@@ -79,7 +79,7 @@ static daTagTWGate_zevParam const l_zevParamTbl[4] = {
 
 static DUSK_CONSTEXPR const char* l_myName = "Gate";
 
-const actionFunc daTagTWGate_c::ActionTable[][2] = {
+DUSK_GAME_DATA const actionFunc daTagTWGate_c::ActionTable[][2] = {
     {&daTagTWGate_c::initWait, &daTagTWGate_c::executeWait},
     {&daTagTWGate_c::initDemoFilone1, &daTagTWGate_c::executeDemoFilone1},
     {&daTagTWGate_c::initDemoFilone2, &daTagTWGate_c::executeDemoFilone2},
diff --git a/src/d/actor/d_a_tag_evt.cpp b/src/d/actor/d_a_tag_evt.cpp
index 7cf68b91b3..92bc7b2494 100644
--- a/src/d/actor/d_a_tag_evt.cpp
+++ b/src/d/actor/d_a_tag_evt.cpp
@@ -8,7 +8,9 @@
 #include "f_op/f_op_actor_mng.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static DUSK_CONST char* l_evtNameList[] = {
     NULL,
@@ -17,7 +19,7 @@ static DUSK_CONST char* l_evtNameList[] = {
 
 static DUSK_CONST char* l_resFileName = "TAGEVT";
 
-DUSK_CONST char* daTag_Evt_c::mEvtCutList[] = {
+DUSK_GAME_DATA DUSK_CONST char* daTag_Evt_c::mEvtCutList[] = {
     "WAIT",
     "TALK",
     "NEXT",
diff --git a/src/d/actor/d_a_tag_evtmsg.cpp b/src/d/actor/d_a_tag_evtmsg.cpp
index c63ec8b3ce..e106ed2006 100644
--- a/src/d/actor/d_a_tag_evtmsg.cpp
+++ b/src/d/actor/d_a_tag_evtmsg.cpp
@@ -17,9 +17,9 @@ enum evt_cut_e {
     NUM_EVT_CUTS_e,
 };
 
-DUSK_CONST char* daTag_EvtMsg_c::mEvtCutNameList[] = {"", "TALK", "WAIT"};
+DUSK_GAME_DATA DUSK_CONST char* daTag_EvtMsg_c::mEvtCutNameList[] = {"", "TALK", "WAIT"};
 
-EvtCutFunc daTag_EvtMsg_c::mEvtCutList[] = {
+DUSK_GAME_DATA EvtCutFunc daTag_EvtMsg_c::mEvtCutList[] = {
     NULL,
     &daTag_EvtMsg_c::ECut_talk,
     &daTag_EvtMsg_c::ECut_wait,
diff --git a/src/d/actor/d_a_tag_firewall.cpp b/src/d/actor/d_a_tag_firewall.cpp
index 0f1a461ba2..9168899f76 100644
--- a/src/d/actor/d_a_tag_firewall.cpp
+++ b/src/d/actor/d_a_tag_firewall.cpp
@@ -14,15 +14,15 @@
 #include "d/d_s_play.h"
 
 struct Tag_FWall_n {
-    static dCcD_SrcSph cc_sph_src;
-    static u16 game_over_eff_name[];
+    static DUSK_GAME_DATA dCcD_SrcSph cc_sph_src;
+    static DUSK_GAME_DATA u16 game_over_eff_name[];
 };
 
 static int daTag_FWall_Draw(daTag_FWall_c* i_this) {
     return 1;
 }
 
-dCcD_SrcSph Tag_FWall_n::cc_sph_src = {
+DUSK_GAME_DATA dCcD_SrcSph Tag_FWall_n::cc_sph_src = {
     {
         {0x0, {{0x400, 0x1, 0xC}, {0x0, 0x0}, 0x0}},  // mObj
         {dCcD_SE_METAL, 0x0, 0x0, 0x0, 0x0},          // mGObjAt
@@ -34,7 +34,7 @@ dCcD_SrcSph Tag_FWall_n::cc_sph_src = {
     }                                // mSphAttr
 };
 
-u16 Tag_FWall_n::game_over_eff_name[] = {0x84CC, 0x84CD, 0x84CE, 0x84CF};
+DUSK_GAME_DATA u16 Tag_FWall_n::game_over_eff_name[] = {0x84CC, 0x84CD, 0x84CE, 0x84CF};
 
 static daTag_FWall_c* fire_leader;
 
diff --git a/src/d/actor/d_a_tag_hstop.cpp b/src/d/actor/d_a_tag_hstop.cpp
index 825ab6e647..2cb2426fca 100644
--- a/src/d/actor/d_a_tag_hstop.cpp
+++ b/src/d/actor/d_a_tag_hstop.cpp
@@ -102,7 +102,7 @@ void daTagHstop_c::setActive() {
     }
 }
 
-dMsgFlow_c daTagHstop_c::m_msgFlow;
+DUSK_GAME_DATA dMsgFlow_c daTagHstop_c::m_msgFlow;
 
 int daTagHstop_c::execute() {
     if (eventInfo.checkCommandTalk()) {
diff --git a/src/d/actor/d_a_tag_lantern.cpp b/src/d/actor/d_a_tag_lantern.cpp
index 00d4e49b95..861d80c66a 100644
--- a/src/d/actor/d_a_tag_lantern.cpp
+++ b/src/d/actor/d_a_tag_lantern.cpp
@@ -14,7 +14,7 @@
 
 static TAG_LANTERN_HIO_CLASS l_HIO;
 
-daTag_Lantern_HIOParam const daTag_Lantern_Param_c::m = {0};
+DUSK_GAME_DATA daTag_Lantern_HIOParam const daTag_Lantern_Param_c::m = {0};
 
 #if DEBUG
 daTag_Lantern_HIO_c::daTag_Lantern_HIO_c() {
diff --git a/src/d/actor/d_a_tag_msg.cpp b/src/d/actor/d_a_tag_msg.cpp
index 08bd00b001..2f5ccd2761 100644
--- a/src/d/actor/d_a_tag_msg.cpp
+++ b/src/d/actor/d_a_tag_msg.cpp
@@ -11,7 +11,9 @@
 #include "d/d_debug_viewer.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 static int createHeapCallBack(fopAc_ac_c* i_this) {
     daTag_Msg_c* msg = (daTag_Msg_c*)i_this;
@@ -79,7 +81,7 @@ int daTag_Msg_c::destroy() {
     return 1;
 }
 
-const daTag_Msg_HIO_Param_c daTag_Msg_Param_c::m = {0};
+DUSK_GAME_DATA const daTag_Msg_HIO_Param_c daTag_Msg_Param_c::m = {0};
 
 int daTag_Msg_c::execute() {
     bool set_event = true;
@@ -224,7 +226,7 @@ void daTag_Msg_c::getParam() {
     SAFE_STRCPY(mStaffName, "Tag_ms");
 }
 
-DUSK_CONST char* daTag_Msg_c::mEvtCutTBL[2] = {
+DUSK_GAME_DATA DUSK_CONST char* daTag_Msg_c::mEvtCutTBL[2] = {
     "SPEAK",
     "PAUSE",
 };
diff --git a/src/d/actor/d_a_tag_statue_evt.cpp b/src/d/actor/d_a_tag_statue_evt.cpp
index 8a4c0c4397..cdd0db19ad 100644
--- a/src/d/actor/d_a_tag_statue_evt.cpp
+++ b/src/d/actor/d_a_tag_statue_evt.cpp
@@ -362,9 +362,14 @@ int daTagStatue_c::demoProc() {
                     item = dItemNo_AIR_LETTER_e;
                 }
 
+#if TARGET_PC
+                const auto itemCheck = dusk::mods::item_check_commit(
+                    dusk::mods::item_give_tag_sky_character(), item & 0xFF, this);
+                item = itemCheck.itemNo;
+#endif
                 mItemId =
-                    fopAcM_createItemForTrBoxDemo(&current.pos, item, -1,
-                                                  fopAcM_GetRoomNo(this), 0, 0);
+                    fopAcM_createItemForTrBoxDemo(&current.pos, item, -1, fopAcM_GetRoomNo(this), 0,
+                        0 IF_DUSK_ARG(itemCheck.tag));
 
                 JUT_ASSERT(580, mItemId != fpcM_ERROR_PROCESS_ID_e);
 
diff --git a/src/d/actor/d_a_tbox.cpp b/src/d/actor/d_a_tbox.cpp
index 1d1826b7e7..f8048478ee 100644
--- a/src/d/actor/d_a_tbox.cpp
+++ b/src/d/actor/d_a_tbox.cpp
@@ -1390,6 +1390,11 @@ u8 daTbox_c::getBombItemNoMain(u8 i_itemNo) {
 
 int daTbox_c::setGetDemoItem() {
     u8 item_no = getItemNo();
+#if TARGET_PC
+    const auto itemCheck = dusk::mods::item_check_commit(
+        dusk::mods::item_give_tag_chest(getTboxNo()), mOriginalItemNo, this);
+    item_no = itemCheck.itemNo;
+#endif
     if (item_no == dItemNo_BOMB_5_e || item_no == dItemNo_BOMB_10_e || item_no == dItemNo_BOMB_20_e || item_no == dItemNo_BOMB_30_e ||
         item_no == dItemNo_WATER_BOMB_5_e || item_no == dItemNo_WATER_BOMB_10_e || item_no == dItemNo_WATER_BOMB_20_e || item_no == dItemNo_WATER_BOMB_30_e ||
         item_no == dItemNo_BOMB_INSECT_5_e || item_no == dItemNo_BOMB_INSECT_10_e || item_no == dItemNo_BOMB_INSECT_20_e || item_no == dItemNo_BOMB_INSECT_30_e)
@@ -1399,9 +1404,11 @@ int daTbox_c::setGetDemoItem() {
 
     fpc_ProcID item_id;
     if (field_0x718) {
-        item_id = fopAcM_createItemForPresentDemo(&current.pos, item_no, 1, -1, -1, NULL, NULL);
+        item_id = fopAcM_createItemForPresentDemo(
+            &current.pos, item_no, 1, -1, -1, NULL, NULL IF_DUSK_ARG(itemCheck.tag));
     } else {
-        item_id = fopAcM_createItemForTrBoxDemo(&current.pos, item_no, -1, -1, NULL, NULL);
+        item_id = fopAcM_createItemForTrBoxDemo(
+            &current.pos, item_no, -1, -1, NULL, NULL IF_DUSK_ARG(itemCheck.tag));
     }
 
     if (item_id != fpcM_ERROR_PROCESS_ID_e) {
@@ -1785,6 +1792,11 @@ void daTbox_c::mode_exec() {
 cPhs_Step daTbox_c::create1st() {
     if (!mParamsInit) {
         field_0x980 = home.angle.x;
+#if TARGET_PC
+        mOriginalItemNo = (home.angle.z >> 8) & 0xFF;
+        const u8 resolvedItem = dusk::mods::item_check_chest(getTboxNo(), mOriginalItemNo, this);
+        home.angle.z = static_cast<s16>((home.angle.z & ~0xFF00) | (resolvedItem << 8));
+#endif
         field_0x982 = home.angle.z;
         home.angle.z = 0;
         home.angle.x = 0;
diff --git a/src/d/actor/d_a_tbox2.cpp b/src/d/actor/d_a_tbox2.cpp
index 2f2a3a8276..2d35e8285f 100644
--- a/src/d/actor/d_a_tbox2.cpp
+++ b/src/d/actor/d_a_tbox2.cpp
@@ -138,6 +138,17 @@ int daTbox2_c::create1st() {
     fopAcM_ct(this, daTbox2_c);
     mModelType = getModelType();
 
+#if TARGET_PC
+    if (!mParamsInit) {
+        mOriginalItemNo = getItemNo();
+        int tboxNo = fopAcM_GetParamBit(this, 16, 8);
+        const u8 resolvedItem = dusk::mods::item_check_chest(tboxNo, mOriginalItemNo, this);
+        u32 params = (fopAcM_GetParam(this) & 0xFFFFFF00) | resolvedItem;
+        fopAcM_SetParam(this, params);
+        mParamsInit = true;
+    }
+#endif
+
     int phase_state = dComIfG_resLoad(&mPhase, l_arcName);
     if (phase_state == cPhs_COMPLEATE_e) {
         u32 heap_size;
@@ -370,12 +381,20 @@ void daTbox2_c::actionOpenWait() {
 
 int daTbox2_c::setGetDemoItem() {
     u8 item_no = getItemNo();
+#if TARGET_PC
+    int tboxNo = fopAcM_GetParamBit(this, 16, 8);
+    const auto itemCheck = dusk::mods::item_check_commit(
+        dusk::mods::item_give_tag_chest(tboxNo), mOriginalItemNo, this);
+    item_no = itemCheck.itemNo;
+#endif
 
     u32 partner_id;
     if (mReturnRupee) {
-        partner_id = fopAcM_createItemForPresentDemo(&current.pos, item_no, 1, -1, -1, NULL, NULL);
+        partner_id = fopAcM_createItemForPresentDemo(
+            &current.pos, item_no, 1, -1, -1, NULL, NULL IF_DUSK_ARG(itemCheck.tag));
     } else {
-        partner_id = fopAcM_createItemForTrBoxDemo(&current.pos, item_no, -1, -1, NULL, NULL);
+        partner_id = fopAcM_createItemForTrBoxDemo(
+            &current.pos, item_no, -1, -1, NULL, NULL IF_DUSK_ARG(itemCheck.tag));
     }
 
     if (partner_id != -1) {
diff --git a/src/d/actor/d_a_title.cpp b/src/d/actor/d_a_title.cpp
index 5ff7dad881..0d011f9213 100644
--- a/src/d/actor/d_a_title.cpp
+++ b/src/d/actor/d_a_title.cpp
@@ -11,7 +11,6 @@
 #include "d/d_pane_class_alpha.h"
 #include "d/d_s_logo.h"
 #include "d/d_s_play.h"
-#include "dusk/version.hpp"
 #include "f_op/f_op_msg_mng.h"
 #include "f_op/f_op_overlap_mng.h"
 #include "f_op/f_op_scene_mng.h"
@@ -19,9 +18,9 @@
 #include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_graphic.h"
 
-#ifdef TARGET_PC
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/version.hpp"
 #endif
 
 class daTit_HIO_c : public JORReflexible {
@@ -52,7 +51,7 @@ static u8 const lit_3772[12] = {
 
 #if TARGET_PC
 using namespace dusk::version;
-#define l_arcName versionSelect<const char*>({{GameVersion::GcnPal, "TitlePal"}}, "Title")
+#define l_arcName regionSelect<const char*>("Title", "TitlePal", "Title")
 #elif VERSION == VERSION_GCN_PAL
 static char const l_arcName[] = "TitlePal";
 #else
@@ -170,7 +169,7 @@ int daTitle_c::Execute() {
     }
 
 #ifdef TARGET_PC
-    if (!dusk::frame_interp::is_enabled()) {
+    if (!dusk::interp::is_enabled()) {
 #endif
         dMenu_Collect3D_c::setViewPortOffsetY(0.0f);
 #ifdef TARGET_PC
@@ -353,11 +352,7 @@ void daTitle_c::fastLogoDispInit() {
     mWaitTimer = 30;
     mProcID = 5;
 
-#ifdef TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
-        dusk::frame_interp::request_presentation_sync();
-    }
-#endif
+    IF_DUSK(dusk::interp::request_presentation_sync());
 }
 
 void daTitle_c::fastLogoDisp() {
diff --git a/src/d/actor/d_flower.inc b/src/d/actor/d_flower.inc
index 54b1e022cc..e42cc7ded0 100644
--- a/src/d/actor/d_flower.inc
+++ b/src/d/actor/d_flower.inc
@@ -5,21 +5,30 @@
 #include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
 #include "SSystem/SComponent/c_counter.h"
 
-#include "dusk/frame_interpolation.h"
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 const u16 l_J_Ohana00_64TEX__width = 63;
 const u16 l_J_Ohana00_64TEX__height = 63;
 
 #if TARGET_PC
-#include "dusk/dvd_asset.hpp"
-using GameVersion = dusk::version::GameVersion;
-static u8* l_J_Ohana00_64TEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9060}, {GameVersion::GcnPal, 0x9060}}, 0x800), true); return buf; }
+DEFINE_GRASS_ASSET(l_J_Ohana00_64TEX, u8, 0x800, {
+    {GameVersion::GcnUsa,     0x9060},
+    {GameVersion::GcnPal,     0x9060},
+    {GameVersion::GcnJpn,     0x9060},
+    {GameVersion::WiiUsaRev0, 0x7B60},
+    {GameVersion::WiiUsa,     0x7BC0},
+    {GameVersion::WiiPal,     0x7BC0},
+    {GameVersion::WiiJpn,     0x7BC0},
+});
+
 #define l_J_Ohana00_64TEX (l_J_Ohana00_64TEX_get())
 
 // from d_grass.inc
 static MtxP get_model_mtx(Mtx modelMtx, Mtx storage);
 static void transform_positions(
-    const dusk::batch::LeafTemplate& tpl, const Vec* posArray, const Mtx mtx, Vec* xfPos);
+    const batch::LeafTemplate& tpl, const Vec* posArray, const Mtx mtx, Vec* xfPos);
 static void split_batch(u32& emitted, u32 vtxCount);
 #else
 #include "assets/l_J_Ohana00_64TEX.h"
@@ -115,12 +124,46 @@ static u8 l_flowerTexCoord[] = {
     0x3E, 0xA7, 0x72, 0xD6, 0xBD, 0x2F, 0x46, 0xAA};
 
 #if TARGET_PC
-using GameVersion = dusk::version::GameVersion;
+DEFINE_GRASS_ASSET(l_J_hana00DL, u8, 0x150, {
+    {GameVersion::GcnUsa,     0x9D20},
+    {GameVersion::GcnPal,     0x9D20},
+    {GameVersion::GcnJpn,     0x9D20},
+    {GameVersion::WiiUsaRev0, 0x8820},
+    {GameVersion::WiiUsa,     0x8880},
+    {GameVersion::WiiPal,     0x8880},
+    {GameVersion::WiiJpn,     0x8880},
+});
+
+DEFINE_GRASS_ASSET(l_J_hana00_cDL, u8, 0xDE, {
+    {GameVersion::GcnUsa,     0x9E80},
+    {GameVersion::GcnPal,     0x9E80},
+    {GameVersion::GcnJpn,     0x9E80},
+    {GameVersion::WiiUsaRev0, 0x8980},
+    {GameVersion::WiiUsa,     0x89E0},
+    {GameVersion::WiiPal,     0x89E0},
+    {GameVersion::WiiJpn,     0x89E0},
+});
+
+DEFINE_GRASS_ASSET(l_matDL, u8, 0x99, {
+    {GameVersion::GcnUsa,     0x9F60},
+    {GameVersion::GcnPal,     0x9F60},
+    {GameVersion::GcnJpn,     0x9F60},
+    {GameVersion::WiiUsaRev0, 0x8A60},
+    {GameVersion::WiiUsa,     0x8AC0},
+    {GameVersion::WiiPal,     0x8AC0},
+    {GameVersion::WiiJpn,     0x8AC0},
+});
+
+DEFINE_GRASS_ASSET(l_matLight4DL, u8, 0x99, {
+    {GameVersion::GcnUsa,     0xA000},
+    {GameVersion::GcnPal,     0xA000},
+    {GameVersion::GcnJpn,     0xA000},
+    {GameVersion::WiiUsaRev0, 0x8B00},
+    {GameVersion::WiiUsa,     0x8B60},
+    {GameVersion::WiiPal,     0x8B60},
+    {GameVersion::WiiJpn,     0x8B60},
+});
 
-static u8* l_J_hana00DL_get()   { static u8 buf[0x150]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9D20}, {GameVersion::GcnPal, 0x9D20}}, 0x150), true); return buf; }
-static u8* l_J_hana00_cDL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9E80}, {GameVersion::GcnPal, 0x9E80}}, 0xDE),  true); return buf; }
-static u8* l_matDL_get()        { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x9F60}, {GameVersion::GcnPal, 0x9F60}}, 0x99),  true); return buf; }
-static u8* l_matLight4DL_get()  { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xA000}, {GameVersion::GcnPal, 0xA000}}, 0x99),  true); return buf; }
 #define l_J_hana00DL   (l_J_hana00DL_get())
 #define l_J_hana00_cDL (l_J_hana00_cDL_get())
 #define l_matDL        (l_matDL_get())
@@ -141,8 +184,16 @@ const u16 l_J_Ohana01_64128_0419TEX__width = 63;
 const u16 l_J_Ohana01_64128_0419TEX__height = 127;
 
 #if TARGET_PC
-using GameVersion = dusk::version::GameVersion;
-static u8* l_J_Ohana01_64128_0419TEX_get() { static u8 buf[0x1000]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xA0A0}, {GameVersion::GcnPal, 0xA0A0}}, 0x1000), true); return buf; }
+DEFINE_GRASS_ASSET(l_J_Ohana01_64128_0419TEX, u8, 0x1000, {
+    {GameVersion::GcnUsa,     0xA0A0},
+    {GameVersion::GcnPal,     0xA0A0},
+    {GameVersion::GcnJpn,     0xA0A0},
+    {GameVersion::WiiUsaRev0, 0x8BA0},
+    {GameVersion::WiiUsa,     0x8C00},
+    {GameVersion::WiiPal,     0x8C00},
+    {GameVersion::WiiJpn,     0x8C00},
+});
+
 #define l_J_Ohana01_64128_0419TEX (l_J_Ohana01_64128_0419TEX_get())
 #else
 #include "assets/l_J_Ohana01_64128_0419TEX.h"
@@ -274,13 +325,56 @@ static u8 l_flowerTexCoord2[] = {
     0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x80, 0x3F, 0x79, 0x40, 0x1B, 0x7D, 0x52, 0x3F, 0x51, 0x10, 0x6F};
 
 #if TARGET_PC
-using GameVersion = dusk::version::GameVersion;
+DEFINE_GRASS_ASSET(l_J_hana01DL, u8, 0x138, {
+    {GameVersion::GcnUsa,     0xB7C0},
+    {GameVersion::GcnPal,     0xB7C0},
+    {GameVersion::GcnJpn,     0xB7C0},
+    {GameVersion::WiiUsaRev0, 0xA2C0},
+    {GameVersion::WiiUsa,     0xA320},
+    {GameVersion::WiiPal,     0xA320},
+    {GameVersion::WiiJpn,     0xA320},
+});
+
+DEFINE_GRASS_ASSET(l_J_hana01_c_00DL, u8, 0xDE, {
+    {GameVersion::GcnUsa,     0xB900},
+    {GameVersion::GcnPal,     0xB900},
+    {GameVersion::GcnJpn,     0xB900},
+    {GameVersion::WiiUsaRev0, 0xA400},
+    {GameVersion::WiiUsa,     0xA460},
+    {GameVersion::WiiPal,     0xA460},
+    {GameVersion::WiiJpn,     0xA460},
+});
+
+DEFINE_GRASS_ASSET(l_J_hana01_c_01DL, u8, 0x128, {
+    {GameVersion::GcnUsa,     0xB9E0},
+    {GameVersion::GcnPal,     0xB9E0},
+    {GameVersion::GcnJpn,     0xB9E0},
+    {GameVersion::WiiUsaRev0, 0xA4E0},
+    {GameVersion::WiiUsa,     0xA540},
+    {GameVersion::WiiPal,     0xA540},
+    {GameVersion::WiiJpn,     0xA540},
+});
+
+DEFINE_GRASS_ASSET(l_mat2DL, u8, 0x99, {
+    {GameVersion::GcnUsa,     0xBB20},
+    {GameVersion::GcnPal,     0xBB20},
+    {GameVersion::GcnJpn,     0xBB20},
+    {GameVersion::WiiUsaRev0, 0xA620},
+    {GameVersion::WiiUsa,     0xA680},
+    {GameVersion::WiiPal,     0xA680},
+    {GameVersion::WiiJpn,     0xA680},
+});
+
+DEFINE_GRASS_ASSET(l_mat2Light4DL, u8, 0x99, {
+    {GameVersion::GcnUsa,     0xBBC0},
+    {GameVersion::GcnPal,     0xBBC0},
+    {GameVersion::GcnJpn,     0xBBC0},
+    {GameVersion::WiiUsaRev0, 0xA6C0},
+    {GameVersion::WiiUsa,     0xA720},
+    {GameVersion::WiiPal,     0xA720},
+    {GameVersion::WiiJpn,     0xA720},
+});
 
-static u8* l_J_hana01DL_get()      { static u8 buf[0x138]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xB7C0}, {GameVersion::GcnPal, 0xB7C0}}, 0x138), true); return buf; }
-static u8* l_J_hana01_c_00DL_get() { static u8 buf[0xDE];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xB900}, {GameVersion::GcnPal, 0xB900}}, 0xDE),  true); return buf; }
-static u8* l_J_hana01_c_01DL_get() { static u8 buf[0x128]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xB9E0}, {GameVersion::GcnPal, 0xB9E0}}, 0x128), true); return buf; }
-static u8* l_mat2DL_get()          { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xBB20}, {GameVersion::GcnPal, 0xBB20}}, 0x99),  true); return buf; }
-static u8* l_mat2Light4DL_get()    { static u8 buf[0x99];  static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0xBBC0}, {GameVersion::GcnPal, 0xBBC0}}, 0x99),  true); return buf; }
 #define l_J_hana01DL      (l_J_hana01DL_get())
 #define l_J_hana01_c_00DL (l_J_hana01_c_00DL_get())
 #define l_J_hana01_c_01DL (l_J_hana01_c_01DL_get())
@@ -595,11 +689,11 @@ dFlower_packet_c::dFlower_packet_c() {
         l_J_Ohana01_64128_0419TEX__width + 1, l_J_Ohana01_64128_0419TEX__height + 1, GX_TF_CMPR, GX_MIRROR, GX_MIRROR, GX_FALSE
     );
 
-    dusk::batch::decode_leaf_template(l_J_hana00DL, 0x140, mTplHana00);
-    dusk::batch::decode_leaf_template(l_J_hana00_cDL, 0xC0, mTplHana00Cut);
-    dusk::batch::decode_leaf_template(l_J_hana01DL, 0x120, mTplHana01);
-    dusk::batch::decode_leaf_template(l_J_hana01_c_00DL, 0xC0, mTplHana01Cut00);
-    dusk::batch::decode_leaf_template(l_J_hana01_c_01DL, 0x120, mTplHana01Cut);
+    batch::decode_leaf_template(l_J_hana00DL, 0x140, mTplHana00);
+    batch::decode_leaf_template(l_J_hana00_cDL, 0xC0, mTplHana00Cut);
+    batch::decode_leaf_template(l_J_hana01DL, 0x120, mTplHana01);
+    batch::decode_leaf_template(l_J_hana01_c_00DL, 0xC0, mTplHana01Cut00);
+    batch::decode_leaf_template(l_J_hana01_c_01DL, 0x120, mTplHana01Cut);
 #endif
 
     m_deleteRoom = &dFlower_packet_c::deleteRoom;
@@ -757,9 +851,9 @@ static GXColor hana01_amb_color(int idx, const dKy_tevstr_c* tevstr) {
     return amb;
 }
 
-static void flower_emit(const dusk::batch::LeafTemplate& tpl, const Vec* xformedPos, GXColor amb) {
+static void flower_emit(const batch::LeafTemplate& tpl, const Vec* xformedPos, GXColor amb) {
     for (u32 i = 0; i < tpl.vtxCount; i++) {
-        const dusk::batch::LeafTemplate::Vtx& v = tpl.vtx[i];
+        const batch::LeafTemplate::Vtx& v = tpl.vtx[i];
         const Vec& p = xformedPos[v.pos];
         GXPosition3f32(p.x, p.y, p.z);
         GXNormal1x8(v.nrm);
@@ -852,7 +946,7 @@ void dFlower_packet_c::draw() {
 
         for (int bucket = 0; bucket < 2; bucket++) {
             const bool cut = bucket != 0;
-            const dusk::batch::LeafTemplate& tpl = cut ? mTplHana00Cut : mTplHana00;
+            const batch::LeafTemplate& tpl = cut ? mTplHana00Cut : mTplHana00;
 
             bool open = false;
             u32 emitted = 0;
@@ -931,10 +1025,10 @@ void dFlower_packet_c::draw() {
         GXLoadPosMtxImm(identity, GX_PNMTX0);
         GXLoadNrmMtxImm(j3dSys.getViewMtx(), 0);
 
-        const dusk::batch::LeafTemplate* const buckets[3] = {
+        const batch::LeafTemplate* const buckets[3] = {
             &mTplHana01, &mTplHana01Cut00, &mTplHana01Cut};
         for (int bucket = 0; bucket < 3; bucket++) {
-            const dusk::batch::LeafTemplate& tpl = *buckets[bucket];
+            const batch::LeafTemplate& tpl = *buckets[bucket];
 
             bool open = false;
             u32 emitted = 0;
@@ -1071,16 +1165,12 @@ void dFlower_packet_c::draw() {
                 GXSetChanAmbColor(GX_COLOR0A0, sp64);
 
                 if (!cLib_checkBit<u8>(sp44->m_state, 4) && !cLib_checkBit<u8>(sp44->m_state, 0x40)) {
-#ifdef TARGET_PC
-                    Mtx flower_mtx;
-                    if (dusk::frame_interp::lookup_replacement(&sp44->m_modelMtx, flower_mtx)) {
-                        cMtx_concat(j3dSys.getViewMtx(), flower_mtx, flower_mtx);
-                        GXLoadPosMtxImm(flower_mtx, 0);
-                    } else
+#if TARGET_PC
+                    Mtx flowerMtx;
+                    GXLoadPosMtxImm(get_model_mtx(sp44->m_modelMtx, flowerMtx), 0);
+#else
+                    GXLoadPosMtxImm(sp44->m_modelMtx, 0);
 #endif
-                    {
-                        GXLoadPosMtxImm(sp44->m_modelMtx, 0);
-                    }
                     GXLoadNrmMtxImm(j3dSys.getViewMtx(), 0);
 
 #if TARGET_PC
@@ -1230,16 +1320,12 @@ void dFlower_packet_c::draw() {
                 sp30++;
 
                 if (!cLib_checkBit<u8>(sp34->m_state, 4) && cLib_checkBit<u8>(sp34->m_state, 0x40)) {
-#ifdef TARGET_PC
-                    Mtx flower_mtx;
-                    if (dusk::frame_interp::lookup_replacement(&sp34->m_modelMtx, flower_mtx)) {
-                        cMtx_concat(j3dSys.getViewMtx(), flower_mtx, flower_mtx);
-                        GXLoadPosMtxImm(flower_mtx, 0);
-                    } else
+#if TARGET_PC
+                    Mtx flowerMtx;
+                    GXLoadPosMtxImm(get_model_mtx(sp34->m_modelMtx, flowerMtx), 0);
+#else
+                    GXLoadPosMtxImm(sp34->m_modelMtx, 0);
 #endif
-                    {
-                        GXLoadPosMtxImm(sp34->m_modelMtx, 0);
-                    }
                     GXLoadNrmMtxImm(j3dSys.getViewMtx(), 0);
 #if TARGET_PC
                     GXLoadTexObj(&mTexObj_l_J_Ohana01_64128_0419TEX, GX_TEXMAP0);
@@ -1369,9 +1455,13 @@ void dFlower_packet_c::update() {
                 
                 mDoMtx_stack_c::copy(temp_r28);
                 mDoMtx_stack_c::scaleM(temp_f31, temp_f31, temp_f31);
+#if TARGET_PC
+                cMtx_copy(temp_r28, data_p->m_modelMtx);
+#else
                 cMtx_concat(j3dSys.getViewMtx(), temp_r28, data_p->m_modelMtx);
+#endif
 #ifdef TARGET_PC
-                dusk::frame_interp::record_final_mtx(temp_r28, data_p->m_modelMtx);
+                dusk::interp::record_final_mtx(temp_r28, data_p->m_modelMtx);
 #endif
             }
         }
diff --git a/src/d/actor/d_grass.inc b/src/d/actor/d_grass.inc
index 9e8c360518..fd911083f4 100644
--- a/src/d/actor/d_grass.inc
+++ b/src/d/actor/d_grass.inc
@@ -11,18 +11,44 @@
 #include "d/d_camera.h"
 #include "f_op/f_op_camera_mng.h"
 
-#include "dusk/frame_interpolation.h"
-
-const u16 l_M_Hijiki00TEX__width = 31;
-const u16 l_M_Hijiki00TEX__height = 31;
-const u16 l_M_kusa05_RGBATEX__width = 31;
-const u16 l_M_kusa05_RGBATEX__height = 31;
-
 #if TARGET_PC
 #include "dusk/dvd_asset.hpp"
+#include "dusk/interp/frame_interpolation.h"
+
 using GameVersion = dusk::version::GameVersion;
-static u8* l_M_kusa05_RGBATEX_get() { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x7680}, {GameVersion::GcnPal, 0x7680}}, 0x800), true); return buf; }
-static u8* l_M_Hijiki00TEX_get()    { static u8 buf[0x800]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x7E80}, {GameVersion::GcnPal, 0x7E80}}, 0x800), true); return buf; }
+
+template <typename T, size_t N>
+static bool LoadGrassAsset(T (&dst)[N], std::initializer_list<dusk::OffsetVersion> offset) {
+    return dusk::LoadArchivedRelAsset(dst, 'AMEM', "d_a_grass.rel", offset);
+}
+
+#define DEFINE_GRASS_ASSET(name, type, count, ...)                                                 \
+    static type* name##_get() {                                                                    \
+        static type buf[count];                                                                    \
+        static bool _ = (LoadGrassAsset(buf, __VA_ARGS__), true);                                  \
+        return buf;                                                                                \
+    }
+
+DEFINE_GRASS_ASSET(l_M_kusa05_RGBATEX, u8, 0x800, {
+    {GameVersion::GcnUsa,     0x7680},
+    {GameVersion::GcnPal,     0x7680},
+    {GameVersion::GcnJpn,     0x7680},
+    {GameVersion::WiiUsaRev0, 0x6180},
+    {GameVersion::WiiUsa,     0x61E0},
+    {GameVersion::WiiPal,     0x61E0},
+    {GameVersion::WiiJpn,     0x61E0},
+});
+
+DEFINE_GRASS_ASSET(l_M_Hijiki00TEX, u8, 0x800, {
+    {GameVersion::GcnUsa,     0x7E80},
+    {GameVersion::GcnPal,     0x7E80},
+    {GameVersion::GcnJpn,     0x7E80},
+    {GameVersion::WiiUsaRev0, 0x6980},
+    {GameVersion::WiiUsa,     0x69E0},
+    {GameVersion::WiiPal,     0x69E0},
+    {GameVersion::WiiJpn,     0x69E0},
+});
+
 #define l_M_kusa05_RGBATEX (l_M_kusa05_RGBATEX_get())
 #define l_M_Hijiki00TEX    (l_M_Hijiki00TEX_get())
 #else
@@ -30,6 +56,11 @@ static u8* l_M_Hijiki00TEX_get()    { static u8 buf[0x800]; static bool _ = (dus
 #include "assets/l_M_Hijiki00TEX.h"     // ALIGN 32
 #endif
 
+const u16 l_M_Hijiki00TEX__width = 31;
+const u16 l_M_Hijiki00TEX__height = 31;
+const u16 l_M_kusa05_RGBATEX__width = 31;
+const u16 l_M_kusa05_RGBATEX__height = 31;
+
 static u8 l_pos[960] = {
     0x3F, 0x4A, 0x56, 0xEF, 0xC2, 0x20, 0x00, 0x00, 0x41, 0xFB, 0x17, 0xE4, 0x41, 0xAA, 0xBB, 0xEA,
     0xC2, 0x20, 0x00, 0x00, 0xC1, 0xB7, 0x03, 0x7A, 0x42, 0x55, 0x8D, 0x6F, 0x43, 0x13, 0x16, 0x3F,
@@ -114,14 +145,66 @@ static u8 l_texCoord[160] = {
 };
 
 #if TARGET_PC
-using GameVersion = dusk::version::GameVersion;
+DEFINE_GRASS_ASSET(l_M_Kusa_9qDL, u8, 0xCB, {
+    {GameVersion::GcnUsa,     0x8B00},
+    {GameVersion::GcnPal,     0x8B00},
+    {GameVersion::GcnJpn,     0x8B00},
+    {GameVersion::WiiUsaRev0, 0x7600},
+    {GameVersion::WiiUsa,     0x7660},
+    {GameVersion::WiiPal,     0x7660},
+    {GameVersion::WiiJpn,     0x7660},
+});
+
+DEFINE_GRASS_ASSET(l_M_Kusa_9q_cDL, u8, 0xCB, {
+    {GameVersion::GcnUsa,     0x8BE0},
+    {GameVersion::GcnPal,     0x8BE0},
+    {GameVersion::GcnJpn,     0x8BE0},
+    {GameVersion::WiiUsaRev0, 0x76E0},
+    {GameVersion::WiiUsa,     0x7740},
+    {GameVersion::WiiPal,     0x7740},
+    {GameVersion::WiiJpn,     0x7740},
+});
+
+DEFINE_GRASS_ASSET(l_M_TenGusaDL, u8, 0xD4, {
+    {GameVersion::GcnUsa,     0x8CC0},
+    {GameVersion::GcnPal,     0x8CC0},
+    {GameVersion::GcnJpn,     0x8CC0},
+    {GameVersion::WiiUsaRev0, 0x77C0},
+    {GameVersion::WiiUsa,     0x7820},
+    {GameVersion::WiiPal,     0x7820},
+    {GameVersion::WiiJpn,     0x7820},
+});
+
+DEFINE_GRASS_ASSET(l_Tengusa_matDL, u8, 0xA8, {
+    {GameVersion::GcnUsa,     0x8DA0},
+    {GameVersion::GcnPal,     0x8DA0},
+    {GameVersion::GcnJpn,     0x8DA0},
+    {GameVersion::WiiUsaRev0, 0x78A0},
+    {GameVersion::WiiUsa,     0x7900},
+    {GameVersion::WiiPal,     0x7900},
+    {GameVersion::WiiJpn,     0x7900},
+});
+
+DEFINE_GRASS_ASSET(l_kusa9q_matDL, u8, 0xA8, {
+    {GameVersion::GcnUsa,     0x8E60},
+    {GameVersion::GcnPal,     0x8E60},
+    {GameVersion::GcnJpn,     0x8E60},
+    {GameVersion::WiiUsaRev0, 0x7960},
+    {GameVersion::WiiUsa,     0x79C0},
+    {GameVersion::WiiPal,     0x79C0},
+    {GameVersion::WiiJpn,     0x79C0},
+});
+
+DEFINE_GRASS_ASSET(l_kusa9q_l4_matDL, u8, 0xA8, {
+    {GameVersion::GcnUsa,     0x8F20},
+    {GameVersion::GcnPal,     0x8F20},
+    {GameVersion::GcnJpn,     0x8F20},
+    {GameVersion::WiiUsaRev0, 0x7A20},
+    {GameVersion::WiiUsa,     0x7A80},
+    {GameVersion::WiiPal,     0x7A80},
+    {GameVersion::WiiJpn,     0x7A80},
+});
 
-static u8* l_M_Kusa_9qDL_get()     { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8B00}, {GameVersion::GcnPal, 0x8B00}}, 0xCB),  true); return buf; }
-static u8* l_M_Kusa_9q_cDL_get()   { static u8 buf[0xCB]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8BE0}, {GameVersion::GcnPal, 0x8BE0}}, 0xCB),  true); return buf; }
-static u8* l_M_TenGusaDL_get()     { static u8 buf[0xD4]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8CC0}, {GameVersion::GcnPal, 0x8CC0}}, 0xD4),  true); return buf; }
-static u8* l_Tengusa_matDL_get()   { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8DA0}, {GameVersion::GcnPal, 0x8DA0}}, 0xA8),  true); return buf; }
-static u8* l_kusa9q_matDL_get()    { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8E60}, {GameVersion::GcnPal, 0x8E60}}, 0xA8),  true); return buf; }
-static u8* l_kusa9q_l4_matDL_get() { static u8 buf[0xA8]; static bool _ = (dusk::LoadArchivedRelAsset(buf, 'AMEM', "d_a_grass.rel", {{GameVersion::GcnUsa, 0x8F20}, {GameVersion::GcnPal, 0x8F20}}, 0xA8),  true); return buf; }
 #define l_M_Kusa_9qDL     (l_M_Kusa_9qDL_get())
 #define l_M_Kusa_9q_cDL   (l_M_Kusa_9q_cDL_get())
 #define l_M_TenGusaDL     (l_M_TenGusaDL_get())
@@ -513,9 +596,9 @@ dGrass_packet_c::dGrass_packet_c() {
     field_0x1d714 = 0;
 
 #if TARGET_PC
-    dusk::batch::decode_leaf_template(mp_Mkusa_9q_DL, m_Mkusa_9q_DL_size, mTplKusa9q);
-    dusk::batch::decode_leaf_template(mp_Mkusa_9q_cDL, m_Mkusa_9q_cDL_size, mTplKusa9qCut);
-    dusk::batch::decode_leaf_template(l_M_TenGusaDL, 0xC0, mTplTengusa);
+    batch::decode_leaf_template(mp_Mkusa_9q_DL, m_Mkusa_9q_DL_size, mTplKusa9q);
+    batch::decode_leaf_template(mp_Mkusa_9q_cDL, m_Mkusa_9q_cDL_size, mTplKusa9qCut);
+    batch::decode_leaf_template(l_M_TenGusaDL, 0xC0, mTplTengusa);
 #endif
 
     OS_REPORT("草群メモリ=%fＫ\n", 117.7734375f);
@@ -525,15 +608,16 @@ dGrass_packet_c::dGrass_packet_c() {
 
 #if TARGET_PC
 static MtxP get_model_mtx(Mtx modelMtx, Mtx storage) {
-    if (dusk::frame_interp::lookup_replacement(modelMtx, storage)) {
+    if (dusk::interp::lookup_replacement(modelMtx, storage)) {
         cMtx_concat(j3dSys.getViewMtx(), storage, storage);
-        return storage;
+    } else {
+        cMtx_concat(j3dSys.getViewMtx(), modelMtx, storage);
     }
-    return modelMtx;
+    return storage;
 }
 
 static void transform_positions(
-    const dusk::batch::LeafTemplate& tpl, const Vec* posArray, const Mtx mtx, Vec* xfPos) {
+    const batch::LeafTemplate& tpl, const Vec* posArray, const Mtx mtx, Vec* xfPos) {
     for (u32 i = 0; i < tpl.posRefCount; i++) {
         const u8 idx = tpl.posRefs[i];
         MTXMultVec(mtx, &posArray[idx], &xfPos[idx]);
@@ -609,10 +693,10 @@ static GXColor blade_amb_color(const dGrass_data_c* blade, const dKy_tevstr_c* t
     return amb;
 }
 
-static void blade_emit(const dusk::batch::LeafTemplate& tpl, const Vec* xformedPos,
+static void blade_emit(const batch::LeafTemplate& tpl, const Vec* xformedPos,
                              const GXColor* colors, GXColor amb) {
     for (u32 i = 0; i < tpl.vtxCount; i++) {
-        const dusk::batch::LeafTemplate::Vtx& v = tpl.vtx[i];
+        const batch::LeafTemplate::Vtx& v = tpl.vtx[i];
         const Vec& p = xformedPos[v.pos];
         GXPosition3f32(p.x, p.y, p.z);
         GXNormal1x8(v.nrm);
@@ -765,7 +849,7 @@ void dGrass_packet_c::draw() {
         for (int bucket = 0; bucket < 4; bucket++) {
             const bool kusaTex = bucket < 2;
             const bool cut = (bucket & 1) != 0;
-            const dusk::batch::LeafTemplate& tpl =
+            const batch::LeafTemplate& tpl =
                 cut ? mTplKusa9qCut : (kusaTex ? mTplKusa9q : mTplTengusa);
 
             bool open = false;
@@ -1110,16 +1194,12 @@ void dGrass_packet_c::draw() {
                 GXSetChanAmbColor(GX_COLOR0A0, sp38);
 
                 if (!cLib_checkBit<u8>(var_r29->field_0x01, 2)) {
-#ifdef TARGET_PC
-                    Mtx grass_mtx;
-                    if (dusk::frame_interp::lookup_replacement(reinterpret_cast<const void*>(&var_r29->m_modelMtx), grass_mtx)) {
-                        cMtx_concat(j3dSys.getViewMtx(), grass_mtx, grass_mtx);
-                        GXLoadPosMtxImm(grass_mtx, 0);
-                    } else
+#if TARGET_PC
+                    Mtx grassMtx;
+                    GXLoadPosMtxImm(get_model_mtx(var_r29->m_modelMtx, grassMtx), 0);
+#else
+                    GXLoadPosMtxImm(var_r29->m_modelMtx, 0);
 #endif
-                    {
-                        GXLoadPosMtxImm(var_r29->m_modelMtx, 0);
-                    }
                     GXLoadNrmMtxImm(j3dSys.getViewMtx(), 0);
                     if (var_r29->field_0x05 <= 3 || var_r29->field_0x05 >= 10) {
                         if (var_r29->field_0x02 < -1) {
@@ -1362,7 +1442,11 @@ void dGrass_packet_c::update() {
                         }
                     }
 
+#if TARGET_PC
+                    cMtx_copy(mDoMtx_stack_c::get(), data_p->m_modelMtx);
+#else
                     cMtx_concat(j3dSys.getViewMtx(), mDoMtx_stack_c::get(), data_p->m_modelMtx);
+#endif
                 } else {
                     mDoMtx_stack_c::transS(data_p->m_pos.x, data_p->m_pos.y, data_p->m_pos.z);
                     mDoMtx_stack_c::YrotM(i * 3535);
@@ -1373,11 +1457,13 @@ void dGrass_packet_c::update() {
 
                     f32 scale = ((((s16)data_p->m_pos.x * 3535) & 0xFFF) / 4096.0f) * 0.3f + 0.7f;
                     mDoMtx_stack_c::scaleM(scale, scale, scale);
+#if TARGET_PC
+                    cMtx_copy(mDoMtx_stack_c::get(), data_p->m_modelMtx);
+#else
                     cMtx_concat(j3dSys.getViewMtx(), mDoMtx_stack_c::get(), data_p->m_modelMtx);
-                }
-#ifdef TARGET_PC
-                dusk::frame_interp::record_final_mtx(mDoMtx_stack_c::get(), data_p->m_modelMtx);
 #endif
+                }
+                IF_DUSK(dusk::interp::record_final_mtx(mDoMtx_stack_c::get(), data_p->m_modelMtx));
             }
         }
         data_p++;
diff --git a/src/d/d_a_horse_static.cpp b/src/d/d_a_horse_static.cpp
index 1c196043ed..e4db3519a9 100644
--- a/src/d/d_a_horse_static.cpp
+++ b/src/d/d_a_horse_static.cpp
@@ -50,4 +50,4 @@ void e_wb_class::setRunRideMode() {
     }
 }
 
-daTagHstop_c* daTagHstop_c::m_top;
+DUSK_GAME_DATA daTagHstop_c* daTagHstop_c::m_top;
diff --git a/src/d/d_a_itembase_static.cpp b/src/d/d_a_itembase_static.cpp
index 9099c5a147..ec3610a787 100644
--- a/src/d/d_a_itembase_static.cpp
+++ b/src/d/d_a_itembase_static.cpp
@@ -50,17 +50,24 @@ bool daItemBase_c::chkDead() {
 int CheckItemCreateHeap(fopAc_ac_c* i_this) {
     daItemBase_c* a_this = static_cast<daItemBase_c*>(i_this);
 
-    u8 item_no = a_this->getItemNo();
+    u8 item_no = DUSK_IF_ELSE(a_this->getDisplayItemNo(), a_this->getItemNo());
     return a_this->CreateItemHeap(dItem_data::getArcName(item_no), dItem_data::getBmdName(item_no),
                                   dItem_data::getBtkName(item_no), dItem_data::getBpkName(item_no),
                                   dItem_data::getBckName(item_no), dItem_data::getBxaName(item_no),
                                   dItem_data::getBrkName(item_no), dItem_data::getBtpName(item_no));
 }
 
+#if TARGET_PC
+const char* dItem_fieldModelArc(u8 itemNo) {
+    const char* arcName = dItem_data::getFieldArc(itemNo);
+    return arcName != NULL ? arcName : dItem_data::getArcName(itemNo);
+}
+#endif
+
 int CheckFieldItemCreateHeap(fopAc_ac_c* i_this) {
     daItemBase_c* a_this = static_cast<daItemBase_c*>(i_this);
 
-    u8 item_no = a_this->getItemNo();
+    u8 item_no = DUSK_IF_ELSE(a_this->getDisplayItemNo(), a_this->getItemNo());
     return a_this->CreateItemHeap(
         dItem_data::getFieldArc(item_no), dItem_data::getItemBmdName(item_no),
         dItem_data::getItemBtkName(item_no), dItem_data::getItemBpkName(item_no),
@@ -68,7 +75,7 @@ int CheckFieldItemCreateHeap(fopAc_ac_c* i_this) {
         dItem_data::getItemBrkName(item_no), dItem_data::getItemBtpName(item_no));
 }
 
-const daItemBase_data daItemBase_c::m_data = {
+DUSK_GAME_DATA const daItemBase_data daItemBase_c::m_data = {
     -4.5f,  // mGravity
     0.62f,  // mGroundReflect
     45.0f,  // mLaunchSpeed
diff --git a/src/d/d_a_shop_item_static.cpp b/src/d/d_a_shop_item_static.cpp
index 902e09a9c4..635f07f5ec 100644
--- a/src/d/d_a_shop_item_static.cpp
+++ b/src/d/d_a_shop_item_static.cpp
@@ -15,7 +15,7 @@ cXyz* daShopItem_c::getPosP() {
     return &current.pos;
 }
 
-ResourceData const daShopItem_c::mData[23] = {
+DUSK_GAME_DATA ResourceData const daShopItem_c::mData[23] = {
     {"B_mD_sold", 3, -1, -1, -1, -1, -1, -1, 0.0f, 1.0f, 0, {0, -0x8000, 0}, 0, 0, 0, 0, -1, -1},
     {"B_mD_oil", 3, -1, -1, -1, -1, -1, -1, 0.0f, 1.0f, 0, {0, 0, 0}, 0, 0, 0, 0, -1, -1},
     {"O_mD_red", 3, -1, -1, -1, -1, -1, -11, 0.0f, 1.0f, 0, {0, 0, 0}, 0, 0, 0, 0, -1, -1},
@@ -45,6 +45,12 @@ int CheckShopItemCreateHeap(fopAc_ac_c* i_this) {
     daShopItem_c* a_this1 = static_cast<daShopItem_c*>(i_this);
     daShopItem_c* a_this2 = static_cast<daShopItem_c*>(i_this);
 
+#if TARGET_PC
+    const ResourceData& data = a_this2->getResourceData();
+    return a_this1->CreateItemHeap(data.get_arcName(), data.get_bmdName(), data.get_btk1Name(),
+        data.get_bpk1Name(), data.get_bck1Name(), data.get_bxa1Name(), data.get_brk1Name(),
+        data.get_btp1Name());
+#else
     u8 a_ShopItemID = a_this2->getShopItemID();
     return a_this1->CreateItemHeap(daShopItem_c::mData[a_ShopItemID].get_arcName(),
                                   daShopItem_c::mData[a_ShopItemID].get_bmdName(),
@@ -54,4 +60,5 @@ int CheckShopItemCreateHeap(fopAc_ac_c* i_this) {
                                   daShopItem_c::mData[a_ShopItemID].get_bxa1Name(),
                                   daShopItem_c::mData[a_ShopItemID].get_brk1Name(),
                                   daShopItem_c::mData[a_ShopItemID].get_btp1Name());
+#endif
 }
diff --git a/src/d/d_att_dist.cpp b/src/d/d_att_dist.cpp
index d2b9ac2b1b..761eb1074c 100644
--- a/src/d/d_att_dist.cpp
+++ b/src/d/d_att_dist.cpp
@@ -3,7 +3,7 @@
 #include "d/d_att_dist.h"
 #include "d/d_attention.h"
 
-dist_entry dAttention_c::dist_table[234] = {
+DUSK_GAME_DATA dist_entry dAttention_c::dist_table[234] = {
     {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.01f, 0},
     {250.0f, 375.0f, 500.0f, 400.0f, -400.0f, 0.5f, 0},
     {187.5f, 250.0f, 312.5f, 300.0f, -300.0f, 1.0f, 0},
diff --git a/src/d/d_attention.cpp b/src/d/d_attention.cpp
index 1bb9e84f70..beea40e806 100644
--- a/src/d/d_attention.cpp
+++ b/src/d/d_attention.cpp
@@ -41,13 +41,13 @@ static bool padLockButton(s32 i_padNo) {
 }
 }  // namespace
 
-type_tbl_entry dAttention_c::loc_type_tbl[3] = {
+DUSK_GAME_DATA type_tbl_entry dAttention_c::loc_type_tbl[3] = {
     {fopAc_attn_LOCK_e, fopAc_AttnFlag_LOCK_e},
     {fopAc_attn_TALK_e, fopAc_AttnFlag_TALK_e},
     {fopAc_attn_BATTLE_e, fopAc_AttnFlag_BATTLE_e},
 };
 
-type_tbl_entry dAttention_c::act_type_tbl[5] = {
+DUSK_GAME_DATA type_tbl_entry dAttention_c::act_type_tbl[5] = {
     {fopAc_attn_SPEAK_e, fopAc_AttnFlag_SPEAK_e},
     {fopAc_attn_CARRY_e, fopAc_AttnFlag_CARRY_e},
     {fopAc_attn_DOOR_e, fopAc_AttnFlag_DOOR_e},
@@ -157,7 +157,7 @@ int dAttDraw_CallBack_c::execute(u16 param_0, J3DTransformInfo* transform) {
     return 1;
 }
 
-dAttDrawParam_c g_AttDwHIO;
+DUSK_GAME_DATA dAttDrawParam_c g_AttDwHIO;
 
 dAttention_c::dAttention_c(fopAc_ac_c* i_player, u32 i_padNo) {
     mpPlayer = i_player;
@@ -339,7 +339,7 @@ dAttList_c* dAttention_c::getActionBtnXY() {
     return NULL;
 }
 
-int dAttention_c::loc_type_num = 3;
+DUSK_GAME_DATA int dAttention_c::loc_type_num = 3;
 
 int dAttention_c::chkAttMask(u32 i_type, u32 i_mask) {
     int i;
@@ -375,13 +375,13 @@ static int check_event_condition(u32 i_attnType, u16 i_condition) {
     return false;
 }
 
-int dAttention_c::act_type_num = 5;
+DUSK_GAME_DATA int dAttention_c::act_type_num = 5;
 
-type_tbl_entry dAttention_c::chk_type_tbl[1] = {
+DUSK_GAME_DATA type_tbl_entry dAttention_c::chk_type_tbl[1] = {
     {fopAc_attn_CHECK_e, fopAc_AttnFlag_CHECK_e},
 };
 
-int dAttention_c::chk_type_num = 1;
+DUSK_GAME_DATA int dAttention_c::chk_type_num = 1;
 
 static bool attn_opt_hold = true;
 
diff --git a/src/d/d_bg_parts.cpp b/src/d/d_bg_parts.cpp
index 9dc7be181d..50eb634c25 100644
--- a/src/d/d_bg_parts.cpp
+++ b/src/d/d_bg_parts.cpp
@@ -8,7 +8,9 @@
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 void dBgp_c::material_c::draw() {
     material_c* material = this;
@@ -222,8 +224,8 @@ dBgp_c::share_c::share_c() {
     mCount = 0;
 }
 
-JKRSolidHeap* dBgp_c::mShareHeap;
-dBgp_c::share_c* dBgp_c::mShare;
+DUSK_GAME_DATA JKRSolidHeap* dBgp_c::mShareHeap;
+DUSK_GAME_DATA dBgp_c::share_c* dBgp_c::mShare;
 
 void dBgp_c::share_c::set(u16 i_id) {
     JUT_ASSERT(441, mCount != static_cast<u16>(~0));
diff --git a/src/d/d_bg_s.cpp b/src/d/d_bg_s.cpp
index f48c58fead..23f87e4e4c 100644
--- a/src/d/d_bg_s.cpp
+++ b/src/d/d_bg_s.cpp
@@ -11,12 +11,14 @@
 #include "d/d_com_inf_game.h"
 #include "f_op/f_op_actor_mng.h"
 
+#if TARGET_PC || DEBUG
 #include "d/d_debug_viewer.h"
 #include "d/d_bg_s_capt_poly.h"
+#endif
 
 #if TARGET_PC
-#include "dusk/offset_ptr.h"
 #include "dusk/settings.h"
+#include "helpers/offset_ptr.h"
 #endif
 
 #if DEBUG
@@ -30,7 +32,6 @@ int g_sph_counter;
 int g_capt_poly_counter;
 #endif
 
-
 void dBgS_HIO::genMessage(JORMContext* mctx) {
 #if DEBUG
     mctx->genLabel("zelda地形チェック", 0);
diff --git a/src/d/d_bg_s_movebg_actor.cpp b/src/d/d_bg_s_movebg_actor.cpp
index 176beadb73..5d5aa13203 100644
--- a/src/d/d_bg_s_movebg_actor.cpp
+++ b/src/d/d_bg_s_movebg_actor.cpp
@@ -51,11 +51,11 @@ int dBgS_MoveBgActor::ToBack() {
     return 1;
 }
 
-const char* dBgS_MoveBgActor::m_name;
+DUSK_GAME_DATA const char* dBgS_MoveBgActor::m_name;
 
-int dBgS_MoveBgActor::m_dzb_id;
+DUSK_GAME_DATA int dBgS_MoveBgActor::m_dzb_id;
 
-MoveBGActor_SetFunc dBgS_MoveBgActor::m_set_func;
+DUSK_GAME_DATA MoveBGActor_SetFunc dBgS_MoveBgActor::m_set_func;
 
 int dBgS_MoveBgActor::MoveBGCreateHeap() {
     if (!CreateHeap()) {
diff --git a/src/d/d_bg_w.cpp b/src/d/d_bg_w.cpp
index ecbc7fa6d3..64a2df2afd 100644
--- a/src/d/d_bg_w.cpp
+++ b/src/d/d_bg_w.cpp
@@ -2485,5 +2485,5 @@ dBgW* dBgW_NewSet(cBgD_t* pbgd, u32 flags, Mtx* pbase_mtx) {
     return nw;
 }
 
-extern u8 struct_80450F88[8];
-u8 struct_80450F88[8];
+DUSK_GAME_EXTERN u8 struct_80450F88[8];
+DUSK_GAME_DATA u8 struct_80450F88[8];
diff --git a/src/d/d_bright_check.cpp b/src/d/d_bright_check.cpp
index ccb04c69e5..17c6f77267 100644
--- a/src/d/d_bright_check.cpp
+++ b/src/d/d_bright_check.cpp
@@ -9,11 +9,16 @@
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
 #include "d/d_msg_string.h"
-#include "dusk/livesplit.h"
-#include "dusk/imgui/ImGuiConsole.hpp"
-#include "dusk/speedrun.h"
 #include "m_Do/m_Do_controller_pad.h"
-#include <dusk/autosave.h>
+
+#if TARGET_PC
+#include "dusk/autosave.h"
+#include "dusk/game_mode.hpp"
+#include "dusk/imgui/ImGuiConsole.hpp"
+#include "dusk/livesplit.h"
+#include "dusk/speedrun.h"
+#include "dusk/version.hpp"
+#endif
 
 dBrightCheck_c::dBrightCheck_c(JKRArchive* i_archive) {
     mArchive = i_archive;
@@ -39,7 +44,16 @@ void dBrightCheck_c::screenSet() {
         MULTI_CHAR('font_a1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4'), MULTI_CHAR('font_at'),
     };
 
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    static u64 const txTV_jpn[] = {
+        MULTI_CHAR('menu_t6s'), MULTI_CHAR('menu_t6'),  MULTI_CHAR('menu_t9s'), MULTI_CHAR('menu_t9'),  MULTI_CHAR('menut10s'),
+        MULTI_CHAR('menu_t10'), MULTI_CHAR('menu_t7s'), MULTI_CHAR('menu_t7'),  MULTI_CHAR('menu_t8s'), MULTI_CHAR('menu_t8'),
+    };
+    static u64 const txTV[] = {
+        MULTI_CHAR('menu_t61'), MULTI_CHAR('menu_t2'),  MULTI_CHAR('menu_t91'), MULTI_CHAR('menu_t1'),  MULTI_CHAR('menut101'),
+        MULTI_CHAR('menu_t01'), MULTI_CHAR('menu_t71'), MULTI_CHAR('menu_t3'),  MULTI_CHAR('menu_t81'), MULTI_CHAR('menu_t4'),
+    };
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     static u64 const txTV[] = {
         MULTI_CHAR('menu_t6s'), MULTI_CHAR('menu_t6'),  MULTI_CHAR('menu_t9s'), MULTI_CHAR('menu_t9'),  MULTI_CHAR('menut10s'),
         MULTI_CHAR('menu_t10'), MULTI_CHAR('menu_t7s'), MULTI_CHAR('menu_t7'),  MULTI_CHAR('menu_t8s'), MULTI_CHAR('menu_t8'),
@@ -51,7 +65,14 @@ void dBrightCheck_c::screenSet() {
     };
     #endif
 
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    static u64 const txTVhide_jpn[] = {
+        MULTI_CHAR('fmenu_6n'), MULTI_CHAR('fmenu_9n'), MULTI_CHAR('fmenu_10'), MULTI_CHAR('fmenu_7n'), MULTI_CHAR('fmenu_8n'),
+    };
+    static u64 const txTVhide[] = {
+        MULTI_CHAR('menu_6n'), MULTI_CHAR('menu_9n'), MULTI_CHAR('menu_10n'), MULTI_CHAR('menu_7n'), MULTI_CHAR('menu_8n'),
+    };
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     static u64 const txTVhide[] = {
         MULTI_CHAR('fmenu_6n'), MULTI_CHAR('fmenu_9n'), MULTI_CHAR('fmenu_10'), MULTI_CHAR('fmenu_7n'), MULTI_CHAR('fmenu_8n'),
     };
@@ -65,9 +86,22 @@ void dBrightCheck_c::screenSet() {
     JUT_ASSERT(0, mBrightCheck.Scr != NULL);
     mBrightCheck.Scr->setPriority("zelda_option_check.blo", 0x1100000, mArchive);
 
+    IF_DUSK_BLOCK(dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn)
     mBrightCheck.Scr->search(MULTI_CHAR('g_abtn_n'))->hide();
+    IF_DUSK_BLOCK_END
 
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    J2DTextBox* settings_text;
+    if (dusk::version::isRegionJpn()) {
+        settings_text = (J2DTextBox*)mBrightCheck.Scr->search(MULTI_CHAR('t_t00'));
+        mBrightCheck.Scr->search(MULTI_CHAR('t_t00'))->show();
+        mBrightCheck.Scr->search(MULTI_CHAR('f_t00'))->hide();
+    } else {
+        settings_text = (J2DTextBox*)mBrightCheck.Scr->search(MULTI_CHAR('f_t00'));
+        mBrightCheck.Scr->search(MULTI_CHAR('f_t00'))->show();
+        mBrightCheck.Scr->search(MULTI_CHAR('t_t00'))->hide();
+    }
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     J2DTextBox* settings_text = (J2DTextBox*)mBrightCheck.Scr->search(MULTI_CHAR('t_t00'));
     mBrightCheck.Scr->search(MULTI_CHAR('t_t00'))->show();
     mBrightCheck.Scr->search(MULTI_CHAR('f_t00'))->hide();
@@ -83,7 +117,17 @@ void dBrightCheck_c::screenSet() {
 
     J2DTextBox* btna_text[5];
     for (int i = 0; i < 5; i++) {
-        #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+        #if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            btna_text[i] = (J2DTextBox*)mBrightCheck.Scr->search(tv_btnA[i]);
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mBrightCheck.Scr->search(ftv_btnA[i])->hide();
+            }
+        } else {
+            btna_text[i] = (J2DTextBox*)mBrightCheck.Scr->search(ftv_btnA[i]);
+            mBrightCheck.Scr->search(tv_btnA[i])->hide();
+        }
+        #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
         btna_text[i] = (J2DTextBox*)mBrightCheck.Scr->search(tv_btnA[i]);
         mBrightCheck.Scr->search(ftv_btnA[i])->hide();
         #else
@@ -97,15 +141,17 @@ void dBrightCheck_c::screenSet() {
     }
 
     for (int i = 0; i < 5; i++) {
-        mBrightCheck.Scr->search(txTVhide[i])->hide();
+        mBrightCheck.Scr->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? txTVhide_jpn[i] : txTVhide[i], txTVhide[i]))->hide();
     }
 
     for (int i = 0; i < 10; i++) {
-        J2DTextBox* check_text = (J2DTextBox*)mBrightCheck.Scr->search(txTV[i]);
+        J2DTextBox* check_text = (J2DTextBox*)mBrightCheck.Scr->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? txTV_jpn[i] : txTV[i], txTV[i]));
         check_text->setFont(mDoExt_getMesgFont());
 
-        #if (VERSION != VERSION_GCN_JPN) && (VERSION != VERSION_WII_JPN)
+        #if TARGET_PC || ((VERSION != VERSION_GCN_JPN) && (VERSION != VERSION_WII_JPN))
+        IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
         check_text->setCharSpace(0.0f);
+        IF_DUSK_BLOCK_END
         #endif
 
         if (i < 2) {
@@ -143,16 +189,15 @@ void dBrightCheck_c::modeMove() {
     if (mDoCPd_c::getTrigA(PAD_1) || mDoCPd_c::getTrigStart(PAD_1)) {
         mDoAud_seStart(Z2SE_ENTER_GAME, NULL, 0, 0);
 #ifdef TARGET_PC
-        if (dusk::getSettings().game.speedrunMode && !dusk::getSettings().game.hideTvSettingsScreen) {
-            // start a new run if a run isn't already in progress
-            if (!dusk::m_speedrunInfo.m_isRunStarted) {
-                dusk::resetForSpeedrunMode();
-                dusk::m_speedrunInfo.startRun();
-                dusk::speedrun::start();
+        toggleAutoSave(true);
+
+        if (!dusk::getSettings().game.hideTvSettingsScreen) {
+            const dusk::gamemode::GameMode* gameMode =
+            dusk::gamemode::getGameModeManager().getCurrentGameMode();
+            if (gameMode) {
+                gameMode->invokeOnSaveLoadedFunction();
             }
         }
-
-        toggleAutoSave(true);
 #endif
         mCompleteCheck = true;
         mMode = MODE_WAIT_e;
@@ -183,7 +228,9 @@ void dBrightCheck_c::brightCheckWide() {
 
     // Confirm A Button
     mBrightCheck.Scr->search(MULTI_CHAR('abtn_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
-    mBrightCheck.Scr->search(MULTI_CHAR('gcabtn_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+        mBrightCheck.Scr->search(MULTI_CHAR('gcabtn_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    }
 
     // Text
     mBrightCheck.Scr->search(MULTI_CHAR('menu_6n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
diff --git a/src/d/d_camera.cpp b/src/d/d_camera.cpp
index ed0de09b63..feb7148cc0 100644
--- a/src/d/d_camera.cpp
+++ b/src/d/d_camera.cpp
@@ -29,13 +29,18 @@
 #endif
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#include "dusk/logging.h"
 #include "dusk/action_bindings.h"
+#include "dusk/camera_operators.hpp"
+#include "dusk/commands.hpp"
+#include "dusk/game_clock.h"
+#include "dusk/interp/camera.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/logging.h"
 #include "dusk/mouse.h"
 #include "dusk/settings.h"
 #include "dusk/touch_camera.h"
-#include "imgui.h"
+
+#include <imgui.h>
 #endif
 
 namespace {
@@ -196,7 +201,7 @@ int dCamMapToolData::Set(s32 param_0, s32 roomNo, fopAc_ac_c* param_2, u16 param
     return 0;
 }
 
-engine_fn dCamera_c::engine_tbl[] = {
+DUSK_GAME_DATA engine_fn dCamera_c::engine_tbl[] = {
     &dCamera_c::letCamera,        &dCamera_c::chaseCamera,    &dCamera_c::lockonCamera,
     &dCamera_c::talktoCamera,     &dCamera_c::subjectCamera,  &dCamera_c::fixedPositionCamera,
     &dCamera_c::fixedFrameCamera, &dCamera_c::towerCamera,    &dCamera_c::rideCamera,
@@ -1053,7 +1058,12 @@ void dCamera_c::debugDrawInit() {
 bool dCamera_c::Run() {
 #if TARGET_PC
     ResetView();
-    if (executeDebugFlyCam()) {
+    if (dusk::isCameraDetached()) {
+        mFrameCounter++;
+        mTicks++;
+        return true;
+    }
+    if (executeDebugFlyCam() || dusk::mods::camera_run_operators(this)) {
         mFrameCounter++;
         mTicks++;
         return true;
@@ -7594,7 +7604,7 @@ bool dCamera_c::executeDebugFlyCam() {
             if (ImGui::IsKeyDown(ImGuiKey_Q)) rollInput -= 1.0f;
             if (ImGui::IsKeyDown(ImGuiKey_E)) rollInput += 1.0f;
         }
-        bool mouseValid = !io.WantCaptureMouse && io.MousePos.x >= 0.0f && io.MousePos.y >= 0.0f;
+        bool mouseValid = !io.WantCaptureMouse && io.MousePos.x >= 0.0f && io.MousePos.y >= 0.0f && ImGui::IsMouseDown(ImGuiMouseButton_Right);
         if (mouseValid && sFlyCamLastMousePos.x >= 0.0f) {
             cStickX -= (io.MousePos.x - sFlyCamLastMousePos.x) * 2.0f;
             cStickY -= (io.MousePos.y - sFlyCamLastMousePos.y) * 2.0f;
@@ -10495,13 +10505,13 @@ bool dCamera_c::eventCamera(s32 param_0) {
 #endif
 
 #if TARGET_PC
-        if (dusk::frame_interp::is_enabled()) {
+        if (dusk::interp::is_enabled()) {
             switch (var_r29) {
                 case 3:
                 case 4:
                 case 5:
                 case 12:
-                    dusk::frame_interp::request_presentation_sync();
+                    dusk::interp::request_presentation_sync();
                     break;
                 default:
                     DuskLog.debug(
@@ -11122,6 +11132,9 @@ camera_class* dCam_getCamera() {
 
 dCamera_c* dCam_getBody() {
     camera_process_class* camera = (camera_process_class*)dCam_getCamera();
+#if TARGET_PC
+    if (camera == nullptr) { return nullptr; }
+#endif
     return &camera->mCamera;
 }
 
@@ -11348,7 +11361,7 @@ void widezoom_correction(camera_process_class* i_this, float trim_height) {
             trim_width = FB_WIDTH_BASE / 2.0f * (1.0f - target_ar_real / current_ar);
         }
 
-        if (dusk::frame_interp::is_sim_frame()) {
+        if (dusk::game_clock::is_sim_frame()) {
             constexpr auto base_ar =
                 static_cast<f32>(FB_WIDTH_BASE) / static_cast<f32>(FB_HEIGHT_BASE);
             const auto ar_corr = base_ar / std::min(current_ar, target_ar_real);
@@ -11386,8 +11399,8 @@ static int camera_execute(camera_process_class* i_this) {
 #ifdef TARGET_PC
     widezoom_correction(i_this, i_this->mCamera.TrimHeight());
 
-    if (dusk::frame_interp::is_enabled()) {
-        dusk::frame_interp::add_interpolation_callback([](bool _, void* pUserWork) {
+    if (dusk::interp::is_enabled()) {
+        dusk::interp::add_interpolation_callback([](void* pUserWork) {
             const auto i_this = static_cast<camera_process_class*>(pUserWork);
             const auto camera = &i_this->mCamera;
 
@@ -11396,7 +11409,7 @@ static int camera_execute(camera_process_class* i_this) {
             if (camera->mCurState != 2 && trim_size >= 0 && trim_size <= 3) {
                 // derive trim height at previous tick using current camera state
                 const auto target = get_target_trim_height(i_this);
-                const auto step = dusk::frame_interp::get_interpolation_step();
+                const auto step = dusk::interp::get_interpolation_step();
                 const auto cur = camera->TrimHeight();
                 const auto prev = (4.0f * cur - target) / 3.0f;
                 const auto trim_height = prev + (cur - prev) * step;
@@ -11407,10 +11420,10 @@ static int camera_execute(camera_process_class* i_this) {
     }
 
     // record new camera for our sim frame
-    dusk::frame_interp::record_camera(i_this, get_camera_id(i_this));
+    dusk::interp::record_camera(i_this, get_camera_id(i_this));
     // interpolate the view now so that this sim frame's view matrix matches what
     // we'll be rendering with later
-    dusk::frame_interp::interp_view(&i_this->view);
+    dusk::interp::interp_view(&i_this->view);
 #endif
 
     view_setup(i_this);
diff --git a/src/d/d_cc_d.cpp b/src/d/d_cc_d.cpp
index 6cc5ab63e3..7edb0f9d07 100644
--- a/src/d/d_cc_d.cpp
+++ b/src/d/d_cc_d.cpp
@@ -259,7 +259,7 @@ u8 dCcD_GObjInf::GetTgHitObjSe() {
     }
 }
 
-Z2SoundID const dCcD_GObjInf::m_hitSeID[24] = {
+DUSK_GAME_DATA Z2SoundID const dCcD_GObjInf::m_hitSeID[24] = {
     Z2SE_HIT_DUMMY_CANCEL,    Z2SE_HIT_SWORD,          Z2SE_HIT_SHIELD_ATTACK,
     Z2SE_HIT_WOLFKICK,        Z2SE_HIT_WOLFBITE,       Z2SE_HIT_WOOD_WEAPON,
     Z2SE_HIT_HAMMER,          Z2SE_HIT_ARROW_STICK,    Z2SE_HIT_HOOKSHOT_STICK,
diff --git a/src/d/d_cc_s.cpp b/src/d/d_cc_s.cpp
index 2a19de3dda..6a1d0c332c 100644
--- a/src/d/d_cc_s.cpp
+++ b/src/d/d_cc_s.cpp
@@ -872,7 +872,7 @@ void dCcS::MassClear() {
 }
 
 // clang-format off
-bool dCcS::m_mtrl_hit_tbl[64] = {
+DUSK_GAME_DATA bool dCcS::m_mtrl_hit_tbl[64] = {
     true,  true,  true,  true,  true,  true,  true,  true, 
     false, true,  false, false, false, false, false, false,
     false, false, true,  false, false, false, false, false,
diff --git a/src/d/d_com_inf_actor.cpp b/src/d/d_com_inf_actor.cpp
index 772ad8542a..0c80f9b1ab 100644
--- a/src/d/d_com_inf_actor.cpp
+++ b/src/d/d_com_inf_actor.cpp
@@ -8,11 +8,11 @@
 #include "d/d_com_inf_actor.h"
 #include <types.h>
 
-dComIfAc_info_c g_dComIfAc_gameInfo = {
+DUSK_GAME_DATA dComIfAc_info_c g_dComIfAc_gameInfo = {
     0,      // field_0x0
     false,  // mPause
 };
 
-dComIfGoat_info_c g_dComIfGoat_gameInfo = {
+DUSK_GAME_DATA dComIfGoat_info_c g_dComIfGoat_gameInfo = {
     NULL, // field_0x0
 };
diff --git a/src/d/d_com_inf_game.cpp b/src/d/d_com_inf_game.cpp
index 93fc15ca8f..8b3f0bde1d 100644
--- a/src/d/d_com_inf_game.cpp
+++ b/src/d/d_com_inf_game.cpp
@@ -19,14 +19,19 @@
 #include "d/d_timer.h"
 #include "f_op/f_op_msg_mng.h"
 #include "f_op/f_op_scene_mng.h"
-#include "m_Do/m_Do_MemCard.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_graphic.h"
 #include <cstdio>
 #include <cstring>
 
-#include "dusk/string.hpp"
+
+#if TARGET_PC
+#include "dusk/settings.h"
+#include "helpers/string.hpp"
+
+#include "m_Do/m_Do_MemCard.h"
+#endif
 
 void dComIfG_play_c::ct() {
     mWindowNum = 0;
@@ -1207,9 +1212,9 @@ void dComIfG_inf_c::createBaseCsr() {
 }
 #endif
 
-GXColor g_clearColor = {0, 0, 0, 0};
+DUSK_GAME_DATA GXColor g_clearColor = {0, 0, 0, 0};
 
-GXColor g_blackColor = {0, 0, 0, 255};
+DUSK_GAME_DATA GXColor g_blackColor = {0, 0, 0, 255};
 
 int dComIfG_changeOpeningScene(scene_class* i_scene, s16 i_procName) {
     dComIfGp_offEnableNextStage();
@@ -1228,7 +1233,7 @@ int dComIfG_changeOpeningScene(scene_class* i_scene, s16 i_procName) {
     return 1;
 }
 
-dComIfG_inf_c g_dComIfG_gameInfo;
+DUSK_GAME_DATA dComIfG_inf_c g_dComIfG_gameInfo;
 
 BOOL dComIfG_resetToOpening(scene_class* i_scene) {
     #if PLATFORM_WII || VERSION == VERSION_SHIELD_DEBUG
@@ -1241,12 +1246,12 @@ BOOL dComIfG_resetToOpening(scene_class* i_scene) {
     }
     #endif
 
-    #ifdef TARGET_PC
+#if TARGET_PC
     if (!mDoMemCd_isCardCommNone()) {
         return 0;
     }
     g_mDoMemCd_control.SaveSync();
-    #endif
+#endif
 
     dComIfG_changeOpeningScene(i_scene, fpcNm_OPENING_SCENE_e);
     mDoAud_bgmStop(30);
@@ -1499,7 +1504,11 @@ static void dummy1() {
 }
 
 BOOL dComIfGs_isStageTbox(int i_stageNo, int i_no) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         return dComIfGs_isTbox(i_no);
     } else {
         return dComIfGs_isSaveTbox(i_stageNo, i_no);
@@ -1507,7 +1516,11 @@ BOOL dComIfGs_isStageTbox(int i_stageNo, int i_no) {
 }
 
 void dComIfGs_onStageSwitch(int i_stageNo, int i_no) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         dComIfGs_onSwitch(i_no, -1);
     }
 
@@ -1523,7 +1536,11 @@ void dComIfGs_offStageSwitch(int i_stageNo, int i_no) {
 }
 
 BOOL dComIfGs_isStageSwitch(int i_stageNo, int i_no) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         return dComIfGs_isSwitch(i_no, -1);
     } else {
         return dComIfGs_isSaveSwitch(i_stageNo, i_no);
@@ -1531,7 +1548,11 @@ BOOL dComIfGs_isStageSwitch(int i_stageNo, int i_no) {
 }
 
 void dComIfGs_onDungeonItemMap(int i_stageNo) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         dComIfGs_onDungeonItemMap();
     }
 
@@ -1547,7 +1568,11 @@ void dComIfGs_offDungeonItemMap(int i_stageNo) {
 }
 
 s32 dComIfGs_isDungeonItemMap(int i_stageNo) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         return dComIfGs_isDungeonItemMap();
     }
 
@@ -1555,7 +1580,11 @@ s32 dComIfGs_isDungeonItemMap(int i_stageNo) {
 }
 
 void dComIfGs_onDungeonItemCompass(int i_stageNo) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         dComIfGs_onDungeonItemCompass();
     }
 
@@ -1571,7 +1600,11 @@ void dComIfGs_offDungeonItemCompass(int i_stageNo) {
 }
 
 s32 dComIfGs_isDungeonItemCompass(int i_stageNo) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         return dComIfGs_isDungeonItemCompass();
     }
 
@@ -1579,7 +1612,11 @@ s32 dComIfGs_isDungeonItemCompass(int i_stageNo) {
 }
 
 void dComIfGs_onDungeonItemBossKey(int i_stageNo) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         dComIfGs_onDungeonItemBossKey();
     }
 
@@ -1595,7 +1632,11 @@ void dComIfGs_offDungeonItemBossKey(int i_stageNo) {
 }
 
 s32 dComIfGs_isDungeonItemBossKey(int i_stageNo) {
+#if TARGET_PC
+    if (dComIfGp_getStageStagInfo() && i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#else
     if (i_stageNo == dStage_stagInfo_GetSaveTbl(dComIfGp_getStageStagInfo())) {
+#endif
         return dComIfGs_isDungeonItemBossKey();
     }
 
@@ -2465,7 +2506,7 @@ struct field_data {
 };
 
 void dComIfGp_calcNowRegion() {
-    u8 buffer[0x800] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 buffer[0x800];
 
     dComIfGp_getFieldMapArchive2()->readResource(buffer, 0x800, "dat/field.dat");
     u8* entry_num_p = &buffer[((field_data_header*)buffer)->field_0x4];
@@ -2521,7 +2562,7 @@ void dComIfGp_calcNowRegion() {
 }
 
 u8 dComIfG_getNowCalcRegion() {
-    u8 buffer[0x800] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 buffer[0x800];
 
     dComIfGp_getFieldMapArchive2()->readResource(buffer, 0x800, "dat/field.dat");
     u8* entry_num_p = &buffer[((field_data_header*)buffer)->field_0x4];
@@ -2987,6 +3028,3618 @@ u8 dComIfGs_staffroll_next_go_check() {
     return envLight->staffroll_next_timer;
 }
 
-GXColor g_whiteColor = {255, 255, 255, 255};
+DUSK_GAME_DATA GXColor g_whiteColor = {255, 255, 255, 255};
 
-GXColor g_saftyWhiteColor = {160, 160, 160, 255};
+DUSK_GAME_DATA GXColor g_saftyWhiteColor = {160, 160, 160, 255};
+
+#if TARGET_PC
+dSv_info_c* dComIfGs_getSaveInfo() {
+    return &g_dComIfG_gameInfo.info;
+}
+
+dSv_save_c* dComIfGs_getSaveData() {
+    return &g_dComIfG_gameInfo.info.getSavedata();
+}
+
+u16 dComIfGs_getMaxLife() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getMaxLife();
+}
+
+void dComIfGs_setMaxLife(u8 i_maxLife) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setMaxLife(i_maxLife);
+}
+
+u16 dComIfGs_getLife() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getLife();
+}
+
+void dComIfGs_setLife(u16 i_life) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setLife(i_life);
+}
+
+u16 dComIfGs_getRupee() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getRupee();
+}
+
+void dComIfGs_setRupee(u16 i_rupees) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setRupee(i_rupees);
+}
+
+u16 dComIfGs_getMaxOil() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getMaxOil();
+}
+
+void dComIfGs_setMaxOil(u16 i_maxOil) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setMaxOil(i_maxOil);
+}
+
+u16 dComIfGs_getOil() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getOil();
+}
+
+void dComIfGs_setOil(u16 i_oil) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setOil(i_oil);
+}
+
+u8 dComIfGs_getSelectEquipClothes() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getSelectEquip(COLLECT_CLOTHING);
+}
+
+u8 dComIfGs_getSelectEquipSword() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getSelectEquip(COLLECT_SWORD);
+}
+
+u8 dComIfGs_getSelectEquipShield() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getSelectEquip(COLLECT_SHIELD);
+}
+
+u8 dComIfGs_getCollectSmell() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getSelectEquip(COLLECT_SMELL);
+}
+
+void dComIfGs_setCollectSmell(u8 smell) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setSelectEquip(COLLECT_SMELL, smell);
+}
+
+u8 dComIfGs_getBButtonItemKey() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getSelectEquip(B_BUTTON_ITEM);
+}
+
+void dComIfGs_setBButtonItemKey(u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setSelectEquip(B_BUTTON_ITEM, i_itemNo);
+}
+
+u8 dComIfGs_getWalletSize() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getWalletSize();
+}
+
+void dComIfGs_setWalletSize(u8 i_size) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setWalletSize(i_size);
+}
+
+u8 dComIfGs_getMaxMagic() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getMaxMagic();
+}
+
+void dComIfGs_setMaxMagic(u8 i_maxMagic) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setMaxMagic(i_maxMagic);
+}
+
+u8 dComIfGs_getMagic() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getMagic();
+}
+
+void dComIfGs_setMagic(u8 i_magic) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setMagic(i_magic);
+}
+
+u8 dComIfGs_getTransformStatus() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getTransformStatus();
+}
+
+void dComIfGs_setTransformStatus(u8 i_status) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().setTransformStatus(i_status);
+}
+
+u8 dComIfGs_getSelectItemIndex(int i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getSelectItemIndex(i_no);
+}
+
+u16 dComIfGs_getRupeeMax() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().getRupeeMax();
+}
+
+void dComIfGs_offGetMagicUseFlag() {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().offMagicFlag(0);
+}
+
+s32 dComIfGs_isGetMagicUseFlag() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusA().isMagicFlag(0);
+}
+
+f32 dComIfGs_getTime() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().getTime();
+}
+
+void dComIfGs_setTime(f32 i_time) {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().setTime(i_time);
+}
+
+u16 dComIfGs_getDate() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().getDate();
+}
+
+void dComIfGs_setDate(u16 i_date) {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().setDate(i_date);
+}
+
+void dComIfGs_onDarkClearLV(int i_no) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().onDarkClearLV(i_no);
+}
+
+void dComIfGs_offDarkClearLV(int i_no) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().offDarkClearLV(i_no);
+}
+
+BOOL dComIfGs_isDarkClearLV(int i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().isDarkClearLV(i_no);
+}
+
+void dComIfGs_onTransformLV(int i_no) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().onTransformLV(i_no);
+}
+
+void dComIfGs_offTransformLV(int i_no) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().offTransformLV(i_no);
+}
+
+BOOL dComIfGs_isTransformLV(int i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerStatusB().isTransformLV(i_no);
+}
+
+cXyz dComIfGs_getHorseRestartPos() {
+    return g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().getPos();
+}
+
+s16 dComIfGs_getHorseRestartAngleY() {
+    return g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().getAngleY();
+}
+
+const char* dComIfGs_getHorseRestartStageName() {
+    return g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().getStageName();
+}
+
+s8 dComIfGs_getHorseRestartRoomNo() {
+    return g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().getRoomNo();
+}
+
+void dComIfGs_setHorseRestart(const char* i_stageName, cXyz& i_pos, s16 i_angle, s8 i_roomNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getHorsePlace().set(i_stageName, i_pos, i_angle, i_roomNo);
+}
+
+cXyz dComIfGs_getPlayerFieldLastStayPos() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().getPos();
+}
+
+s16 dComIfGs_getPlayerFieldLastStayAngleY() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().getAngleY();
+}
+
+char* dComIfGs_getPlayerFieldLastStayName() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().getName();
+}
+
+u8 dComIfGs_getPlayerFieldLastStayRegionNo() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().getRegionNo();
+}
+
+bool dComIfGs_isPlayerFieldLastStayFieldDataExistFlag() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().isFieldDataExistFlag();
+}
+
+void dComIfGs_offPlayerFieldLastStayFieldDataExistFlag() {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().offFieldDataExistFlag();
+}
+
+void dComIfGs_onPlayerFieldLastStayFieldDataExistFlag() {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().onFieldDataExistFlag();
+}
+
+BOOL dComIfGs_isRegionBit(int i_region) {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().isRegionBit(i_region);
+}
+
+void dComIfGs_onRegionBit(int i_region) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().onRegionBit(i_region);
+}
+
+void dComIfGs_setPlayerFieldLastStayInfo(
+    const char* i_stage, cXyz& i_pos, s16 i_angle, s8 i_point, u8 i_region) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerFieldLastStayInfo().set(
+        i_stage, i_pos, i_angle, i_point, i_region);
+}
+
+cXyz dComIfGs_getLastWarpMarkPlayerPos() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().getPos();
+}
+
+s16 dComIfGs_getLastWarpMarkPlayerAngleY() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().getAngleY();
+}
+
+const char* dComIfGs_getLastWarpMarkStageName() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().getName();
+}
+
+u8 dComIfGs_getLastWarpMarkRoomNo() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().getRoomNo();
+}
+
+s8 dComIfGs_getLastWarpAcceptStage() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().getWarpAcceptStage();
+}
+
+void dComIfGs_setLastWarpAcceptStage(s8 param_0) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().setWarpAcceptStage(param_0);
+}
+
+void dComIfGs_resetLastWarpAcceptStage() {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerLastMarkInfo().resetWarpAcceptStage();
+}
+
+void dComIfGs_setItem(int i_slotNo, u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setItem(i_slotNo, i_itemNo);
+}
+
+u8 dComIfGs_getItem(int i_slotNo, bool i_checkCombo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItem().getItem(i_slotNo, i_checkCombo);
+}
+
+void dComIfGs_setLineUpItem() {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setLineUpItem();
+}
+
+u8 dComIfGs_getLineUpItem(int i_slotNo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItem().getLineUpItem(i_slotNo);
+}
+
+void dComIfGs_setBottleItemIn(u8 curItem, u8 newItem) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setBottleItemIn(curItem, newItem);
+}
+
+void dComIfGs_setEmptyBottleItemIn(u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBottleItemIn(i_itemNo);
+}
+
+void dComIfGs_setEmptyBottle() {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBottle();
+}
+
+void dComIfGs_setEmptyBottle(u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBottle(i_itemNo);
+}
+
+void dComIfGs_setEquipBottleItemIn(u8 i_curItem, u8 i_newItem) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEquipBottleItemIn(i_curItem, i_newItem);
+}
+
+void dComIfGs_setEquipBottleItemEmpty(u8 i_curItem) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEquipBottleItemEmpty(i_curItem);
+}
+
+u8 dComIfGs_checkBottle(u8 i_itemNo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItem().checkBottle(i_itemNo);
+}
+
+u8 dComIfGs_checkInsectBottle() {
+    return g_dComIfG_gameInfo.info.getPlayer().getItem().checkInsectBottle();
+}
+
+u8 dComIfGs_checkEmptyBottle() {
+    return g_dComIfG_gameInfo.info.getPlayer().getItem().checkEmptyBottle();
+}
+
+void dComIfGs_setEmptyBombBagItemIn(u8 i_newBomb, bool i_setNum) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBombBagItemIn(i_newBomb, i_setNum);
+}
+
+void dComIfGs_setEmptyBombBagItemIn(u8 i_newBomb, u8 i_bombNum, bool i_setNum) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBombBagItemIn(
+        i_newBomb, i_bombNum, i_setNum);
+}
+
+void dComIfGs_setEmptyBombBag() {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBombBag();
+}
+
+void dComIfGs_setEmptyBombBag(u8 i_newBomb, u8 i_bombNum) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setEmptyBombBag(i_newBomb, i_bombNum);
+}
+
+u8 dComIfGs_checkBombBag(u8 i_itemNo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItem().checkBombBag(i_itemNo);
+}
+
+void dComIfGs_setWarashibeItem(u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setWarashibeItem(i_itemNo);
+}
+
+void dComIfGs_setRodTypeLevelUp() {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setRodTypeLevelUp();
+}
+
+void dComIfGs_setBaitItem(u8 i_item) {
+    g_dComIfG_gameInfo.info.getPlayer().getItem().setBaitItem(i_item);
+}
+
+void dComIfGs_onItemFirstBit(u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getGetItem().onFirstBit(i_itemNo);
+}
+
+void dComIfGs_offItemFirstBit(u8 i_itemNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getGetItem().offFirstBit(i_itemNo);
+}
+
+int dComIfGs_isItemFirstBit(u8 i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getGetItem().isFirstBit(i_no);
+}
+
+u8 dComIfGs_getArrowNum() {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemRecord().getArrowNum();
+}
+
+void dComIfGs_setArrowNum(u8 i_arrowNum) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemRecord().setArrowNum(i_arrowNum);
+}
+
+u8 dComIfGs_getPachinkoNum() {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemRecord().getPachinkoNum();
+}
+
+void dComIfGs_setPachinkoNum(u8 i_num) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemRecord().setPachinkoNum(i_num);
+}
+
+u8 dComIfGs_getPachinkoMax() {
+    return 50;
+}
+
+void dComIfGs_setBombNum(u8 i_num) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemRecord().setBombNum(0, i_num);
+}
+
+void dComIfGs_setBombNum(u8 i_bagIdx, u8 i_bombNum) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemRecord().setBombNum(i_bagIdx, i_bombNum);
+}
+
+u8 dComIfGs_getBombNum(u8 i_bagIdx) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemRecord().getBombNum(i_bagIdx);
+}
+
+void dComIfGs_setBottleNum(u8 i_bottleIdx, u8 i_bottleNum) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemRecord().setBottleNum(i_bottleIdx, i_bottleNum);
+}
+
+void dComIfGs_addBottleNum(u8 i_bottleIdx, s16 i_num) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemRecord().addBottleNum(i_bottleIdx, i_num);
+}
+
+u8 dComIfGs_getBottleNum(u8 i_bottleIdx) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemRecord().getBottleNum(i_bottleIdx);
+}
+
+u8 dComIfGs_getArrowMax() {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemMax().getArrowNum();
+}
+
+void dComIfGs_setArrowMax(u8 i_arrowMax) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemMax().setArrowNum(i_arrowMax);
+}
+
+void dComIfGs_setBombMax(u8 i_max) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemMax().setBombNum(0, i_max);
+}
+
+void dComIfGs_setBombMax(u8 i_type, u8 i_max) {
+    g_dComIfG_gameInfo.info.getPlayer().getItemMax().setBombNum(i_type, i_max);
+}
+
+u8 dComIfGs_getBombMax() {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemMax().getBombNum(0);
+}
+
+u8 dComIfGs_getBombMax(u8 i_bombType) {
+    return g_dComIfG_gameInfo.info.getPlayer().getItemMax().getBombNum(i_bombType);
+}
+
+void dComIfGs_setPohSpiritNum(u8 i_num) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().setPohNum(i_num);
+}
+
+u8 dComIfGs_getPohSpiritNum() {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().getPohNum();
+}
+
+void dComIfGs_addPohSpiritNum() {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().addPohNum();
+}
+
+BOOL dComIfGs_isCollectClothes(u8 i_clothesNo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().isCollect(
+        COLLECT_CLOTHING, i_clothesNo);
+}
+
+void dComIfGs_setCollectClothes(u8 i_clothesNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().setCollect(COLLECT_CLOTHING, i_clothesNo);
+}
+
+void dComIfGs_setCollectSword(u8 i_swordNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().setCollect(COLLECT_SWORD, i_swordNo);
+}
+
+void dComIfGs_setCollectShield(u8 i_shieldNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().setCollect(COLLECT_SHIELD, i_shieldNo);
+}
+
+BOOL dComIfGs_isCollectClothing(u8 i_clothesNo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().isCollect(
+        COLLECT_CLOTHING, i_clothesNo);
+}
+
+void dComIfGs_offCollectClothes(u8 i_clothesNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().offCollect(COLLECT_CLOTHING, i_clothesNo);
+}
+
+BOOL dComIfGs_isCollectSword(u8 i_swordNo) {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().isCollect(COLLECT_SWORD, i_swordNo);
+}
+
+void dComIfGs_offCollectSword(u8 i_swordNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().offCollect(COLLECT_SWORD, i_swordNo);
+}
+
+BOOL dComIfGs_isCollectShield(u8 i_item) {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().isCollect(COLLECT_SHIELD, i_item);
+}
+
+void dComIfGs_offCollectShield(u8 i_shieldNo) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().offCollect(COLLECT_SHIELD, i_shieldNo);
+}
+
+void dComIfGs_onCollectCrystal(u8 i_item) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().onCollectCrystal(i_item);
+}
+
+void dComIfGs_offCollectCrystal(u8 i_item) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().offCollectCrystal(i_item);
+}
+
+bool dComIfGs_isCollectCrystal(u8 i_item) {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().isCollectCrystal(i_item);
+}
+
+void dComIfGs_onCollectMirror(u8 i_item) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().onCollectMirror(i_item);
+}
+
+void dComIfGs_offCollectMirror(u8 i_item) {
+    g_dComIfG_gameInfo.info.getPlayer().getCollect().offCollectMirror(i_item);
+}
+
+bool dComIfGs_isCollectMirror(u8 i_item) {
+    return g_dComIfG_gameInfo.info.getPlayer().getCollect().isCollectMirror(i_item);
+}
+
+void dComIfGs_setLightDropNum(u8 i_level, u8 i_num) {
+    g_dComIfG_gameInfo.info.getPlayer().getLightDrop().setLightDropNum(i_level, i_num);
+}
+
+u8 dComIfGs_getLightDropNum(u8 i_nowLevel) {
+    return g_dComIfG_gameInfo.info.getPlayer().getLightDrop().getLightDropNum(i_nowLevel);
+}
+
+void dComIfGs_onLightDropGetFlag(u8 i_nowLevel) {
+    g_dComIfG_gameInfo.info.getPlayer().getLightDrop().onLightDropGetFlag(i_nowLevel);
+}
+
+void dComIfGs_offLightDropGetFlag(u8 i_level) {
+    g_dComIfG_gameInfo.info.getPlayer().getLightDrop().offLightDropGetFlag(i_level);
+}
+
+BOOL dComIfGs_isLightDropGetFlag(u8 i_nowLevel) {
+    return g_dComIfG_gameInfo.info.getPlayer().getLightDrop().isLightDropGetFlag(i_nowLevel);
+}
+
+void dComIfGs_onLetterGetFlag(int i_no) {
+    g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().onLetterGetFlag(i_no);
+}
+
+BOOL dComIfGs_isLetterGetFlag(int i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().isLetterGetFlag(i_no);
+}
+
+void dComIfGs_onLetterReadFlag(int i_no) {
+    g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().onLetterReadFlag(i_no);
+}
+
+int dComIfGs_isLetterReadFlag(int i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().isLetterReadFlag(i_no);
+}
+
+u8 dComIfGs_getGetNumber(int i_no) {
+    return g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().getGetNumber(i_no);
+}
+
+void dComIfGs_setGetNumber(int i_no, u8 i_value) {
+    g_dComIfG_gameInfo.info.getPlayer().getLetterInfo().setGetNumber(i_no, i_value);
+}
+
+void dComIfGs_addFishNum(u8 param_0) {
+    g_dComIfG_gameInfo.info.getPlayer().getFishingInfo().addFishCount(param_0);
+}
+
+u16 dComIfGs_getFishNum(u8 param_0) {
+    return g_dComIfG_gameInfo.info.getPlayer().getFishingInfo().getFishCount(param_0);
+}
+
+u8 dComIfGs_getFishSize(u8 param_0) {
+    return g_dComIfG_gameInfo.info.getPlayer().getFishingInfo().getMaxSize(param_0);
+}
+
+void dComIfGs_setFishSize(u8 param_0, u8 param_1) {
+    g_dComIfG_gameInfo.info.getPlayer().getFishingInfo().setMaxSize(param_0, param_1);
+}
+
+OSTime dComIfGs_getTotalTime() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getTotalTime();
+}
+
+void dComIfGs_addDeathCount() {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().addDeathCount();
+}
+
+u16 dComIfGs_getDeathCount() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getDeathCount();
+}
+
+TEXT_SPAN dComIfGs_getPlayerName() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getPlayerName();
+}
+
+void dComIfGs_setPlayerName(const char* i_name) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().setPlayerName(i_name);
+}
+
+TEXT_SPAN dComIfGs_getHorseName() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getHorseName();
+}
+
+void dComIfGs_setHorseName(const char* i_name) {
+    g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().setHorseName(i_name);
+}
+
+u8 dComIfGs_getClearCount() {
+    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getClearCount();
+}
+
+// Ruby inline names are from TWW debug.
+u8 dComIfGs_getOptRuby() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getRuby();
+}
+
+void dComIfGs_setOptRuby(u8 i_ruby) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setRuby(i_ruby);
+}
+
+u8 dComIfGs_getOptAttentionType() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getAttentionType();
+}
+
+void dComIfGs_setOptAttentionType(u8 i_attentionType) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setAttentionType(i_attentionType);
+}
+
+void dComIfGs_setOptCalibrateDist(u16 i_calibrateDist) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setCalibrateDist(i_calibrateDist);
+}
+
+void dComIfGs_setOptCalValue(s8 i_calValue) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setCalValue(i_calValue);
+}
+
+u8 dComIfGs_getOptCameraControl() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getCameraControl();
+}
+
+void dComIfGs_setOptCameraControl(u8 i_cameraControl) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setCameraControl(i_cameraControl);
+}
+
+u8 dComIfGs_getOptPointer() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getPointer();
+}
+
+void dComIfGs_setOptPointer(u8 i_pointer) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setPointer(i_pointer);
+}
+
+u8 dComIfGs_checkOptVibration() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().checkVibration();
+}
+
+u8 dComIfGs_getOptSound() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getSound();
+}
+
+void dComIfGs_setOptSound(u8 i_mode) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setSound(i_mode);
+}
+
+u8 dComIfGs_getOptVibration() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getVibration();
+}
+
+void dComIfGs_setOptVibration(u8 i_status) {
+    g_dComIfG_gameInfo.info.getPlayer().getConfig().setVibration(i_status);
+}
+
+u8 dComIfGs_getPalLanguage() {
+    return g_dComIfG_gameInfo.info.getPlayer().getConfig().getPalLanguage();
+}
+
+BOOL dComIfGs_isSaveTbox(int i_stageNo, int i_no) {
+    return g_dComIfG_gameInfo.info.getSavedata().getSave(i_stageNo).getBit().isTbox(i_no);
+}
+
+void dComIfGs_onSaveSwitch(int i_stageNo, int i_no) {
+    g_dComIfG_gameInfo.info.getSavedata().getSave(i_stageNo).getBit().onSwitch(i_no);
+}
+
+void dComIfGs_offSaveSwitch(int i_stageNo, int i_no) {
+    g_dComIfG_gameInfo.info.getSavedata().getSave(i_stageNo).getBit().offSwitch(i_no);
+}
+
+BOOL dComIfGs_isSaveSwitch(int i_stageNo, int i_no) {
+    return g_dComIfG_gameInfo.info.getSavedata().getSave(i_stageNo).getBit().isSwitch(i_no);
+}
+
+void dComIfGs_onSaveVisitedRoom(int param_0, int i_roomNo) {
+    return g_dComIfG_gameInfo.info.getSavedata().getSave2(param_0)->onVisitedRoom(i_roomNo);
+}
+
+void dComIfGs_offSaveVisitedRoom(int param_0, int i_roomNo) {
+    return g_dComIfG_gameInfo.info.getSavedata().getSave2(param_0)->offVisitedRoom(i_roomNo);
+}
+
+BOOL dComIfGs_isSaveVisitedRoom(int param_0, int i_roomNo) {
+    return g_dComIfG_gameInfo.info.getSavedata().getSave2(param_0)->isVisitedRoom(i_roomNo);
+}
+
+void* dComIfGs_getPEventBit() {
+    return g_dComIfG_gameInfo.info.getEvent().getPEventBit();
+}
+
+void dComIfGs_onEventBit(const u16 i_flag) {
+    g_dComIfG_gameInfo.info.getEvent().onEventBit(i_flag);
+}
+
+void dComIfGs_offEventBit(const u16 i_flag) {
+    g_dComIfG_gameInfo.info.getEvent().offEventBit(i_flag);
+}
+
+BOOL dComIfGs_isEventBit(const u16 i_flag) {
+    return g_dComIfG_gameInfo.info.getEvent().isEventBit(i_flag);
+}
+
+void dComIfGs_setEventReg(u16 reg, u8 value) {
+    g_dComIfG_gameInfo.info.getEvent().setEventReg(reg, value);
+}
+
+u8 dComIfGs_getEventReg(u16 reg) {
+    return g_dComIfG_gameInfo.info.getEvent().getEventReg(reg);
+}
+
+int dComIfGs_getHookGameTime() {
+    return g_dComIfG_gameInfo.info.getMiniGame().getHookGameTime();
+}
+
+void dComIfGs_setHookGameTime(u32 i_time) {
+    g_dComIfG_gameInfo.info.getMiniGame().setHookGameTime(i_time);
+}
+
+u32 dComIfGs_getBalloonScore() {
+    return g_dComIfG_gameInfo.info.getMiniGame().getBalloonScore();
+}
+
+void dComIfGs_setBalloonScore(u32 i_score) {
+    g_dComIfG_gameInfo.info.getMiniGame().setBalloonScore(i_score);
+}
+
+int dComIfGs_getRaceGameTime() {
+    return g_dComIfG_gameInfo.info.getMiniGame().getRaceGameTime();
+}
+
+void dComIfGs_setRaceGameTime(int i_time) {
+    g_dComIfG_gameInfo.info.getMiniGame().setRaceGameTime(i_time);
+}
+
+u8 dComIfGs_getKeyNum() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().getKeyNum();
+}
+
+void dComIfGs_setKeyNum(u8 i_keyNum) {
+    g_dComIfG_gameInfo.info.getMemory().getBit().setKeyNum(i_keyNum);
+}
+
+void dComIfGs_onDungeonItemMap() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onDungeonItemMap();
+}
+
+void dComIfGs_offDungeonItemMap() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offDungeonItemMap();
+}
+
+s32 dComIfGs_isDungeonItemMap() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isDungeonItemMap();
+}
+
+void dComIfGs_onDungeonItemCompass() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onDungeonItemCompass();
+}
+
+void dComIfGs_offDungeonItemCompass() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offDungeonItemCompass();
+}
+
+s32 dComIfGs_isDungeonItemCompass() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isDungeonItemCompass();
+}
+
+void dComIfGs_onDungeonItemBossKey() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onDungeonItemBossKey();
+}
+
+void dComIfGs_offDungeonItemBossKey() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offDungeonItemBossKey();
+}
+
+s32 dComIfGs_isDungeonItemBossKey() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isDungeonItemBossKey();
+}
+
+void dComIfGs_onStageBossEnemy() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onStageBossEnemy();
+}
+
+void dComIfGs_offStageBossEnemy() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offStageBossEnemy();
+}
+
+s32 dComIfGs_isStageBossEnemy() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isStageBossEnemy();
+}
+
+void dComIfGs_onStageLife() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onStageLife();
+}
+
+void dComIfGs_offStageLife() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offStageLife();
+}
+
+s32 dComIfGs_isStageLife() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isStageLife();
+}
+
+void dComIfGs_onStageBossDemo() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onStageBossDemo();
+}
+
+void dComIfGs_offStageBossDemo() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offStageBossDemo();
+}
+
+s32 dComIfGs_isStageBossDemo() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isStageBossDemo();
+}
+
+void dComIfGs_onDungeonItemWarp() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onDungeonItemWarp();
+}
+
+void dComIfGs_offDungeonItemWarp() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offDungeonItemWarp();
+}
+
+s32 dComIfGs_isDungeonItemWarp() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isDungeonItemWarp();
+}
+
+void dComIfGs_onStageMiddleBoss() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onStageBossEnemy2();
+}
+
+void dComIfGs_offStageMiddleBoss() {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offStageBossEnemy2();
+}
+
+BOOL dComIfGs_isStageMiddleBoss() {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isStageBossEnemy2();
+}
+
+void dComIfGs_onTbox(int i_no) {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onTbox(i_no);
+}
+
+void dComIfGs_offTbox(int i_no) {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offTbox(i_no);
+}
+
+BOOL dComIfGs_isTbox(int i_no) {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isTbox(i_no);
+}
+
+void dComIfGs_onSaveSwitch(int i_no) {
+    g_dComIfG_gameInfo.info.getMemory().getBit().onSwitch(i_no);
+}
+
+void dComIfGs_offSaveSwitch(int i_no) {
+    g_dComIfG_gameInfo.info.getMemory().getBit().offSwitch(i_no);
+}
+
+BOOL dComIfGs_isSaveSwitch(int i_no) {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isSwitch(i_no);
+}
+
+BOOL dComIfGs_isSaveItem(int i_no) {
+    return g_dComIfG_gameInfo.info.getMemory().getBit().isItem(i_no);
+}
+
+void dComIfGs_onSaveDunSwitch(int i_swNo) {
+    g_dComIfG_gameInfo.info.getDan().onSwitch(i_swNo);
+}
+
+void dComIfGs_offSaveDunSwitch(int i_swNo) {
+    g_dComIfG_gameInfo.info.getDan().offSwitch(i_swNo);
+}
+
+BOOL dComIfGs_isSaveDunSwitch(int i_no) {
+    return g_dComIfG_gameInfo.info.getDan().isSwitch(i_no);
+}
+
+BOOL dComIfGs_isSaveDunItem(int i_no) {
+    return g_dComIfG_gameInfo.info.getDan().isItem(i_no);
+}
+
+void dComIfGs_resetDan() {
+    g_dComIfG_gameInfo.info.resetDan();
+}
+
+void dComIfGs_initDan(s8 i_stageNo) {
+    g_dComIfG_gameInfo.info.initDan(i_stageNo);
+}
+
+void dComIfGs_clearRoomSwitch(int i_zoneNo) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().clearRoomSwitch();
+}
+
+void dComIfGs_clearRoomItem(int i_zoneNo) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().clearRoomItem();
+}
+
+void dComIfGs_onSvZoneSwitch(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().onSwitch(i_swBit);
+}
+
+void dComIfGs_offSvZoneSwitch(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().offSwitch(i_swBit);
+}
+
+BOOL dComIfGs_isSvZoneSwitch(int i_zoneNo, int i_swBit) {
+    return g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().isSwitch(i_swBit);
+}
+
+void dComIfGs_onSvOneZoneSwitch(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().onOneSwitch(i_swBit);
+}
+
+void dComIfGs_offSvOneZoneSwitch(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().offOneSwitch(i_swBit);
+}
+
+BOOL dComIfGs_isSvOneZoneSwitch(int i_zoneNo, int i_swBit) {
+    return g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().isOneSwitch(i_swBit);
+}
+
+void dComIfGs_onSvZoneItem(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().onItem(i_swBit);
+}
+
+void dComIfGs_offSvZoneItem(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().offItem(i_swBit);
+}
+
+BOOL dComIfGs_isSvZoneItem(int i_zoneNo, int i_swBit) {
+    return g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().isItem(i_swBit);
+}
+
+void dComIfGs_onSvOneZoneItem(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().onOneItem(i_swBit);
+}
+
+void dComIfGs_offSvOneZoneItem(int i_zoneNo, int i_swBit) {
+    g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().offOneItem(i_swBit);
+}
+
+BOOL dComIfGs_isSvOneZoneItem(int i_zoneNo, int i_swBit) {
+    return g_dComIfG_gameInfo.info.getZone(i_zoneNo).getBit().isOneItem(i_swBit);
+}
+
+void dComIfGs_removeZone(int i_zoneNo) {
+    g_dComIfG_gameInfo.info.removeZone(i_zoneNo);
+}
+
+s8 dComIfGs_getRestartRoomNo() {
+    return g_dComIfG_gameInfo.info.getRestart().getRoomNo();
+}
+
+s16 dComIfGs_getStartPoint() {
+    return g_dComIfG_gameInfo.info.getRestart().getStartPoint();
+}
+
+void dComIfGs_setStartPoint(s16 i_point) {
+    g_dComIfG_gameInfo.info.getRestart().setStartPoint(i_point);
+}
+
+s16 dComIfGs_getRestartRoomAngleY() {
+    return g_dComIfG_gameInfo.info.getRestart().getRoomAngleY();
+}
+
+const cXyz& dComIfGs_getRestartRoomPos() {
+    return g_dComIfG_gameInfo.info.getRestart().getRoomPos();
+}
+
+u32 dComIfGs_getRestartRoomParam() {
+    return g_dComIfG_gameInfo.info.getRestart().getRoomParam();
+}
+
+void dComIfGs_setRestartRoomParam(u32 i_param) {
+    g_dComIfG_gameInfo.info.getRestart().setRoomParam(i_param);
+}
+
+f32 dComIfGs_getLastSceneSpeedF() {
+    return g_dComIfG_gameInfo.info.getRestart().getLastSpeedF();
+}
+
+u32 dComIfGs_getLastSceneMode() {
+    return g_dComIfG_gameInfo.info.getRestart().getLastMode();
+}
+
+s16 dComIfGs_getLastSceneAngleY() {
+    return g_dComIfG_gameInfo.info.getRestart().getLastAngleY();
+}
+
+void dComIfGs_setRestartRoom(const cXyz& i_position, s16 i_angle, s8 i_roomNo) {
+    g_dComIfG_gameInfo.info.getRestart().setRoom(i_position, i_angle, i_roomNo);
+}
+
+void dComIfGs_onTmpBit(const u16 i_flag) {
+    g_dComIfG_gameInfo.info.getTmp().onEventBit(i_flag);
+}
+
+void dComIfGs_offTmpBit(const u16 i_flag) {
+    g_dComIfG_gameInfo.info.getTmp().offEventBit(i_flag);
+}
+
+BOOL dComIfGs_isTmpBit(const u16 i_flag) {
+    return g_dComIfG_gameInfo.info.getTmp().isEventBit(i_flag);
+}
+
+void dComIfGs_setTmpReg(u16 i_reg, u8 i_no) {
+    g_dComIfG_gameInfo.info.getTmp().setEventReg(i_reg, i_no);
+}
+
+u8 dComIfGs_getTmpReg(const u16 i_reg) {
+    return g_dComIfG_gameInfo.info.getTmp().getEventReg(i_reg);
+}
+
+dSv_turnRestart_c& dComIfGs_getTurnRestart() {
+    return g_dComIfG_gameInfo.info.getTurnRestart();
+}
+
+const cXyz& dComIfGs_getTurnRestartPos() {
+    return g_dComIfG_gameInfo.info.getTurnRestart().getPos();
+}
+
+u32 dComIfGs_getTurnRestartParam() {
+    return g_dComIfG_gameInfo.info.getTurnRestart().getParam();
+}
+
+s16 dComIfGs_getTurnRestartAngleY() {
+    return g_dComIfG_gameInfo.info.getTurnRestart().getAngleY();
+}
+
+s8 dComIfGs_getTurnRestartRoomNo() {
+    return g_dComIfG_gameInfo.info.getTurnRestart().getRoomNo();
+}
+
+void dComIfGs_setTurnRestart(const cXyz& i_position, s16 i_angle, s8 param_2, u32 i_param) {
+    g_dComIfG_gameInfo.info.getTurnRestart().set(i_position, i_angle, param_2, i_param);
+}
+
+u8 dComIfGs_getDataNum() {
+    return g_dComIfG_gameInfo.info.getDataNum();
+}
+
+void dComIfGs_setDataNum(u8 i_num) {
+    return g_dComIfG_gameInfo.info.setDataNum(i_num);
+}
+
+u8 dComIfGs_getNewFile() {
+    return g_dComIfG_gameInfo.info.getNewFile();
+}
+
+void dComIfGs_setNewFile(u8 i_fileNo) {
+    return g_dComIfG_gameInfo.info.setNewFile(i_fileNo);
+}
+
+u8 dComIfGs_getNoFile() {
+    return g_dComIfG_gameInfo.info.getNoFile();
+}
+
+void dComIfGs_setNoFile(u8 i_file) {
+    g_dComIfG_gameInfo.info.setNoFile(i_file);
+}
+
+s64 dComIfGs_getSaveStartTime() {
+    return g_dComIfG_gameInfo.info.getStartTime();
+}
+
+void dComIfGs_setSaveStartTime(s64 i_time) {
+    g_dComIfG_gameInfo.info.setStartTime(i_time);
+}
+
+s64 dComIfGs_getSaveTotalTime() {
+    return g_dComIfG_gameInfo.info.getSaveTotalTime();
+}
+
+void dComIfGs_setSaveTotalTime(s64 i_time) {
+    g_dComIfG_gameInfo.info.setSaveTotalTime(i_time);
+}
+
+void dComIfGs_init() {
+    g_dComIfG_gameInfo.info.init();
+}
+
+void dComIfGs_getSave(int i_stageNo) {
+    g_dComIfG_gameInfo.info.getSave(i_stageNo);
+}
+
+void dComIfGs_putSave(int i_stageNo) {
+    g_dComIfG_gameInfo.info.putSave(i_stageNo);
+}
+
+void dComIfGs_initZone() {
+    g_dComIfG_gameInfo.info.initZone();
+}
+
+int dComIfGs_createZone(int roomNo) {
+    return g_dComIfG_gameInfo.info.createZone(roomNo);
+}
+
+void dComIfGs_onSwitch(int i_no, int i_roomNo) {
+    g_dComIfG_gameInfo.info.onSwitch(i_no, i_roomNo);
+}
+
+void dComIfGs_offSwitch(int i_no, int i_roomNo) {
+    g_dComIfG_gameInfo.info.offSwitch(i_no, i_roomNo);
+}
+
+BOOL dComIfGs_isSwitch(int i_no, int i_roomNo) {
+    return g_dComIfG_gameInfo.info.isSwitch(i_no, i_roomNo);
+}
+
+void dComIfGs_revSwitch(int i_no, int i_roomNo) {
+    g_dComIfG_gameInfo.info.revSwitch(i_no, i_roomNo);
+}
+
+void dComIfGs_onItem(int i_bitNo, int i_roomNo) {
+    g_dComIfG_gameInfo.info.onItem(i_bitNo, i_roomNo);
+}
+
+bool dComIfGs_isItem(int i_bitNo, int i_roomNo) {
+    return g_dComIfG_gameInfo.info.isItem(i_bitNo, i_roomNo);
+}
+
+void dComIfGs_onActor(int i_bitNo, int i_roomNo) {
+    g_dComIfG_gameInfo.info.onActor(i_bitNo, i_roomNo);
+}
+
+void dComIfGs_offActor(int i_no, int i_roomNo) {
+    g_dComIfG_gameInfo.info.offActor(i_no, i_roomNo);
+}
+
+BOOL dComIfGs_isActor(int i_no, int i_roomNo) {
+    return g_dComIfG_gameInfo.info.isActor(i_no, i_roomNo);
+}
+
+void dComIfGs_setMemoryToCard(u8* i_saveData, int i_dataNum) {
+    g_dComIfG_gameInfo.info.memory_to_card((char*)i_saveData, i_dataNum);
+}
+
+void dComIfGs_setCardToMemory(u8* card_ptr, int dataNum) {
+    g_dComIfG_gameInfo.info.card_to_memory((char*)card_ptr, dataNum);
+}
+
+void dComIfGs_setInitDataToCard(u8* i_saveData, int i_dataNum) {
+    g_dComIfG_gameInfo.info.initdata_to_card((char*)i_saveData, i_dataNum);
+}
+
+u8 dComIfGs_getWolfAbility(int i_idx) {
+    return g_dComIfG_gameInfo.play.getWolfAbility(i_idx);
+}
+
+s8 dComIfGs_Grass_hide_Check() {
+    return g_dComIfG_gameInfo.field_0x1ddfc;
+}
+
+dStage_startStage_c* dComIfGp_getStartStage() {
+    return g_dComIfG_gameInfo.play.getStartStage();
+}
+
+void dComIfGp_setStartStage(dStage_startStage_c* p_startStage) {
+    g_dComIfG_gameInfo.play.setStartStage(p_startStage);
+}
+
+const char* dComIfGp_getStartStageName() {
+    return g_dComIfG_gameInfo.play.getStartStageName();
+}
+
+s16 dComIfGp_getStartStagePoint() {
+    return g_dComIfG_gameInfo.play.getStartStagePoint();
+}
+
+s8 dComIfGp_getStartStageRoomNo() {
+    return g_dComIfG_gameInfo.play.getStartStageRoomNo();
+}
+
+s8 dComIfGp_getStartStageLayer() {
+    return g_dComIfG_gameInfo.play.getStartStageLayer();
+}
+
+void dComIfGp_setStartStageLayer(s8 layer) {
+    g_dComIfG_gameInfo.play.setStartStageLayer(layer);
+}
+
+s8 dComIfGp_getStartStageDarkArea() {
+    return g_dComIfG_gameInfo.play.getStartStageDarkArea();
+}
+
+void dComIfGp_setStartStageDarkArea(s8 darkArea) {
+    g_dComIfG_gameInfo.play.setStartStageDarkArea(darkArea);
+}
+
+dStage_startStage_c* dComIfGp_getNextStartStage() {
+    return g_dComIfG_gameInfo.play.getNextStartStage();
+}
+
+const char* dComIfGp_getNextStageName() {
+    return g_dComIfG_gameInfo.play.getNextStageName();
+}
+
+s16 dComIfGp_getNextStagePoint() {
+    return g_dComIfG_gameInfo.play.getNextStagePoint();
+}
+
+s16 dComIfGp_getNextStageRoomNo() {
+    return g_dComIfG_gameInfo.play.getNextStageRoomNo();
+}
+
+s16 dComIfGp_getNextStageLayer() {
+    return g_dComIfG_gameInfo.play.getNextStageLayer();
+}
+
+BOOL dComIfGp_isEnableNextStage() {
+    return g_dComIfG_gameInfo.play.isEnableNextStage();
+}
+
+void dComIfGp_offEnableNextStage() {
+    g_dComIfG_gameInfo.play.offEnableNextStage();
+}
+
+s8 dComIfGp_getNextStageWipe() {
+    return g_dComIfG_gameInfo.play.getNextStageWipe();
+}
+
+u8 dComIfGp_getNextStageWipeSpeed() {
+    return g_dComIfG_gameInfo.play.getNextStageWipeSpeed();
+}
+
+dStage_stageDt_c* dComIfGp_getStage() {
+    return &g_dComIfG_gameInfo.play.getStage();
+}
+
+roomRead_class* dComIfGp_getStageRoom() {
+    return g_dComIfG_gameInfo.play.getStage().getRoom();
+}
+
+stage_palette_info_class* dComIfGp_getStagePaletteInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getPaletteInfo();
+}
+
+stage_pselect_info_class* dComIfGp_getStagePselectInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getPselectInfo();
+}
+
+stage_envr_info_class* dComIfGp_getStageEnvrInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getEnvrInfo();
+}
+
+stage_vrboxcol_info_class* dComIfGp_getStageVrboxcolInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getVrboxcolInfo();
+}
+
+stage_plight_info_class* dComIfGp_getStagePlightInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getPlightInfo();
+}
+
+int dComIfGp_getStagePaletteNumInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getPaletteNumInfo();
+}
+
+int dComIfGp_getStagePselectNumInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getPselectNumInfo();
+}
+
+int dComIfGp_getStageEnvrNumInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getEnvrNumInfo();
+}
+
+int dComIfGp_getStageVrboxcolNumInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getVrboxcolNumInfo();
+}
+
+int dComIfGp_getStagePlightNumInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getPlightNumInfo();
+}
+
+stage_stag_info_class* dComIfGp_getStageStagInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getStagInfo();
+}
+
+stage_scls_info_dummy_class* dComIfGp_getStageSclsInfo() {
+    return g_dComIfG_gameInfo.play.getStage().getSclsInfo();
+}
+
+dStage_Multi_c* dComIfGp_getMulti() {
+    return g_dComIfG_gameInfo.play.getStage().getMulti();
+}
+
+void dComIfGp_setOldMulti() {
+    g_dComIfG_gameInfo.play.getStage().setOldMulti();
+}
+
+void dComIfGp_resetOldMulti() {
+    g_dComIfG_gameInfo.play.getStage().resetOldMulti();
+}
+
+s16 dComIfGp_getStageWorldRollAngleX() {
+    return g_dComIfG_gameInfo.play.getStage().getWorldRollAngleX();
+}
+
+s16 dComIfGp_getStageWorldRollDirAngleY() {
+    return g_dComIfG_gameInfo.play.getStage().getWorldRollDirAngleY();
+}
+
+int dComIfGp_roomControl_getStayNo() {
+    return dStage_roomControl_c::getStayNo();
+}
+
+BOOL dComIfGp_roomControl_getTimePass() {
+    return g_dComIfG_gameInfo.play.getRoomControl()->GetTimePass();
+}
+
+void dComIfGp_roomControl_setTimePass(int isPassing) {
+    g_dComIfG_gameInfo.play.getRoomControl()->SetTimePass(isPassing);
+}
+
+dKy_tevstr_c* dComIfGp_roomControl_getTevStr(int i_roomNo) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->getTevStr(i_roomNo);
+}
+
+void dComIfGp_roomControl_setStatusFlag(int i_roomNo, u8 flag) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->setStatusFlag(i_roomNo, flag);
+}
+
+void dComIfGp_roomControl_onStatusFlag(int i_roomNo, u8 flag) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->onStatusFlag(i_roomNo, flag);
+}
+
+void dComIfGp_roomControl_offStatusFlag(int i_roomNo, u8 flag) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->offStatusFlag(i_roomNo, flag);
+}
+
+u8 dComIfGp_roomControl_checkStatusFlag(int i_roomNo, u8 flag) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->checkStatusFlag(i_roomNo, flag);
+}
+
+s32 dComIfGp_roomControl_getZoneNo(int i_roomNo) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->getZoneNo(i_roomNo);
+}
+
+void dComIfGp_roomControl_setZoneNo(int roomNo, int zoneNo) {
+    g_dComIfG_gameInfo.play.getRoomControl()->setZoneNo(roomNo, zoneNo);
+}
+
+void dComIfGp_roomControl_init() {
+    g_dComIfG_gameInfo.play.getRoomControl()->init();
+}
+
+void dComIfGp_roomControl_initZone() {
+    g_dComIfG_gameInfo.play.getRoomControl()->initZone();
+}
+
+dStage_roomDt_c* dComIfGp_roomControl_getStatusRoomDt(int room_no) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->getStatusRoomDt(room_no);
+}
+
+void dComIfGp_roomControl_setStayNo(int stayNo) {
+    g_dComIfG_gameInfo.play.mRoomControl.setStayNo(stayNo);
+}
+
+BOOL dComIfGp_roomControl_checkRoomDisp(int i_roomNo) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->checkRoomDisp(i_roomNo);
+}
+
+int dComIfGp_roomControl_loadRoom(int param_0, u8* param_1, bool param_2) {
+    return g_dComIfG_gameInfo.play.getRoomControl()->loadRoom(param_0, param_1, param_2);
+}
+
+void dComIfGp_roomControl_zoneCountCheck(int i_roomNo) {
+    g_dComIfG_gameInfo.play.getRoomControl()->zoneCountCheck(i_roomNo);
+}
+
+dEvt_control_c* dComIfGp_getEvent() {
+    return g_dComIfG_gameInfo.play.getEvent();
+}
+
+u16 dComIfGp_event_chkEventFlag(u16 i_flag) {
+    return g_dComIfG_gameInfo.play.getEvent()->chkEventFlag(i_flag);
+}
+
+void dComIfGp_event_onEventFlag(u16 i_flag) {
+    g_dComIfG_gameInfo.play.getEvent()->onEventFlag(i_flag);
+}
+
+void dComIfGp_event_onHindFlag(u16 i_flag) {
+    g_dComIfG_gameInfo.play.getEvent()->onHindFlag(i_flag);
+}
+
+void dComIfGp_event_offHindFlag(u16 i_flag) {
+    g_dComIfG_gameInfo.play.getEvent()->offHindFlag(i_flag);
+}
+
+u8 dComIfGp_event_getMode() {
+    return g_dComIfG_gameInfo.play.getEvent()->getMode();
+}
+
+BOOL dComIfGp_event_runCheck() {
+    return g_dComIfG_gameInfo.play.getEvent()->runCheck();
+}
+
+u16 dComIfGp_event_checkHind(u16 i_hindFlag) {
+    if (!dComIfGp_event_runCheck()) {
+        return false;
+    }
+    return g_dComIfG_gameInfo.play.getEvent()->checkHind(i_hindFlag);
+}
+
+BOOL dComIfGp_event_chkTalkXY() {
+    return g_dComIfG_gameInfo.play.getEvent()->chkTalkXY();
+}
+
+u8 dComIfGp_event_getPreItemNo() {
+    return g_dComIfG_gameInfo.play.getEvent()->getPreItemNo();
+}
+
+f32 dComIfGp_event_getCullRate() {
+    return g_dComIfG_gameInfo.play.getEvent()->getCullRate();
+}
+
+void dComIfGp_event_setCullRate(f32 i_rate) {
+    g_dComIfG_gameInfo.play.getEvent()->setCullRate(i_rate);
+}
+
+int dComIfGp_event_order(u16 i_type, u16 i_prio, u16 i_flags, u16 i_hindFlags, void* i_requestActor,
+    void* i_targetActor, s16 i_eventID, u8 i_mapToolId) {
+    return g_dComIfG_gameInfo.play.getEvent()->order(i_type, i_prio, i_flags, i_hindFlags,
+        i_requestActor, i_targetActor, i_eventID, i_mapToolId);
+}
+
+void dComIfGp_event_reset() {
+    g_dComIfG_gameInfo.play.getEvent()->reset();
+}
+
+int dComIfGp_event_moveApproval(void* i_actor) {
+    return g_dComIfG_gameInfo.play.getEvent()->moveApproval(i_actor);
+}
+
+BOOL dComIfGp_event_compulsory(void* i_actor, const char* i_eventname, u16 i_hindFlag) {
+    return g_dComIfG_gameInfo.play.getEvent()->compulsory(i_actor, i_eventname, i_hindFlag);
+}
+
+void dComIfGp_event_remove() {
+    g_dComIfG_gameInfo.play.getEvent()->remove();
+}
+
+fopAc_ac_c* dComIfGp_event_getPt1() {
+    return g_dComIfG_gameInfo.play.getEvent()->getPt1();
+}
+
+fopAc_ac_c* dComIfGp_event_getPt2() {
+    return g_dComIfG_gameInfo.play.getEvent()->getPt2();
+}
+
+fopAc_ac_c* dComIfGp_event_getTalkPartner() {
+    return g_dComIfG_gameInfo.play.getEvent()->getPtT();
+}
+
+void dComIfGp_event_setTalkPartner(void* i_actor) {
+    g_dComIfG_gameInfo.play.getEvent()->setPtT(i_actor);
+}
+
+fopAc_ac_c* dComIfGp_event_getItemPartner() {
+    return g_dComIfG_gameInfo.play.getEvent()->getPtI();
+}
+
+void dComIfGp_event_setItemPartner(void* i_actor) {
+    g_dComIfG_gameInfo.play.getEvent()->setPtI(i_actor);
+}
+
+void dComIfGp_event_setItemPartnerId(fpc_ProcID i_id) {
+    g_dComIfG_gameInfo.play.getEvent()->setPtI_Id(i_id);
+}
+
+fopAc_ac_c* dComIfGp_event_getDoorPartner() {
+    return g_dComIfG_gameInfo.play.getEvent()->getPtD();
+}
+
+void dComIfGp_event_setDoorPartner(void* i_partner) {
+    g_dComIfG_gameInfo.play.getEvent()->setPtD(i_partner);
+}
+
+u8 dComIfGp_event_getGtItm() {
+    return g_dComIfG_gameInfo.play.getEvent()->getGtItm();
+}
+
+void dComIfGp_event_setGtItm(u8 i_itemNo) {
+    g_dComIfG_gameInfo.play.getEvent()->setGtItm(i_itemNo);
+}
+
+dEvent_manager_c& dComIfGp_getEventManager() {
+    return g_dComIfG_gameInfo.play.getEvtManager();
+}
+
+dEvent_manager_c* dComIfGp_getPEvtManager() {
+    return &g_dComIfG_gameInfo.play.getEvtManager();
+}
+
+int dComIfGp_evmng_cameraPlay() {
+    return dComIfGp_getPEvtManager()->cameraPlay();
+}
+
+int dComIfGp_evmng_startDemo(int i_mapToolId) {
+    return dComIfGp_getPEvtManager()->setStartDemo(i_mapToolId);
+}
+
+void dComIfGp_evmng_create() {
+    g_dComIfG_gameInfo.play.getEvtManager().create();
+}
+
+void dComIfGp_evmng_remove() {
+    g_dComIfG_gameInfo.play.getEvtManager().remove();
+}
+
+bool dComIfGp_evmng_existence(s16 eventId) {
+    return g_dComIfG_gameInfo.play.getEvtManager().getEventData(eventId) != NULL;
+}
+
+s16 dComIfGp_evmng_getEventIdx(const char* eventName, u8 mapToolID) {
+    return g_dComIfG_gameInfo.play.getEvtManager().getEventIdx(eventName, mapToolID, -1);
+}
+
+bool dComIfGp_evmng_existence(const char* eventname) {
+    return g_dComIfG_gameInfo.play.getEvtManager().getEventData(
+               dComIfGp_evmng_getEventIdx(eventname, 0xFF)) != NULL;
+}
+
+BOOL dComIfGp_evmng_isMapToolCamera(u8 mapToolID) {
+    return g_dComIfG_gameInfo.play.getEvtManager().isMapToolCamera(mapToolID, -1);
+}
+
+BOOL dComIfGp_evmng_startCheck(s16 i_eventId) {
+    return g_dComIfG_gameInfo.play.getEvtManager().startCheck(i_eventId);
+}
+
+BOOL dComIfGp_evmng_startCheck(char const* i_eventname) {
+    return g_dComIfG_gameInfo.play.getEvtManager().startCheckOld(i_eventname);
+}
+
+BOOL dComIfGp_evmng_endCheck(s16 i_eventID) {
+    return g_dComIfG_gameInfo.play.getEvtManager().endCheck(i_eventID);
+}
+
+BOOL dComIfGp_evmng_endCheck(const char* i_eventname) {
+    return g_dComIfG_gameInfo.play.getEvtManager().endCheckOld(i_eventname);
+}
+
+int dComIfGp_evmng_getMyStaffId(const char* i_staffname, fopAc_ac_c* i_actor, int i_tagId) {
+    return dComIfGp_getPEvtManager()->getMyStaffId(i_staffname, i_actor, i_tagId);
+}
+
+int dComIfGp_evmng_getIsAddvance(int i_staffId) {
+    return dComIfGp_getPEvtManager()->getIsAddvance(i_staffId);
+}
+
+int dComIfGp_evmng_getMyActIdx(int i_staffId, DUSK_CONST char* DUSK_CONST* i_actions,
+    int i_actionNum, BOOL param_3, BOOL param_4) {
+    return dComIfGp_getPEvtManager()->getMyActIdx(
+        i_staffId, i_actions, i_actionNum, param_3, param_4);
+}
+
+f32* dComIfGp_evmng_getMyFloatP(int i_staffId, DUSK_CONST char* i_dataname) {
+    return (f32*)dComIfGp_getPEvtManager()->getMySubstanceP(
+        i_staffId, i_dataname, dEvDtData_c::TYPE_FLOAT);
+}
+
+cXyz* dComIfGp_evmng_getMyXyzP(int i_staffId, DUSK_CONST char* i_dataname) {
+    return (cXyz*)dComIfGp_getPEvtManager()->getMySubstanceP(
+        i_staffId, i_dataname, dEvDtData_c::TYPE_VEC);
+}
+
+int* dComIfGp_evmng_getMyIntegerP(int i_staffId, DUSK_CONST char* i_dataname) {
+    return (int*)dComIfGp_getPEvtManager()->getMySubstanceP(
+        i_staffId, i_dataname, dEvDtData_c::TYPE_INT);
+}
+
+char* dComIfGp_evmng_getMyStringP(int i_staffId, DUSK_CONST char* i_dataname) {
+    return (char*)dComIfGp_getPEvtManager()->getMySubstanceP(
+        i_staffId, i_dataname, dEvDtData_c::TYPE_STRING);
+}
+
+int dComIfGp_evmng_getMySubstanceNum(int i_staffId, DUSK_CONST char* i_dataname) {
+    return dComIfGp_getPEvtManager()->getMySubstanceNum(i_staffId, i_dataname);
+}
+
+void dComIfGp_evmng_cutEnd(int i_staffId) {
+    dComIfGp_getPEvtManager()->cutEnd(i_staffId);
+}
+
+void dComIfGp_evmng_setGoal(cXyz* i_pos) {
+    dComIfGp_getPEvtManager()->setGoal(i_pos);
+}
+
+cXyz* dComIfGp_evmng_getGoal() {
+    return dComIfGp_getPEvtManager()->getGoal();
+}
+
+BOOL dComIfGp_evmng_ChkPresentEnd() {
+    return dComIfGp_getPEvtManager()->ChkPresentEnd();
+}
+
+int dComIfGp_evmng_checkStartDemo() {
+    return dComIfGp_getPEvtManager()->checkStartDemo();
+}
+
+dAttention_c* dComIfGp_getAttention() {
+    return g_dComIfG_gameInfo.play.getAttention();
+}
+
+fopAc_ac_c* dComIfGp_att_getZHint() {
+    return dComIfGp_getAttention()->getZHintTarget();
+}
+
+int dComIfGp_att_ZHintRequest(fopAc_ac_c* param_1, int param_2) {
+    return dComIfGp_getAttention()->ZHintRequest(param_1, param_2);
+}
+
+fopAc_ac_c* dComIfGp_att_getCatghTarget() {
+    return dComIfGp_getAttention()->getCatghTarget();
+}
+
+u8 dComIfGp_att_getCatchChgItem() {
+    return dComIfGp_getAttention()->getCatchChgItem();
+}
+
+int dComIfGp_att_CatchRequest(fopAc_ac_c* param_0, u8 param_1, f32 i_horizontalDist, f32 i_upDist,
+    f32 i_downDist, s16 i_angle, int param_5) {
+    return dComIfGp_getAttention()->CatchRequest(
+        param_0, param_1, i_horizontalDist, i_upDist, i_downDist, i_angle, param_5);
+}
+
+fopAc_ac_c* dComIfGp_att_getLookTarget() {
+    return dComIfGp_getAttention()->getLookTarget();
+}
+
+void dComIfGp_att_LookRequest(fopAc_ac_c* param_0, f32 i_horizontalDist, f32 i_upDist,
+    f32 i_downDist, s16 i_angle, int param_5) {
+    dComIfGp_getAttention()->LookRequest(
+        param_0, i_horizontalDist, i_upDist, i_downDist, i_angle, param_5);
+}
+
+dVibration_c& dComIfGp_getVibration() {
+    return g_dComIfG_gameInfo.play.getVibration();
+}
+
+JKRAramArchive* dComIfGp_getFieldMapArchive2() {
+    return g_dComIfG_gameInfo.play.getFieldMapArchive2();
+}
+
+void dComIfGp_setFieldMapArchive2(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setFieldMapArchive2(arc);
+}
+
+JKRArchive* dComIfGp_getMsgArchive(int idx) {
+    return g_dComIfG_gameInfo.play.getMsgArchive(idx);
+}
+
+void dComIfGp_setMsgArchive(int i, JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setMsgArchive(i, arc);
+}
+
+JKRArchive* dComIfGp_getDemoMsgArchive() {
+    return g_dComIfG_gameInfo.play.getDemoMsgArchive();
+}
+
+void dComIfGp_setDemoMsgArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setDemoMsgArchive(arc);
+}
+
+JKRArchive* dComIfGp_getMeterButtonArchive() {
+    return g_dComIfG_gameInfo.play.getMeterButtonArchive();
+}
+
+void dComIfGp_setMeterButtonArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setMeterButtonArchive(arc);
+}
+
+JKRArchive* dComIfGp_getFontArchive() {
+    return g_dComIfG_gameInfo.play.getFontArchive();
+}
+
+void dComIfGp_setFontArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setFontArchive(arc);
+}
+
+JKRArchive* dComIfGp_getRubyArchive() {
+    return g_dComIfG_gameInfo.play.getRubyArchive();
+}
+
+void dComIfGp_setRubyArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setRubyArchive(arc);
+}
+
+JKRArchive* dComIfGp_getAnmArchive() {
+    return g_dComIfG_gameInfo.play.getAnmArchive();
+}
+
+void dComIfGp_setAnmArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setAnmArchive(arc);
+}
+
+JKRArchive* dComIfGp_getCollectResArchive() {
+    return g_dComIfG_gameInfo.play.getCollectResArchive();
+}
+
+void dComIfGp_setCollectResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setCollectResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getFmapResArchive() {
+    return g_dComIfG_gameInfo.play.getFmapResArchive();
+}
+
+void dComIfGp_setFmapResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setFmapResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getDmapResArchive() {
+    return g_dComIfG_gameInfo.play.getDmapResArchive();
+}
+
+void dComIfGp_setDmapResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setDmapResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getOptionResArchive() {
+    return g_dComIfG_gameInfo.play.getOptionResArchive();
+}
+
+void dComIfGp_setOptionResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setOptionResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getItemIconArchive() {
+    return g_dComIfG_gameInfo.play.getItemIconArchive();
+}
+
+void dComIfGp_setItemIconArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setItemIconArchive(arc);
+}
+
+JKRArchive* dComIfGp_getNameResArchive() {
+    return g_dComIfG_gameInfo.play.getNameResArchive();
+}
+
+void dComIfGp_setNameResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setNameResArchive(arc);
+}
+
+void dComIfGp_setErrorResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setErrorResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getAllMapArchive() {
+    return g_dComIfG_gameInfo.play.getAllMapArchive();
+}
+
+void dComIfGp_setAllMapArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setAllMapArchive(arc);
+}
+
+JKRArchive* dComIfGp_getMsgCommonArchive() {
+    return g_dComIfG_gameInfo.play.getMsgCommonArchive();
+}
+
+void dComIfGp_setMsgCommonArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setMsgCommonArchive(arc);
+}
+
+JKRArchive* dComIfGp_getRingResArchive() {
+    return g_dComIfG_gameInfo.play.getRingResArchive();
+}
+
+void dComIfGp_setRingResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setRingResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getCardIconResArchive() {
+    return g_dComIfG_gameInfo.play.getCardIconResArchive();
+}
+
+void dComIfGp_setCardIconResArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setCardIconResArchive(arc);
+}
+
+JKRArchive* dComIfGp_getMsgDtArchive() {
+    return g_dComIfG_gameInfo.play.getMsgDtArchive();
+}
+
+JKRArchive* dComIfGp_getMsgDtArchive(int idx) {
+    return g_dComIfG_gameInfo.play.getMsgDtArchive(idx);
+}
+
+void dComIfGp_setMsgDtArchive(int i, JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setMsgDtArchive(i, arc);
+}
+
+JKRArchive* dComIfGp_getMain2DArchive() {
+    return g_dComIfG_gameInfo.play.getMain2DArchive();
+}
+
+void dComIfGp_setMain2DArchive(JKRArchive* arc) {
+    g_dComIfG_gameInfo.play.setMain2DArchive(arc);
+}
+
+JKRExpHeap* dComIfGp_particle_getResHeap() {
+    return g_dComIfG_gameInfo.play.getParticle()->getResHeap();
+}
+
+void dComIfGp_particle_levelExecute(u32 param_0) {
+    g_dComIfG_gameInfo.play.getParticle()->levelExecute(param_0);
+}
+
+void dComIfGp_particle_createCommon(const void* data) {
+    g_dComIfG_gameInfo.play.getParticle()->createCommon(data);
+}
+
+void dComIfGp_particle_readScene(u8 particle_no, mDoDvdThd_toMainRam_c** param_1) {
+    g_dComIfG_gameInfo.play.getParticle()->readScene(particle_no, param_1);
+}
+
+void dComIfGp_particle_createScene(const void* param_0) {
+    g_dComIfG_gameInfo.play.getParticle()->createScene(param_0);
+}
+
+void dComIfGp_particle_removeScene(bool param_0) {
+    g_dComIfG_gameInfo.play.getParticle()->removeScene(param_0);
+}
+
+void dComIfGp_particle_cleanup() {
+    g_dComIfG_gameInfo.play.getParticle()->cleanup();
+}
+
+void dComIfGp_particle_calc3D() {
+    g_dComIfG_gameInfo.play.getParticle()->calc3D();
+}
+
+void dComIfGp_particle_calc2D() {
+    g_dComIfG_gameInfo.play.getParticle()->calc2D();
+}
+
+void dComIfGp_particle_calcMenu() {
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->calcMenu();
+    }
+}
+
+void dComIfGp_particle_draw(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawNormal(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFog(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawNormalFog(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawP1(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawNormalP1(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawProjection(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawProjection(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawNormalPri0_A(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawNormalPri0_A(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawNormalPri0_B(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawNormalPri0_B(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFogPri0_A(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogPri0_A(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFogPri0_B(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogPri0_B(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFogPri1(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogPri1(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFogPri2(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogPri2(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFogPri3(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogPri3(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawFogPri4(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogPri4(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawDarkworld(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawDarkworld(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_drawScreen(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->drawFogScreen(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_draw2Dgame(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->draw2Dgame(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_draw2Dfore(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->draw2Dfore(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_draw2Dback(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->draw2Dback(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_draw2DmenuFore(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->draw2DmenuFore(i_drawInfo);
+    }
+}
+
+void dComIfGp_particle_draw2DmenuBack(JPADrawInfo* i_drawInfo) {
+    ZoneScoped;
+    if (g_dComIfG_gameInfo.play.getParticle() != NULL) {
+        g_dComIfG_gameInfo.play.getParticle()->draw2DmenuBack(i_drawInfo);
+    }
+}
+
+void dComIfGp_setHitMark(u16 i_hitmark, fopAc_ac_c* param_1, const cXyz* param_2,
+    const csXyz* param_3, const cXyz* param_4, u32 i_atType) {
+    g_dComIfG_gameInfo.play.getParticle()->setHitMark(
+        i_hitmark, param_1, param_2, param_3, param_4, i_atType);
+}
+
+void dComIfGp_particle_setWaterRipple(u32* param_0, cBgS_PolyInfo& param_1, const cXyz* param_2,
+    f32 param_3, const dKy_tevstr_c* param_4, const cXyz* param_5, s8 param_6) {
+    g_dComIfG_gameInfo.play.getParticle()->setWaterRipple(
+        param_0, param_1, param_2, param_3, param_4, param_5, param_6);
+}
+
+u32 dComIfGp_particle_setPolyColor(u32 param_0, u16 param_1, cBgS_PolyInfo& param_2,
+    const cXyz* param_3, const dKy_tevstr_c* param_4, const csXyz* param_5, const cXyz* param_6,
+    int param_7, dPa_levelEcallBack* param_8, s8 param_9, const cXyz* param_10) {
+    return g_dComIfG_gameInfo.play.getParticle()->setPoly(param_0, param_1, param_2, param_3,
+        param_4, param_5, param_6, param_7, param_8, param_9, param_10);
+}
+
+JPABaseEmitter* dComIfGp_particle_setPolyColor(u16 param_1, cBgS_PolyInfo& param_2,
+    const cXyz* param_3, const dKy_tevstr_c* param_4, const csXyz* param_5, const cXyz* param_6,
+    int param_7, dPa_levelEcallBack* param_8, s8 param_9, const cXyz* param_10) {
+    return g_dComIfG_gameInfo.play.getParticle()->setPoly(
+        param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8, param_9, param_10);
+}
+
+void dComIfGp_particle_setSimple(u16 param_0, cXyz* i_pos, u8 param_2, GXColor& param_3,
+    GXColor& param_4, int param_5, float param_6) {
+    g_dComIfG_gameInfo.play.getParticle()->setSimple(
+        param_0, i_pos, 0, param_2, param_3, param_4, param_5, param_6);
+}
+
+u32 dComIfGp_particle_setStopContinue(u32 param_0) {
+    return g_dComIfG_gameInfo.play.getParticle()->setStopContinue(param_0);
+}
+
+u32 dComIfGp_particle_setSimpleFoot(u32 param_0, u32* param_1, cBgS_PolyInfo& param_2,
+    cXyz const* param_3, dKy_tevstr_c const* param_4, int param_5, csXyz const* param_6,
+    cXyz const* param_7, dPa_levelEcallBack* param_8, s8 param_9, cXyz const* param_10) {
+    return g_dComIfG_gameInfo.play.getParticle()->setSimpleFoot(param_0, param_1, param_2, param_3,
+        param_4, param_5, param_6, param_7, param_8, param_9, param_10);
+}
+
+u16 dComIfGp_particle_setCommonPoly(u32* param_0, cBgS_PolyInfo* param_1, const cXyz* param_2,
+    const cXyz* param_3, const dKy_tevstr_c* param_4, u32 param_5, u32 param_6,
+    const csXyz* param_7, const cXyz* param_8, s8 param_9) {
+    return g_dComIfG_gameInfo.play.getParticle()->setCommonPoly(
+        param_0, param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8, param_9);
+}
+
+void dComIfGp_particle_levelEmitterOnEventMove(u32 param_0) {
+    g_dComIfG_gameInfo.play.getParticle()->forceOnEventMove(param_0);
+}
+
+JPABaseEmitter* dComIfGp_particle_getEmitter(u32 param_0) {
+    return g_dComIfG_gameInfo.play.getParticle()->getEmitter(param_0);
+}
+
+u32 dComIfGp_particle_set(u32 param_0, u16 param_1, const cXyz* i_pos, const dKy_tevstr_c* param_3,
+    const csXyz* i_rotation, const cXyz* i_scale, u8 i_alpha, dPa_levelEcallBack* param_7,
+    s8 param_8, const GXColor* param_9, const GXColor* param_10, const cXyz* param_11) {
+    return g_dComIfG_gameInfo.play.getParticle()->setNormal(param_0, param_1, i_pos, param_3,
+        i_rotation, i_scale, i_alpha, param_7, param_8, param_9, param_10, param_11, 1.0f);
+}
+
+u32 dComIfGp_particle_set(u32 param_0, u16 param_1, const cXyz* i_pos, const csXyz* i_rotation,
+    const cXyz* i_scale, u8 param_5, dPa_levelEcallBack* param_6, s8 param_7,
+    const GXColor* param_8, const GXColor* param_9, const cXyz* param_10) {
+    return g_dComIfG_gameInfo.play.getParticle()->setNormal(param_0, param_1, i_pos, NULL,
+        i_rotation, i_scale, param_5, param_6, param_7, param_8, param_9, param_10, 1.0f);
+}
+
+JPABaseEmitter* dComIfGp_particle_set(u16 i_resID, const cXyz* i_pos, const dKy_tevstr_c* param_3,
+    const csXyz* i_rotation, const cXyz* i_scale, u8 i_alpha, dPa_levelEcallBack* i_callback,
+    s8 param_8, const GXColor* i_prmColor, const GXColor* i_envColor, const cXyz* i_particleScale) {
+    return g_dComIfG_gameInfo.play.getParticle()->setNormal(i_resID, i_pos, param_3, i_rotation,
+        i_scale, i_alpha, i_callback, param_8, i_prmColor, i_envColor, i_particleScale, 1.0f);
+}
+
+JPABaseEmitter* dComIfGp_particle_set(u16 i_resID, const cXyz* i_pos, const csXyz* i_rotation,
+    const cXyz* i_scale, u8 i_alpha, dPa_levelEcallBack* i_callback, s8 param_7,
+    const GXColor* i_prmColor, const GXColor* i_envColor, const cXyz* i_particleScale) {
+    return g_dComIfG_gameInfo.play.getParticle()->setNormal(i_resID, i_pos, NULL, i_rotation,
+        i_scale, i_alpha, i_callback, param_7, i_prmColor, i_envColor, i_particleScale, 1.0f);
+}
+
+u32 dComIfGp_particle_set(
+    u32 param_0, u16 param_1, const cXyz* i_pos, const dKy_tevstr_c* param_3) {
+    return dComIfGp_particle_set(
+        param_0, param_1, i_pos, param_3, NULL, NULL, 0xFF, NULL, -1, NULL, NULL, NULL);
+}
+
+JPABaseEmitter* dComIfGp_particle_set(
+    u16 i_resID, const cXyz* i_pos, const csXyz* i_rotation, const cXyz* i_scale) {
+    return dComIfGp_particle_set(
+        i_resID, i_pos, NULL, i_rotation, i_scale, 255, NULL, -1, NULL, NULL, NULL);
+}
+
+JPABaseEmitter* dComIfGp_particle_set(u16 i_resID, const cXyz* i_pos, const dKy_tevstr_c* param_2,
+    const csXyz* i_rotation, const cXyz* i_scale) {
+    return dComIfGp_particle_set(
+        i_resID, i_pos, param_2, i_rotation, i_scale, 255, NULL, -1, NULL, NULL, NULL);
+}
+
+u32 dComIfGp_particle_set(
+    u32 param_0, u16 param_1, const cXyz* i_pos, const csXyz* param_3, const cXyz* param_4) {
+    return dComIfGp_particle_set(
+        param_0, param_1, i_pos, param_3, param_4, 0xFF, NULL, -1, NULL, NULL, NULL);
+}
+
+u32 dComIfGp_particle_setColor(u32 param_0, u16 param_1, const cXyz* i_pos,
+    const dKy_tevstr_c* param_3, const GXColor* param_4, const GXColor* param_5, f32 param_6,
+    u8 param_7, const csXyz* param_8, const cXyz* param_9, dPa_levelEcallBack* param_10,
+    s8 param_11, const cXyz* param_12) {
+    return g_dComIfG_gameInfo.play.getParticle()->setNormal(param_0, param_1, i_pos, param_3,
+        param_8, param_9, param_7, param_10, param_11, param_4, param_5, param_12, param_6);
+}
+
+JPABaseEmitter* dComIfGp_particle_setColor(u16 param_0, const cXyz* i_pos,
+    const dKy_tevstr_c* param_2, const GXColor* param_3, const GXColor* param_4, f32 param_5,
+    u8 param_6, const csXyz* param_7, const cXyz* param_8, dPa_levelEcallBack* param_9, s8 param_10,
+    const cXyz* param_11) {
+    return g_dComIfG_gameInfo.play.getParticle()->setNormal(param_0, i_pos, param_2, param_7,
+        param_8, param_6, param_9, param_10, param_3, param_4, param_11, param_5);
+}
+
+JPABaseEmitter* dComIfGp_particle_setColor(u16 param_0, const cXyz* i_pos,
+    const dKy_tevstr_c* param_2, const GXColor* param_3, const GXColor* param_4, f32 param_5,
+    u8 param_6) {
+    return dComIfGp_particle_setColor(
+        param_0, i_pos, param_2, param_3, param_4, param_5, param_6, NULL, NULL, NULL, -1, NULL);
+}
+
+u32 dComIfGp_particle_getHeapSize() {
+    return g_dComIfG_gameInfo.play.getParticle()->getHeapSize();
+}
+
+u32 dComIfGp_particle_getSceneHeapSize() {
+    return g_dComIfG_gameInfo.play.getParticle()->getSceneHeapSize();
+}
+
+int dComIfGp_particle_getEmitterNum() {
+    return g_dComIfG_gameInfo.play.getParticle()->getEmitterNum();
+}
+
+int dComIfGp_particle_getParticleNum() {
+    return g_dComIfG_gameInfo.play.getParticle()->getParticleNum();
+}
+
+dSmplMdl_draw_c* dComIfGp_getSimpleModel() {
+    return g_dComIfG_gameInfo.play.getSimpleModel();
+}
+
+int dComIfGp_getWindowNum() {
+    return g_dComIfG_gameInfo.play.getWindowNum();
+}
+
+void dComIfGp_setWindowNum(int num) {
+    g_dComIfG_gameInfo.play.setWindowNum(num);
+}
+
+s8 dComIfGp_getLayerOld() {
+    return g_dComIfG_gameInfo.play.getLayerOld();
+}
+
+s32 dComIfGp_checkStatus(u16 flags) {
+    return g_dComIfG_gameInfo.play.checkStatus(flags);
+}
+
+void dComIfGp_setStatus(u16 status) {
+    g_dComIfG_gameInfo.play.setStatus(status);
+}
+
+void dComIfGp_onStatus(u16 i_status) {
+    g_dComIfG_gameInfo.play.onStatus(i_status);
+}
+
+dDlst_window_c* dComIfGp_getWindow(int i) {
+    return g_dComIfG_gameInfo.play.getWindow(i);
+}
+
+void dComIfGp_setWindow(u8 i, f32 param_1, f32 param_2, f32 param_3, f32 param_4, f32 param_5,
+    f32 param_6, int camID, int mode) {
+    g_dComIfG_gameInfo.play.setWindow(
+        i, param_1, param_2, param_3, param_4, param_5, param_6, camID, mode);
+}
+
+camera_process_class* dComIfGp_getCamera(int idx) {
+    return (camera_process_class*)g_dComIfG_gameInfo.play.getCamera(idx);
+}
+
+void dComIfGp_setCamera(int i, camera_class* cam) {
+    g_dComIfG_gameInfo.play.setCamera(i, cam);
+}
+
+int dComIfGp_getCameraWinID(int idx) {
+    return g_dComIfG_gameInfo.play.getCameraWinID(idx);
+}
+
+int dComIfGp_getCameraPlayer1ID(int idx) {
+    return g_dComIfG_gameInfo.play.getCameraPlayer1ID(idx);
+}
+
+int dComIfGp_getCameraPlayer2ID(int idx) {
+    return g_dComIfG_gameInfo.play.getCameraPlayer2ID(idx);
+}
+
+u32 dComIfGp_getCameraAttentionStatus(int i_no) {
+    return g_dComIfG_gameInfo.play.getCameraAttentionStatus(i_no);
+}
+
+BOOL dComIfGp_checkCameraAttentionStatus(int i, u32 flag) {
+    return g_dComIfG_gameInfo.play.checkCameraAttentionStatus(i, flag);
+}
+
+void dComIfGp_onCameraAttentionStatus(int i, u32 flag) {
+    g_dComIfG_gameInfo.play.onCameraAttentionStatus(i, flag);
+}
+
+void dComIfGp_offCameraAttentionStatus(int i, u32 flag) {
+    g_dComIfG_gameInfo.play.offCameraAttentionStatus(i, flag);
+}
+
+void dComIfGp_setCameraInfo(
+    int camIdx, camera_class* p_cam, int param_2, int param_3, int param_4) {
+    g_dComIfG_gameInfo.play.setCameraInfo(camIdx, p_cam, param_2, param_3, param_4);
+}
+
+f32 dComIfGp_getCameraZoomScale(int i_no) {
+    return g_dComIfG_gameInfo.play.getCameraZoomScale(i_no);
+}
+
+void dComIfGp_setCameraZoomScale(int i_no, f32 i_scale) {
+    g_dComIfG_gameInfo.play.setCameraZoomScale(i_no, i_scale);
+}
+
+f32 dComIfGp_getCameraZoomForcus(int i_no) {
+    return g_dComIfG_gameInfo.play.getCameraZoomForcus(i_no);
+}
+
+void dComIfGp_setCameraZoomForcus(int i_no, f32 i_focus) {
+    g_dComIfG_gameInfo.play.setCameraZoomForcus(i_no, i_focus);
+}
+
+const char* dComIfGp_getCameraParamFileName(int i) {
+    return g_dComIfG_gameInfo.play.getCameraParamFileName(i);
+}
+
+void dComIfGp_setCameraParamFileName(int i, char* name) {
+    g_dComIfG_gameInfo.play.setCameraParamFileName(i, name);
+}
+
+void dComIfGp_saveCameraPosition(int i, cXyz* i_pos, cXyz* i_target, f32 i_fovy, s16 i_bank) {
+    g_dComIfG_gameInfo.play.saveCameraPosition(i, i_pos, i_target, i_fovy, i_bank);
+}
+
+void dComIfGp_loadCameraPosition(int i, cXyz* o_pos, cXyz* o_target, f32* o_fovy, s16* o_bank) {
+    g_dComIfG_gameInfo.play.loadCameraPosition(i, o_pos, o_target, o_fovy, o_bank);
+}
+
+fopAc_ac_c* dComIfGp_getPlayer(int idx) {
+    return g_dComIfG_gameInfo.play.getPlayer(idx);
+}
+
+void dComIfGp_setPlayer(int i, fopAc_ac_c* player) {
+    g_dComIfG_gameInfo.play.setPlayer(i, player);
+}
+
+int dComIfGp_getPlayerCameraID(int idx) {
+    return g_dComIfG_gameInfo.play.getPlayerCameraID(idx);
+}
+
+void dComIfGp_setPlayerInfo(int plyrIdx, fopAc_ac_c* ptr, int camIdx) {
+    g_dComIfG_gameInfo.play.setPlayerInfo(plyrIdx, ptr, camIdx);
+}
+
+daPy_py_c* dComIfGp_getLinkPlayer() {
+    return (daPy_py_c*)g_dComIfG_gameInfo.play.getPlayerPtr(LINK_PTR);
+}
+
+daHorse_c* dComIfGp_getHorseActor() {
+    return (daHorse_c*)g_dComIfG_gameInfo.play.getPlayerPtr(HORSE_PTR);
+}
+
+void dComIfGp_setLinkPlayer(fopAc_ac_c* ptr) {
+    g_dComIfG_gameInfo.play.setPlayerPtr(0, ptr);
+}
+
+void dComIfGp_setHorseActor(fopAc_ac_c* i_horse) {
+    g_dComIfG_gameInfo.play.setPlayerPtr(1, i_horse);
+}
+
+void dComIfGp_setPlayerPtr(int i, fopAc_ac_c* ptr) {
+    g_dComIfG_gameInfo.play.setPlayerPtr(i, ptr);
+}
+
+dMsgObject_c* dComIfGp_getMsgObjectClass() {
+    return g_dComIfG_gameInfo.play.getMsgObjectClass();
+}
+
+void dComIfGp_setMsgObjectClass(dMsgObject_c* obj) {
+    return g_dComIfG_gameInfo.play.setMsgObjectClass(obj);
+}
+
+f32 dComIfGp_getItemLifeCount() {
+    return g_dComIfG_gameInfo.play.getItemLifeCount();
+}
+
+u8 dComIfGp_getItemLifeCountType() {
+    return g_dComIfG_gameInfo.play.getItemLifeCountType();
+}
+
+void dComIfGp_setItemLifeCount(f32 amount, u8 type) {
+    g_dComIfG_gameInfo.play.setItemLifeCount(amount, type);
+}
+
+void dComIfGp_clearItemLifeCount() {
+    g_dComIfG_gameInfo.play.clearItemLifeCount();
+}
+
+s32 dComIfGp_getItemRupeeCount() {
+    return g_dComIfG_gameInfo.play.getItemRupeeCount();
+}
+
+void dComIfGp_setItemRupeeCount(s32 amount) {
+    g_dComIfG_gameInfo.play.setItemRupeeCount(amount);
+}
+
+void dComIfGp_clearItemRupeeCount() {
+    g_dComIfG_gameInfo.play.clearItemRupeeCount();
+}
+
+s16 dComIfGp_getItemKeyNumCount() {
+    return g_dComIfG_gameInfo.play.getItemKeyNumCount();
+}
+
+void dComIfGp_setItemKeyNumCount(s16 count) {
+    g_dComIfG_gameInfo.play.setItemKeyNumCount(count);
+}
+
+void dComIfGp_clearItemKeyNumCount() {
+    g_dComIfG_gameInfo.play.clearItemKeyNumCount();
+}
+
+s16 dComIfGp_getItemMaxLifeCount() {
+    return g_dComIfG_gameInfo.play.getItemMaxLifeCount();
+}
+
+void dComIfGp_setItemMaxLifeCount(s16 count) {
+    g_dComIfG_gameInfo.play.setItemMaxLifeCount(count);
+}
+
+void dComIfGp_clearItemMaxLifeCount() {
+    g_dComIfG_gameInfo.play.clearItemMaxLifeCount();
+}
+
+void dComIfGp_setItemMagicCount(s16 count) {
+    g_dComIfG_gameInfo.play.setItemMagicCount(count);
+}
+
+void dComIfGp_setItemNowMagic(s16 magic) {
+    g_dComIfG_gameInfo.play.setItemNowMagic(magic);
+}
+
+void dComIfGp_setItemMaxMagicCount(s16 count) {
+    g_dComIfG_gameInfo.play.setItemMaxMagicCount(count);
+}
+
+s32 dComIfGp_getItemOilCount() {
+    return g_dComIfG_gameInfo.play.getItemOilCount();
+}
+
+void dComIfGp_setItemOilCount(s32 oil) {
+    g_dComIfG_gameInfo.play.setItemOilCount(oil);
+}
+
+void dComIfGp_setItemMaxOilCount(s32 oil) {
+    g_dComIfG_gameInfo.play.setItemMaxOilCount(oil);
+}
+
+void dComIfGp_clearItemOilCount() {
+    g_dComIfG_gameInfo.play.clearItemOilCount();
+}
+
+s32 dComIfGp_getItemNowOil() {
+    return g_dComIfG_gameInfo.play.getItemNowOil();
+}
+
+void dComIfGp_setItemNowOil(s32 oil) {
+    g_dComIfG_gameInfo.play.setItemNowOil(oil);
+}
+
+s32 dComIfGp_getItemMaxOilCount() {
+    return g_dComIfG_gameInfo.play.getItemMaxOilCount();
+}
+
+void dComIfGp_clearItemMaxOilCount() {
+    g_dComIfG_gameInfo.play.clearItemMaxOilCount();
+}
+
+int dComIfGp_getOxygen() {
+    return g_dComIfG_gameInfo.play.getOxygen();
+}
+
+void dComIfGp_setOxygen(s32 oxygen) {
+    g_dComIfG_gameInfo.play.setOxygen(oxygen);
+}
+
+int dComIfGp_getNowOxygen() {
+    return g_dComIfG_gameInfo.play.getNowOxygen();
+}
+
+void dComIfGp_setNowOxygen(s32 oxygen) {
+    g_dComIfG_gameInfo.play.setNowOxygen(oxygen);
+}
+
+s32 dComIfGp_getMaxOxygen() {
+    return g_dComIfG_gameInfo.play.getMaxOxygen();
+}
+
+void dComIfGp_setMaxOxygen(s32 i_oxygen) {
+    g_dComIfG_gameInfo.play.setMaxOxygen(i_oxygen);
+}
+
+s32 dComIfGp_getOxygenCount() {
+    return g_dComIfG_gameInfo.play.getOxygenCount();
+}
+
+void dComIfGp_setOxygenCount(s32 oxygen) {
+    g_dComIfG_gameInfo.play.setOxygenCount(oxygen);
+}
+
+void dComIfGp_clearOxygenCount() {
+    g_dComIfG_gameInfo.play.clearOxygenCount();
+}
+
+void dComIfGp_setMaxOxygenCount(s32 oxygen) {
+    g_dComIfG_gameInfo.play.setMaxOxygenCount(oxygen);
+}
+
+s32 dComIfGp_getMaxOxygenCount() {
+    return g_dComIfG_gameInfo.play.getMaxOxygenCount();
+}
+
+void dComIfGp_clearMaxOxygenCount() {
+    g_dComIfG_gameInfo.play.clearMaxOxygenCount();
+}
+
+s16 dComIfGp_getItemArrowNumCount() {
+    return g_dComIfG_gameInfo.play.getItemArrowNumCount();
+}
+
+void dComIfGp_setItemArrowNumCount(s16 count) {
+    g_dComIfG_gameInfo.play.setItemArrowNumCount(count);
+}
+
+void dComIfGp_clearItemArrowNumCount() {
+    g_dComIfG_gameInfo.play.clearItemArrowNumCount();
+}
+
+s16 dComIfGp_getItemPachinkoNumCount() {
+    return g_dComIfG_gameInfo.play.getItemPachinkoNumCount();
+}
+
+void dComIfGp_setItemPachinkoNumCount(s16 count) {
+    g_dComIfG_gameInfo.play.setItemPachinkoNumCount(count);
+}
+
+void dComIfGp_clearItemPachinkoNumCount() {
+    g_dComIfG_gameInfo.play.clearItemPachinkoNumCount();
+}
+
+s16 dComIfGp_getItemMaxArrowNumCount() {
+    return g_dComIfG_gameInfo.play.getItemMaxArrowNumCount();
+}
+
+int dComIfGp_getMessageCountNumber() {
+    return g_dComIfG_gameInfo.play.getMessageCountNumber();
+}
+
+void dComIfGp_setMessageCountNumber(s32 number) {
+    g_dComIfG_gameInfo.play.setMessageCountNumber(number);
+}
+
+u16 dComIfGp_getItemNowLife() {
+    return g_dComIfG_gameInfo.play.getItemNowLife();
+}
+
+void dComIfGp_setItemNowLife(u16 life) {
+    g_dComIfG_gameInfo.play.setItemNowLife(life);
+}
+
+u8 dComIfGp_getMesgStatus() {
+    return g_dComIfG_gameInfo.play.getMesgStatus();
+}
+
+u8 dComIfGp_getRStatus() {
+    return g_dComIfG_gameInfo.play.getRStatus();
+}
+
+bool dComIfGp_isRSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isRSetFlag(flag);
+}
+
+void dComIfGp_setRStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setRStatus(status, flag);
+}
+
+u8 dComIfGp_getRStatusForce() {
+    return g_dComIfG_gameInfo.play.getRStatusForce();
+}
+
+u8 dComIfGp_getRSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getRSetFlagForce();
+}
+
+void dComIfGp_setRStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setRStatusForce(status, flag);
+}
+
+u8 dComIfGp_getAStatus() {
+    return g_dComIfG_gameInfo.play.getAStatus();
+}
+
+bool dComIfGp_isASetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isASetFlag(flag);
+}
+
+void dComIfGp_setAStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setAStatus(status, flag);
+}
+
+u8 dComIfGp_getAStatusForce() {
+    return g_dComIfG_gameInfo.play.getAStatusForce();
+}
+
+u8 dComIfGp_getASetFlagForce() {
+    return g_dComIfG_gameInfo.play.getASetFlagForce();
+}
+
+void dComIfGp_setAStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setAStatusForce(status, flag);
+}
+
+u8 dComIfGp_getNunStatus() {
+    return g_dComIfG_gameInfo.play.getNunStatus();
+}
+
+bool dComIfGp_isNunSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isNunSetFlag(flag);
+}
+
+void dComIfGp_setNunStatus(u8 status, u8 param_1, u8 flag) {
+    g_dComIfG_gameInfo.play.setNunStatus(status, param_1, flag);
+}
+
+u8 dComIfGp_getBottleStatus() {
+    return g_dComIfG_gameInfo.play.getBottleStatus();
+}
+
+bool dComIfGp_isBottleSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isBottleSetFlag(flag);
+}
+
+void dComIfGp_setBottleStatus(u8 param_0, u8 param_1) {
+    g_dComIfG_gameInfo.play.setBottleStatus(param_0, param_1);
+}
+
+u8 dComIfGp_getBottleStatusForce() {
+    return g_dComIfG_gameInfo.play.getBottleStatusForce();
+}
+
+u8 dComIfGp_getBottleSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getBottleSetFlagForce();
+}
+
+void dComIfGp_setBottleStatusForce(u8 param_0, u8 param_1) {
+    g_dComIfG_gameInfo.play.setBottleStatusForce(param_0, param_1);
+}
+
+u8 dComIfGp_getRemoConStatus() {
+    return g_dComIfG_gameInfo.play.getRemoConStatus();
+}
+
+bool dComIfGp_isRemoConSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isRemoConSetFlag(flag);
+}
+
+void dComIfGp_setRemoConStatus(u8 status, u8 param_1, u8 flag) {
+    g_dComIfG_gameInfo.play.setRemoConStatus(status, param_1, flag);
+}
+
+u8 dComIfGp_getDoStatus() {
+    return g_dComIfG_gameInfo.play.getDoStatus();
+}
+
+bool dComIfGp_isDoSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isDoSetFlag(flag);
+}
+
+void dComIfGp_setDoStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setDoStatus(status, flag);
+}
+
+u8 dComIfGp_getDoStatusForce() {
+    return g_dComIfG_gameInfo.play.getDoStatusForce();
+}
+
+u8 dComIfGp_getDoSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getDoSetFlagForce();
+}
+
+void dComIfGp_setDoStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setDoStatusForce(status, flag);
+}
+
+u8 dComIfGp_get3DStatus() {
+    return g_dComIfG_gameInfo.play.get3DStatus();
+}
+
+u8 dComIfGp_get3DDirection() {
+    return g_dComIfG_gameInfo.play.get3DDirection();
+}
+
+bool dComIfGp_is3DSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.is3DSetFlag(flag);
+}
+
+void dComIfGp_set3DStatus(u8 status, u8 direction, u8 flag) {
+    g_dComIfG_gameInfo.play.set3DStatus(status, direction, flag);
+}
+
+u8 dComIfGp_get3DStatusForce() {
+    return g_dComIfG_gameInfo.play.get3DStatusForce();
+}
+
+u8 dComIfGp_get3DDirectionForce() {
+    return g_dComIfG_gameInfo.play.get3DDirectionForce();
+}
+
+u8 dComIfGp_get3DSetFlagForce() {
+    return g_dComIfG_gameInfo.play.get3DSetFlagForce();
+}
+
+void dComIfGp_set3DStatusForce(u8 status, u8 direction, u8 flag) {
+    g_dComIfG_gameInfo.play.set3DStatusForce(status, direction, flag);
+}
+
+u8 dComIfGp_getCStickStatus() {
+    return g_dComIfG_gameInfo.play.getCStickStatus();
+}
+
+u8 dComIfGp_getCStickDirection() {
+    return g_dComIfG_gameInfo.play.getCStickDirection();
+}
+
+bool dComIfGp_isCStickSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isCStickSetFlag(flag);
+}
+
+void dComIfGp_setCStickStatus(u8 status, u8 param_1, u8 flag) {
+    g_dComIfG_gameInfo.play.setCStickStatus(status, param_1, flag);
+}
+
+u8 dComIfGp_getCStickStatusForce() {
+    return g_dComIfG_gameInfo.play.getCStickStatusForce();
+}
+
+u8 dComIfGp_getCStickDirectionForce() {
+    return g_dComIfG_gameInfo.play.getCStickDirectionForce();
+}
+
+u8 dComIfGp_getCStickSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getCStickSetFlagForce();
+}
+
+void dComIfGp_setCStickStatusForce(u8 status, u8 param_1, u8 flag) {
+    g_dComIfG_gameInfo.play.setCStickStatusForce(status, param_1, flag);
+}
+
+u8 dComIfGp_getSButtonStatus() {
+    return g_dComIfG_gameInfo.play.getSButtonStatus();
+}
+
+bool dComIfGp_isSButtonSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isSButtonSetFlag(flag);
+}
+
+void dComIfGp_setSButtonStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setSButtonStatus(status, flag);
+}
+
+u8 dComIfGp_getSButtonStatusForce() {
+    return g_dComIfG_gameInfo.play.getSButtonStatusForce();
+}
+
+u8 dComIfGp_getSButtonSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getSButtonSetFlagForce();
+}
+
+void dComIfGp_setSButtonStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setSButtonStatusForce(status, flag);
+}
+
+u8 dComIfGp_getZStatus() {
+    return g_dComIfG_gameInfo.play.getZStatus();
+}
+
+bool dComIfGp_isZSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isZSetFlag(flag);
+}
+
+void dComIfGp_setZStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setZStatus(status, flag);
+}
+
+u8 dComIfGp_getZStatusForce() {
+    return g_dComIfG_gameInfo.play.getZStatusForce();
+}
+
+u8 dComIfGp_getZSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getZSetFlagForce();
+}
+
+void dComIfGp_setZStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setZStatusForce(status, flag);
+}
+
+u8 dComIfGp_getXStatus() {
+    return g_dComIfG_gameInfo.play.getXStatus();
+}
+
+bool dComIfGp_isXSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isXSetFlag(flag);
+}
+
+void dComIfGp_setXStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setXStatus(status, flag);
+}
+
+u8 dComIfGp_getXStatusForce() {
+    return g_dComIfG_gameInfo.play.getXStatusForce();
+}
+
+u8 dComIfGp_getXSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getXSetFlagForce();
+}
+
+void dComIfGp_setXStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setXStatusForce(status, flag);
+}
+
+u8 dComIfGp_getYStatus() {
+    return g_dComIfG_gameInfo.play.getYStatus();
+}
+
+bool dComIfGp_isYSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isYSetFlag(flag);
+}
+
+void dComIfGp_setYStatus(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setYStatus(status, flag);
+}
+
+u8 dComIfGp_getYStatusForce() {
+    return g_dComIfG_gameInfo.play.getYStatusForce();
+}
+
+u8 dComIfGp_getYSetFlagForce() {
+    return g_dComIfG_gameInfo.play.getYSetFlagForce();
+}
+
+void dComIfGp_setYStatusForce(u8 status, u8 flag) {
+    g_dComIfG_gameInfo.play.setYStatusForce(status, flag);
+}
+
+u8 dComIfGp_getNunZStatus() {
+    return g_dComIfG_gameInfo.play.getNunZStatus();
+}
+
+bool dComIfGp_isNunZSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isNunZSetFlag(flag);
+}
+
+void dComIfGp_setNunZStatus(u8 param_0, u8 param_1) {
+    g_dComIfG_gameInfo.play.setNunZStatus(param_0, param_1);
+}
+
+u8 dComIfGp_getNunCStatus() {
+    return g_dComIfG_gameInfo.play.getNunCStatus();
+}
+
+bool dComIfGp_isNunCSetFlag(u8 flag) {
+    return g_dComIfG_gameInfo.play.isNunCSetFlag(flag);
+}
+
+void dComIfGp_setNunCStatus(u8 param_0, u8 param_1) {
+    g_dComIfG_gameInfo.play.setNunCStatus(param_0, param_1);
+}
+
+void dComIfGp_setSelectEquipClothes(u8 i_clothNo) {
+    g_dComIfG_gameInfo.play.setSelectEquip(COLLECT_CLOTHING, i_clothNo);
+}
+
+void dComIfGp_setSelectEquipSword(u8 i_swordNo) {
+    g_dComIfG_gameInfo.play.setSelectEquip(COLLECT_SWORD, i_swordNo);
+}
+
+void dComIfGp_setSelectEquipShield(u8 i_shieldNo) {
+    g_dComIfG_gameInfo.play.setSelectEquip(COLLECT_SHIELD, i_shieldNo);
+}
+
+u8 dComIfGp_getMesgAnimeAttrInfo() {
+    return g_dComIfG_gameInfo.play.getBaseAnimeID();
+}
+
+void dComIfGp_setMesgAnimeAttrInfo(u8 param_1) {
+    g_dComIfG_gameInfo.play.setBaseAnimeID(param_1);
+}
+
+void dComIfGp_clearMesgAnimeAttrInfo() {
+    g_dComIfG_gameInfo.play.clearBaseAnimeID();
+}
+
+u8 dComIfGp_getMesgFaceAnimeAttrInfo() {
+    return g_dComIfG_gameInfo.play.getFaceAnimeID();
+}
+
+void dComIfGp_setMesgFaceAnimeAttrInfo(u8 id) {
+    g_dComIfG_gameInfo.play.setFaceAnimeID(id);
+}
+
+void dComIfGp_clearMesgFaceAnimeAttrInfo() {
+    g_dComIfG_gameInfo.play.clearFaceAnimeID();
+}
+
+void dComIfGp_clearMesgAnimeTagInfo() {
+    g_dComIfG_gameInfo.play.clearNowAnimeID();
+}
+
+void dComIfGp_setItem(u8 slot, u8 i_no) {
+    g_dComIfG_gameInfo.play.setItem(slot, i_no);
+}
+
+u8 dComIfGp_getAdvanceDirection() {
+    return g_dComIfG_gameInfo.play.getDirection();
+}
+
+void dComIfGp_setAdvanceDirection(u8 i_dir) {
+    g_dComIfG_gameInfo.play.setDirection(i_dir);
+}
+
+u8 dComIfGp_checkMesgCancelButton() {
+    return g_dComIfG_gameInfo.play.checkMesgCancelButton();
+}
+
+void dComIfGp_setMesgCancelButton(u8 button) {
+    g_dComIfG_gameInfo.play.setMesgCancelButton(button);
+}
+
+u8 dComIfGp_getGameoverStatus() {
+    return g_dComIfG_gameInfo.play.getGameoverStatus();
+}
+
+void dComIfGp_setGameoverStatus(u8 i_status) {
+    return g_dComIfG_gameInfo.play.setGameoverStatus(i_status);
+}
+
+u8 dComIfGp_isHeapLockFlag() {
+    return g_dComIfG_gameInfo.play.isHeapLockFlag();
+}
+
+u8 dComIfGp_getSubHeapLockFlag(int idx) {
+    return g_dComIfG_gameInfo.play.getSubHeapLockFlag(idx);
+}
+
+void dComIfGp_setSubHeapLockFlag(int idx, u8 status) {
+    g_dComIfG_gameInfo.play.setSubHeapLockFlag(idx, status);
+}
+
+u8 dComIfGp_getNeedLightDropNum() {
+    return g_dComIfG_gameInfo.play.getNeedLightDropNum();
+}
+
+void dComIfGp_setNeedLightDropNum(u8 i_num) {
+    g_dComIfG_gameInfo.play.setNeedLightDropNum(i_num);
+}
+
+u8 dComIfGp_checkMesgBgm() {
+    return g_dComIfG_gameInfo.play.checkMesgBgm();
+}
+
+void dComIfGp_setMesgBgmOff() {
+    g_dComIfG_gameInfo.play.setMesgBgm(0);
+}
+
+void dComIfGp_setMesgBgmOn() {
+    g_dComIfG_gameInfo.play.setMesgBgm(1);
+}
+
+u8 dComIfGp_isPauseFlag() {
+    return g_dComIfG_gameInfo.play.isPauseFlag();
+}
+
+void dComIfGp_offPauseFlag() {
+    g_dComIfG_gameInfo.play.offPauseFlag();
+}
+
+void dComIfGp_onPauseFlag() {
+    g_dComIfG_gameInfo.play.onPauseFlag();
+}
+
+u8 dComIfGp_getOxygenShowFlag() {
+    return g_dComIfG_gameInfo.play.getOxygenShowFlag();
+}
+
+void dComIfGp_offOxygenShowFlag() {
+    g_dComIfG_gameInfo.play.setOxygenShowFlag(0);
+}
+
+void dComIfGp_onOxygenShowFlag() {
+    g_dComIfG_gameInfo.play.setOxygenShowFlag(1);
+}
+
+u8 dComIfGp_2dShowCheck() {
+    return g_dComIfG_gameInfo.play.show2dCheck();
+}
+
+void dComIfGp_2dShowOn() {
+    g_dComIfG_gameInfo.play.show2dOn();
+}
+
+void dComIfGp_2dShowOff() {
+    g_dComIfG_gameInfo.play.show2dOff();
+}
+
+JKRExpHeap* dComIfGp_getExpHeap2D() {
+    return g_dComIfG_gameInfo.play.getExpHeap2D();
+}
+
+void dComIfGp_setExpHeap2D(void* heap) {
+    g_dComIfG_gameInfo.play.setExpHeap2D(heap);
+}
+
+JKRExpHeap* dComIfGp_getSubExpHeap2D(int idx) {
+    return g_dComIfG_gameInfo.play.getSubExpHeap2D(idx);
+}
+
+void dComIfGp_setSubExpHeap2D(int idx, void* heap) {
+    g_dComIfG_gameInfo.play.setSubExpHeap2D(idx, heap);
+}
+
+JKRExpHeap* dComIfGp_getMsgExpHeap() {
+    return g_dComIfG_gameInfo.play.getMsgExpHeap();
+}
+
+void dComIfGp_setMsgExpHeap(void* heap) {
+    g_dComIfG_gameInfo.play.setMsgExpHeap(heap);
+}
+
+dComIfG_MesgCamInfo_c* dComIfGp_getMesgCameraInfo() {
+    return g_dComIfG_gameInfo.play.getMesgCamInfo();
+}
+
+void dComIfGp_setMesgCameraTagInfo(int id) {
+    g_dComIfG_gameInfo.play.setMesgCamInfoID(id);
+}
+
+void dComIfGp_clearMesgCameraTagInfo() {
+    g_dComIfG_gameInfo.play.clearMesgCamInfoID();
+}
+
+void dComIfGp_setMesgCameraAttrInfo(int param_1) {
+    g_dComIfG_gameInfo.play.setMesgCamInfoBasicID(param_1);
+}
+
+void dComIfGp_clearMesgCameraAttrInfo() {
+    g_dComIfG_gameInfo.play.clearMesgCamInfoBasicID();
+}
+
+void dComIfGp_setMesgCameraInfoActor(fopAc_ac_c* param_1, fopAc_ac_c* param_2, fopAc_ac_c* param_3,
+    fopAc_ac_c* param_4, fopAc_ac_c* param_5, fopAc_ac_c* param_6, fopAc_ac_c* param_7,
+    fopAc_ac_c* param_8, fopAc_ac_c* param_9, fopAc_ac_c* param_10)
+
+{
+    g_dComIfG_gameInfo.play.setMesgCamInfoActor(
+        param_1, param_2, param_3, param_4, param_5, param_6, param_7, param_8, param_9, param_10);
+}
+
+u32 dComIfGp_checkPlayerStatus0(int param_0, u32 flag) {
+    return g_dComIfG_gameInfo.play.checkPlayerStatus(param_0, 0, flag);
+}
+
+u32 dComIfGp_checkPlayerStatus1(int param_0, u32 flag) {
+    return g_dComIfG_gameInfo.play.checkPlayerStatus(param_0, 1, flag);
+}
+
+void dComIfGp_setPlayerStatus0(int param_0, u32 flag) {
+    g_dComIfG_gameInfo.play.setPlayerStatus(param_0, 0, flag);
+}
+
+void dComIfGp_setPlayerStatus1(int param_0, u32 flag) {
+    g_dComIfG_gameInfo.play.setPlayerStatus(param_0, 1, flag);
+}
+
+void dComIfGp_clearPlayerStatus0(int param_0, u32 flag) {
+    g_dComIfG_gameInfo.play.clearPlayerStatus(param_0, 0, flag);
+}
+
+void dComIfGp_clearPlayerStatus1(int param_0, u32 flag) {
+    g_dComIfG_gameInfo.play.clearPlayerStatus(param_0, 1, flag);
+}
+
+void dComIfGp_setCurrentWindow(dDlst_window_c* i_window) {
+    g_dComIfG_gameInfo.play.setCurrentWindow(i_window);
+}
+
+void dComIfGp_setCurrentView(view_class* i_view) {
+    g_dComIfG_gameInfo.play.setCurrentView(i_view);
+}
+
+void dComIfGp_setCurrentViewport(view_port_class* i_viewport) {
+    g_dComIfG_gameInfo.play.setCurrentViewport(i_viewport);
+}
+
+J2DGrafContext* dComIfGp_getCurrentGrafPort() {
+    return g_dComIfG_gameInfo.play.getCurrentGrafPort();
+}
+
+void dComIfGp_setCurrentGrafPort(J2DOrthoGraph* i_graf) {
+    g_dComIfG_gameInfo.play.setCurrentGrafPort(i_graf);
+}
+
+void* dComIfGp_getItemTable() {
+    return g_dComIfG_gameInfo.play.getItemTable();
+}
+
+void dComIfGp_setItemTable(void* data) {
+    g_dComIfG_gameInfo.play.setItemTable(data);
+}
+
+char* dComIfGp_getLastPlayStageName() {
+    return g_dComIfG_gameInfo.play.getLastPlayStageName();
+}
+
+void dComIfGp_setLastPlayStageName(char* name) {
+    g_dComIfG_gameInfo.play.setLastPlayStageName(name);
+}
+
+void dComIfGp_init() {
+    g_dComIfG_gameInfo.play.init();
+}
+
+void dComIfGp_itemDataInit() {
+    g_dComIfG_gameInfo.play.itemInit();
+}
+
+void dComIfGp_setItemBombNumCount(u8 i_item, s16 count) {
+    g_dComIfG_gameInfo.play.setItemBombNumCount(i_item, count);
+}
+
+s16 dComIfGp_getItemBombNumCount(u8 i_no) {
+    return g_dComIfG_gameInfo.play.getItemBombNumCount(i_no);
+}
+
+void dComIfGp_clearItemBombNumCount(u8 i_no) {
+    g_dComIfG_gameInfo.play.clearItemBombNumCount(i_no);
+}
+
+s16 dComIfGp_getItemMaxBombNumCount() {
+    return g_dComIfG_gameInfo.play.getItemMaxBombNumCount(dItemNo_NORMAL_BOMB_e);
+}
+
+void dComIfGp_setNowVibration(u8 status) {
+    g_dComIfG_gameInfo.play.setNowVibration(status);
+}
+
+u32 dComIfGp_getNowVibration() {
+    return g_dComIfG_gameInfo.play.getNowVibration();
+}
+
+void dComIfGp_particle_create() {
+    g_dComIfG_gameInfo.play.createParticle();
+}
+
+void dComIfGp_createSimpleModel() {
+    g_dComIfG_gameInfo.play.createSimpleModel();
+}
+
+void dComIfGp_deleteSimpleModel() {
+    g_dComIfG_gameInfo.play.deleteSimpleModel();
+}
+
+void dComIfGp_drawSimpleModel() {
+    g_dComIfG_gameInfo.play.drawSimpleModel();
+}
+
+int dComIfGp_addSimpleModel(J3DModelData* i_modelData, int roomNo, u8 i_drawBG) {
+    return g_dComIfG_gameInfo.play.addSimpleModel(i_modelData, roomNo, i_drawBG);
+}
+
+void dComIfGp_removeSimpleModel(J3DModelData* i_modelData, int roomNo) {
+    g_dComIfG_gameInfo.play.removeSimpleModel(i_modelData, roomNo);
+}
+
+void dComIfGp_entrySimpleModel(J3DModel* model, int roomNo) {
+    g_dComIfG_gameInfo.play.entrySimpleModel(model, roomNo);
+}
+
+void dComIfG_ct() {
+    g_dComIfG_gameInfo.ct();
+}
+
+dBgS& dComIfG_Bgsp() {
+    return g_dComIfG_gameInfo.play.mBgs;
+}
+
+dCcS* dComIfG_Ccsp() {
+    return &g_dComIfG_gameInfo.play.mCcs;
+}
+
+dCcS& dComIfG_Ccsp2() {
+    return g_dComIfG_gameInfo.play.mCcs;
+}
+
+void dComIfG_setTimerNowTimeMs(int time) {
+    g_dComIfG_gameInfo.play.setTimerNowTimeMs(time);
+}
+
+int dComIfG_getTimerNowTimeMs() {
+    return g_dComIfG_gameInfo.play.getTimerNowTimeMs();
+}
+
+void dComIfG_setTimerLimitTimeMs(int i_time) {
+    g_dComIfG_gameInfo.play.setTimerLimitTimeMs(i_time);
+}
+
+int dComIfG_getTimerLimitTimeMs() {
+    return g_dComIfG_gameInfo.play.getTimerLimitTimeMs();
+}
+
+void dComIfG_setTimerMode(int mode) {
+    return g_dComIfG_gameInfo.play.setTimerMode(mode);
+}
+
+int dComIfG_getTimerMode() {
+    return g_dComIfG_gameInfo.play.getTimerMode();
+}
+
+void dComIfG_setTimerType(u8 i_type) {
+    g_dComIfG_gameInfo.play.setTimerType(i_type);
+}
+
+u8 dComIfG_getTimerType() {
+    return g_dComIfG_gameInfo.play.getTimerType();
+}
+
+void dComIfG_setTimerPtr(dTimer_c* i_ptr) {
+    g_dComIfG_gameInfo.play.setTimerPtr(i_ptr);
+}
+
+dTimer_c* dComIfG_getTimerPtr() {
+    return g_dComIfG_gameInfo.play.getTimerPtr();
+}
+
+/**
+ * Attempts to add a new Object Resource Archive (*.arc) into the Resource Control.
+ * @param i_arcName Name of archive to be added
+ * @param i_mountDirection The direction to mount the archive. mDoDvd_MOUNT_DIRECTION_HEAD or
+ * mDoDvd_MOUNT_DIRECTION_TAIL
+ * @param i_heap Pointer to heap to load resources into
+ * @return TRUE if successful, FALSE otherwise
+ */
+int dComIfG_setObjectRes(const char* i_arcName, u8 i_mountDirection, JKRHeap* i_heap) {
+    return g_dComIfG_gameInfo.mResControl.setObjectRes(i_arcName, i_mountDirection, i_heap);
+}
+
+int dComIfG_setObjectRes(
+    const char* i_arcName, void* i_archiveRes, u32 i_bufferSize, JKRHeap* i_heap) {
+    UNUSED(i_heap);
+    return g_dComIfG_gameInfo.mResControl.setObjectRes(i_arcName, i_archiveRes, i_bufferSize, NULL);
+}
+
+/**
+ * Attempts to add a new Stage Resource Archive (*.arc) into the Resource Control.
+ * @param i_arcName Name of archive to be added
+ * @param i_heap Pointer to heap to load resources into
+ * @return TRUE if successful, FALSE otherwise
+ */
+int dComIfG_setStageRes(const char* i_arcName, JKRHeap* i_heap) {
+    return g_dComIfG_gameInfo.mResControl.setStageRes(i_arcName, i_heap);
+}
+
+int dComIfG_syncObjectRes(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.syncObjectRes(i_arcName);
+}
+
+int dComIfG_syncStageRes(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.syncStageRes(i_arcName);
+}
+
+int dComIfG_deleteObjectResMain(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.deleteObjectRes(i_arcName);
+}
+
+int dComIfG_deleteStageRes(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.deleteStageRes(i_arcName);
+}
+
+void* dComIfG_getStageRes(const char* i_arcName, const char* i_resName) {
+    return g_dComIfG_gameInfo.mResControl.getStageRes(i_arcName, i_resName);
+}
+
+void* dComIfG_getObjectRes(const char* i_arcName, const char* i_resName) {
+    return g_dComIfG_gameInfo.mResControl.getObjectRes(i_arcName, i_resName);
+}
+
+void* dComIfG_getObjectRes(const char* i_arcName, int i_index) {
+    return g_dComIfG_gameInfo.mResControl.getObjectRes(i_arcName, i_index);
+}
+
+void dComIfG_dumpResControl() {
+    g_dComIfG_gameInfo.mResControl.dump();
+}
+
+dRes_info_c* dComIfG_getObjectResInfo(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.getObjectResInfo(i_arcName);
+}
+
+dRes_info_c* dComIfG_getStageResInfo(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.getStageResInfo(i_arcName);
+}
+
+int dComIfG_syncAllObjectRes() {
+    return g_dComIfG_gameInfo.mResControl.syncAllObjectRes();
+}
+
+void* dComIfG_getObjectIDRes(const char* i_arcName, u16 i_resID) {
+    return g_dComIfG_gameInfo.mResControl.getObjectIDRes(i_arcName, i_resID);
+}
+
+int dComIfG_getObjctResName2Index(const char* i_arcName, const char* i_resName) {
+    return g_dComIfG_gameInfo.mResControl.getObjectResName2Index(i_arcName, i_resName);
+}
+
+u8 dComIfG_getBrightness() {
+    return g_dComIfG_gameInfo.mFadeBrightness;
+}
+
+void dComIfG_setBrightness(u8 brightness) {
+    g_dComIfG_gameInfo.mFadeBrightness = brightness;
+}
+
+BOOL dComIfG_isDebugMode() {
+    return g_dComIfG_gameInfo.mIsDebugMode;
+}
+
+u32 dComIfG_getTrigB(u32 i_padNo) {
+    return mDoCPd_c::getTrig(i_padNo) & PAD_BUTTON_B;
+}
+
+#if DEBUG
+u32 dComIfG_getObjectAllSize() {
+    return g_dComIfG_gameInfo.mResControl.getObjectAllSize();
+}
+
+u32 dComIfG_getStageAllSize() {
+    return g_dComIfG_gameInfo.mResControl.getStageAllSize();
+}
+
+u32 dComIfG_getObjectSize(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.getObjectSize(i_arcName);
+}
+
+u32 dComIfG_getStageSize(const char* i_arcName) {
+    return g_dComIfG_gameInfo.mResControl.getStageSize(i_arcName);
+}
+
+void dComIfG_initStopwatch() {
+    OSInitStopwatch(&g_dComIfG_gameInfo.mStopwatch, "dComIfG");
+}
+#endif
+
+int dComIfGd_setRealShadow(u32 param_0, s8 param_1, J3DModel* param_2, cXyz* param_3, f32 param_4,
+    f32 param_5, dKy_tevstr_c* param_6) {
+    return g_dComIfG_gameInfo.drawlist.setRealShadow(
+        param_0, param_1, param_2, param_3, param_4, param_5, param_6);
+}
+
+int dComIfGd_setSimpleShadow(
+    cXyz* pos, f32 param_1, f32 param_2, cXyz* param_3, s16 angle, f32 param_5, TGXTexObj* tex) {
+    return g_dComIfG_gameInfo.drawlist.setSimpleShadow(
+        pos, param_1, param_2, param_3, angle, param_5, tex);
+}
+
+bool dComIfGd_addRealShadow(u32 key, J3DModel* model) {
+    return g_dComIfG_gameInfo.drawlist.addRealShadow(key, model);
+}
+
+void dComIfGd_drawListItem3d() {
+    g_dComIfG_gameInfo.drawlist.drawOpaListItem3d();
+    g_dComIfG_gameInfo.drawlist.drawXluListItem3d();
+}
+
+#if VERSION > VERSION_GCN_JPN
+void dComIfGd_drawListCursor() {
+    g_dComIfG_gameInfo.drawlist.drawOpaListCursor();
+    g_dComIfG_gameInfo.drawlist.drawXluListCursor();
+}
+#endif
+
+void dComIfGd_reset() {
+    g_dComIfG_gameInfo.drawlist.reset();
+}
+
+void dComIfGd_set2DOpa(dDlst_base_c* dlst) {
+    g_dComIfG_gameInfo.drawlist.set2DOpa(dlst);
+}
+
+void dComIfGd_set2DXlu(dDlst_base_c* dlst) {
+    g_dComIfG_gameInfo.drawlist.set2DXlu(dlst);
+}
+
+void dComIfGd_set2DOpaTop(dDlst_base_c* dlst) {
+    g_dComIfG_gameInfo.drawlist.set2DOpaTop(dlst);
+}
+
+void dComIfGd_setCopy2D(dDlst_base_c* dlst) {
+    g_dComIfG_gameInfo.drawlist.setCopy2D(dlst);
+}
+
+view_class* dComIfGd_getView() {
+    return g_dComIfG_gameInfo.drawlist.getView();
+}
+
+Mtx44* dComIfGd_getProjViewMtx() {
+    return &(g_dComIfG_gameInfo.drawlist.getView()->projViewMtx);
+}
+
+MtxP dComIfGd_getInvViewMtx() {
+    return g_dComIfG_gameInfo.drawlist.getView()->invViewMtx;
+}
+
+view_port_class* dComIfGd_getViewport() {
+    return g_dComIfG_gameInfo.drawlist.getViewport();
+}
+
+MtxP dComIfGd_getViewRotMtx() {
+    return g_dComIfG_gameInfo.drawlist.getView()->viewMtxNoTrans;
+}
+MtxP dComIfGd_getViewMtx() {
+    return g_dComIfG_gameInfo.drawlist.getView()->viewMtx;
+}
+
+J3DDrawBuffer* dComIfGd_getListFilter() {
+    return g_dComIfG_gameInfo.drawlist.getOpaListFilter();
+}
+
+J3DDrawBuffer* dComIfGd_getOpaListIndScreen() {
+    return g_dComIfG_gameInfo.drawlist.getOpaListP0();
+}
+
+J3DDrawBuffer* dComIfGd_getListPacket() {
+    return g_dComIfG_gameInfo.drawlist.getOpaListPacket();
+}
+
+void dComIfGd_setListSky() {
+    g_dComIfG_gameInfo.drawlist.setOpaListSky();
+    g_dComIfG_gameInfo.drawlist.setXluListSky();
+}
+
+void dComIfGd_setListDark() {
+    g_dComIfG_gameInfo.drawlist.setOpaListDark();
+    g_dComIfG_gameInfo.drawlist.setXluListDark();
+}
+
+void dComIfGd_setListInvisisble() {
+    g_dComIfG_gameInfo.drawlist.setOpaListInvisible();
+    g_dComIfG_gameInfo.drawlist.setXluListInvisible();
+}
+
+void dComIfGd_setListDarkBG() {
+    g_dComIfG_gameInfo.drawlist.setOpaListDarkBG();
+    g_dComIfG_gameInfo.drawlist.setXluListDarkBG();
+}
+
+void dComIfGd_setXluListDarkBG() {
+    g_dComIfG_gameInfo.drawlist.setXluListDarkBG();
+}
+
+void dComIfGd_setList() {
+    g_dComIfG_gameInfo.drawlist.setOpaList();
+    g_dComIfG_gameInfo.drawlist.setXluList();
+}
+
+void dComIfGd_setListItem3D() {
+    g_dComIfG_gameInfo.drawlist.setOpaListItem3D();
+    g_dComIfG_gameInfo.drawlist.setXluListItem3D();
+}
+
+void dComIfGd_setList3Dlast() {
+    g_dComIfG_gameInfo.drawlist.setOpaList3Dlast();
+    g_dComIfG_gameInfo.drawlist.setXluList3Dlast();
+}
+
+void dComIfGd_setXluList2DScreen() {
+    g_dComIfG_gameInfo.drawlist.setXluList2DScreen();
+}
+
+void dComIfGd_setXluListBG() {
+    g_dComIfG_gameInfo.drawlist.setXluListBG();
+}
+
+void dComIfGd_setListBG() {
+    g_dComIfG_gameInfo.drawlist.setOpaListBG();
+    g_dComIfG_gameInfo.drawlist.setXluListBG();
+}
+
+void dComIfGd_setListIndScreen() {
+    g_dComIfG_gameInfo.drawlist.setOpaListP0();
+    g_dComIfG_gameInfo.drawlist.setXluListP0();
+}
+
+void dComIfGd_setListMiddle() {
+    g_dComIfG_gameInfo.drawlist.setOpaListMiddle();
+    g_dComIfG_gameInfo.drawlist.setXluListMiddle();
+}
+
+void dComIfGd_setListZxlu() {
+    g_dComIfG_gameInfo.drawlist.setOpaListZxlu();
+    g_dComIfG_gameInfo.drawlist.setXluListZxlu();
+}
+
+J3DDrawBuffer* dComIfGd_getOpaList() {
+    return g_dComIfG_gameInfo.drawlist.getOpaList();
+}
+
+J3DDrawBuffer* dComIfGd_getOpaListBG() {
+    return g_dComIfG_gameInfo.drawlist.getOpaListBG();
+}
+
+J3DDrawBuffer* dComIfGd_getOpaListDark() {
+    return g_dComIfG_gameInfo.drawlist.getOpaListDark();
+}
+
+J3DDrawBuffer* dComIfGd_getXluListBG() {
+    return g_dComIfG_gameInfo.drawlist.getXluListBG();
+}
+
+void dComIfGd_setListFilter() {
+    g_dComIfG_gameInfo.drawlist.setOpaListFilter();
+    g_dComIfG_gameInfo.drawlist.setXluListFilter();
+}
+
+void dComIfGd_init() {
+    g_dComIfG_gameInfo.drawlist.init();
+}
+
+void dComIfGd_peekZ(s16 param_0, s16 param_1, u32* param_2) {
+    g_dComIfG_gameInfo.drawlist.newPeekZdata(param_0, param_1, param_2);
+}
+
+void dComIfGd_peekZdata() {
+    g_dComIfG_gameInfo.drawlist.peekZdata();
+}
+
+void dComIfGd_setView(view_class* view) {
+    g_dComIfG_gameInfo.drawlist.setView(view);
+}
+
+void dComIfGd_setWindow(dDlst_window_c* window) {
+    g_dComIfG_gameInfo.drawlist.setWindow(window);
+}
+
+void dComIfGd_setViewport(view_port_class* port) {
+    g_dComIfG_gameInfo.drawlist.setViewport(port);
+}
+
+void dComIfGd_entryZSortListZxlu(J3DPacket* i_packet, cXyz& param_1) {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.entryZSortListZxlu(i_packet, param_1);
+}
+
+void dComIfGd_entryZSortXluList(J3DPacket* i_packet, cXyz& param_1) {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.entryZSortXluList(i_packet, param_1);
+}
+
+void dComIfGd_drawCopy2D() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawCopy2D();
+}
+
+void dComIfGd_drawOpaListSky() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListSky();
+}
+
+void dComIfGd_drawXluListSky() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluListSky();
+}
+
+void dComIfGd_drawOpaListBG() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListBG();
+}
+
+void dComIfGd_drawOpaListDarkBG() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListDarkBG();
+}
+
+void dComIfGd_drawOpaListMiddle() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListMiddle();
+}
+
+void dComIfGd_drawOpaList() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaList();
+}
+
+void dComIfGd_drawOpaListDark() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListDark();
+}
+
+void dComIfGd_drawOpaListPacket() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListPacket();
+}
+
+void dComIfGd_drawXluListBG() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluListBG();
+}
+
+void dComIfGd_drawXluListDarkBG() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluListDarkBG();
+}
+
+void dComIfGd_drawXluList() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluList();
+}
+
+void dComIfGd_drawXluListDark() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluListDark();
+}
+
+void dComIfGd_drawXluListZxlu() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluListZxlu();
+}
+
+void dComIfGd_drawXluList2DScreen() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluList2DScreen();
+}
+
+void dComIfGd_drawOpaList3Dlast() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaList3Dlast();
+}
+
+void dComIfGd_draw2DOpa() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.draw2DOpa();
+}
+
+void dComIfGd_draw2DOpaTop() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.draw2DOpaTop();
+}
+
+void dComIfGd_draw2DXlu() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.draw2DXlu();
+}
+
+void dComIfGd_drawOpaListFilter() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListFilter();
+}
+
+void dComIfGd_drawIndScreen() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawOpaListP0();
+}
+
+void dComIfGd_drawListZxlu() {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawXluListZxlu();
+}
+
+void dComIfGd_drawShadow(Mtx param_0) {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.drawShadow(param_0);
+}
+
+void dComIfGd_imageDrawShadow(Mtx param_0) {
+    ZoneScoped;
+    g_dComIfG_gameInfo.drawlist.imageDrawShadow(param_0);
+}
+
+void dComIfGd_set3DlineMat(mDoExt_3DlineMat_c* param_0) {
+    g_dComIfG_gameInfo.drawlist.set3DlineMat(param_0);
+}
+
+void dComIfGd_set3DlineMatDark(mDoExt_3DlineMat_c* param_0) {
+    g_dComIfG_gameInfo.drawlist.set3DlineMatDark(param_0);
+}
+
+#if PLATFORM_WII || VERSION == VERSION_SHIELD_DEBUG
+void dComIfGd_setListCursor() {
+    g_dComIfG_gameInfo.drawlist.setOpaListCursor();
+    g_dComIfG_gameInfo.drawlist.setXluListCursor();
+}
+#endif
+
+void dComIfGd_drawXluListInvisible() {
+    ZoneScoped;
+    if (!dusk::getSettings().game.disableWaterRefraction) {
+        g_dComIfG_gameInfo.drawlist.drawXluListInvisible();
+    }
+}
+
+void dComIfGd_drawOpaListInvisible() {
+    ZoneScoped;
+    if (!dusk::getSettings().game.disableWaterRefraction) {
+        g_dComIfG_gameInfo.drawlist.drawOpaListInvisible();
+    }
+}
+#endif
diff --git a/src/d/d_com_static.cpp b/src/d/d_com_static.cpp
index 585d39869b..bc6f99afbf 100644
--- a/src/d/d_com_static.cpp
+++ b/src/d/d_com_static.cpp
@@ -19,7 +19,7 @@
 #include <cstdio>
 #include <cstring>
 
-s16 const daObjMovebox::Act_c::M_dir_base[4] = {
+DUSK_GAME_DATA s16 const daObjMovebox::Act_c::M_dir_base[4] = {
     0x0000,
     0x4000,
     -0x8000,
@@ -132,17 +132,17 @@ void daSus_c::room_c::reset() {
     }
 }
 
-daSus_c::data_c daSus_c::mData[0x20];
+DUSK_GAME_DATA daSus_c::data_c daSus_c::mData[0x20];
 
-daSus_c::room_c daSus_c::mRoom[0x40];
+DUSK_GAME_DATA daSus_c::room_c daSus_c::mRoom[0x40];
 
 #if DEBUG
 daCanBall_c::Hio_c daCanBall_c::mHIO;
 #endif
 
-s16 daArrow_c::m_count;
+DUSK_GAME_DATA s16 daArrow_c::m_count;
 
-s16 daSus_c::mSetTop;
+DUSK_GAME_DATA s16 daSus_c::mSetTop;
 
 int daSus_c::newData(s8 i_roomNo, cXyz const& param_1, cXyz const& param_2, u8 param_3, u8 param_4,
                      u8 i_type) {
@@ -334,17 +334,17 @@ void daNpcKakashi_clrSuccessCount() {
     dComIfGs_setTmpReg(0xFEFF, 0);
 }
 
-bool daYkgr_c::m_flag;
+DUSK_GAME_DATA bool daYkgr_c::m_flag;
 
-bool daYkgr_c::m_alpha_flag;
+DUSK_GAME_DATA bool daYkgr_c::m_alpha_flag;
 
-u8 daYkgr_c::m_alpha;
+DUSK_GAME_DATA u8 daYkgr_c::m_alpha;
 
-f32 daYkgr_c::m_aim_rate;
+DUSK_GAME_DATA f32 daYkgr_c::m_aim_rate;
 
-dPath* daYkgr_c::m_path;
+DUSK_GAME_DATA dPath* daYkgr_c::m_path;
 
-JPABaseEmitter* daYkgr_c::m_emitter;
+DUSK_GAME_DATA JPABaseEmitter* daYkgr_c::m_emitter;
 
 const char* daSetBgObj_c::getArcName(fopAc_ac_c* i_this) {
     static char arcName[8];
@@ -362,23 +362,23 @@ const char* daSetBgObj_c::getArcName(fopAc_ac_c* i_this) {
     return arcName;
 }
 
-f32 const daDsh_c::OPEN_SIZE = 270.1f;
+DUSK_GAME_DATA f32 const daDsh_c::OPEN_SIZE = 270.1f;
 
-f32 const daDsh_c::OPEN_ACCEL = 10.0f;
+DUSK_GAME_DATA f32 const daDsh_c::OPEN_ACCEL = 10.0f;
 
-f32 const daDsh_c::OPEN_SPEED = -40.0f;
+DUSK_GAME_DATA f32 const daDsh_c::OPEN_SPEED = -40.0f;
 
-f32 const daDsh_c::OPEN_BOUND_SPEED = -30.0f;
+DUSK_GAME_DATA f32 const daDsh_c::OPEN_BOUND_SPEED = -30.0f;
 
-f32 const daDsh_c::OPEN_BOUND_RATIO = -0.4f;
+DUSK_GAME_DATA f32 const daDsh_c::OPEN_BOUND_RATIO = -0.4f;
 
-f32 const daDsh_c::CLOSE_ACCEL = 10.0f;
+DUSK_GAME_DATA f32 const daDsh_c::CLOSE_ACCEL = 10.0f;
 
-f32 const daDsh_c::CLOSE_SPEED = 40.0f;
+DUSK_GAME_DATA f32 const daDsh_c::CLOSE_SPEED = 40.0f;
 
-f32 const daDsh_c::CLOSE_BOUND_SPEED = 30.0f;
+DUSK_GAME_DATA f32 const daDsh_c::CLOSE_BOUND_SPEED = 30.0f;
 
-f32 const daDsh_c::CLOSE_BOUND_RATIO = -0.4f;
+DUSK_GAME_DATA f32 const daDsh_c::CLOSE_BOUND_RATIO = -0.4f;
 
 int daTagStream_c::checkArea(cXyz const* param_0) {
     cXyz relativePos;
@@ -391,11 +391,11 @@ int daTagStream_c::checkArea(cXyz const* param_0) {
     return 0;
 }
 
-daMirror_c::entryModelFunc daMirror_c::m_entryModel = NULL;
+DUSK_GAME_DATA daMirror_c::entryModelFunc daMirror_c::m_entryModel = NULL;
 
-daTagStream_c* daTagStream_c::m_top;
+DUSK_GAME_DATA daTagStream_c* daTagStream_c::m_top;
 
-daMirror_c* daMirror_c::m_myObj;
+DUSK_GAME_DATA daMirror_c* daMirror_c::m_myObj;
 
 int daMirror_c::entry(J3DModel* param_0) {
     if (m_myObj == NULL) {
@@ -413,11 +413,11 @@ bool daMirror_c::remove() {
     return true;
 }
 
-dGrass_packet_c::deleteFunc dGrass_packet_c::m_deleteRoom = NULL;
+DUSK_GAME_DATA dGrass_packet_c::deleteFunc dGrass_packet_c::m_deleteRoom = NULL;
 
-daGrass_c* daGrass_c::m_myObj;
+DUSK_GAME_DATA daGrass_c* daGrass_c::m_myObj;
 
-dGrass_packet_c* daGrass_c::m_grass;
+DUSK_GAME_DATA dGrass_packet_c* daGrass_c::m_grass;
 
 void daGrass_c::deleteRoomGrass(int param_0) {
     if (m_grass) {
@@ -425,9 +425,9 @@ void daGrass_c::deleteRoomGrass(int param_0) {
     }
 }
 
-dFlower_packet_c::deleteFunc dFlower_packet_c::m_deleteRoom = NULL;
+DUSK_GAME_DATA dFlower_packet_c::deleteFunc dFlower_packet_c::m_deleteRoom = NULL;
 
-dFlower_packet_c* daGrass_c::m_flower;
+DUSK_GAME_DATA dFlower_packet_c* daGrass_c::m_flower;
 
 void daGrass_c::deleteRoomFlower(int param_0) {
     if (m_flower != NULL) {
@@ -435,7 +435,7 @@ void daGrass_c::deleteRoomFlower(int param_0) {
     }
 }
 
-daMP_c* daMP_c::m_myObj;
+DUSK_GAME_DATA daMP_c* daMP_c::m_myObj;
 
 u32 daMP_c::daMP_c_Get_MovieRestFrame() {
     JUT_ASSERT(668, m_myObj != NULL);
@@ -462,7 +462,7 @@ void daMP_c::daMP_c_THPPlayerPause() {
     m_myObj->mpTHPPause();
 }
 
-daTagMagne_c* daTagMagne_c::mTagMagne;
+DUSK_GAME_DATA daTagMagne_c* daTagMagne_c::mTagMagne;
 
 int daTagMagne_c::checkMagnetCode(cBgS_PolyInfo& poly) {
 #if DEBUG
@@ -508,9 +508,9 @@ int daTagMagne_c::checkMagneC() {
     return 0;
 }
 
-u8 daTagMist_c::mPlayerNo;
+DUSK_GAME_DATA u8 daTagMist_c::mPlayerNo;
 
-bool daObjCarry_c::mSaveFlag;
+DUSK_GAME_DATA bool daObjCarry_c::mSaveFlag;
 
 u8 daTagMist_c::getPlayerNo() {
     return mPlayerNo;
@@ -528,7 +528,7 @@ bool daObjCarry_c::chkSaveFlag() {
     return mSaveFlag == true;
 }
 
-cXyz daObjCarry_c::mPos[5];
+DUSK_GAME_DATA cXyz daObjCarry_c::mPos[5];
 
 const cXyz& daObjCarry_c::getPos(int param_0) {
 #if DEBUG
@@ -548,7 +548,7 @@ void daObjCarry_c::savePos(int param_0, cXyz param_1) {
     mPos[param_0] = param_1;
 }
 
-u8 daObjCarry_c::mSttsFlag[5];
+DUSK_GAME_DATA u8 daObjCarry_c::mSttsFlag[5];
 
 void daObjCarry_c::onSttsFlag(int idx, u8 flag) {
 #if DEBUG
@@ -577,7 +577,7 @@ u8 daObjCarry_c::chkSttsFlag(int idx, u8 flag) {
     return cLib_checkBit(mSttsFlag[idx], flag) > 0;
 }
 
-s8 daObjCarry_c::mRoomNo[5];
+DUSK_GAME_DATA s8 daObjCarry_c::mRoomNo[5];
 
 void daObjCarry_c::setRoomNo(int idx, s8 roomNo) {
 #if DEBUG
diff --git a/src/d/d_cursor_mng.cpp b/src/d/d_cursor_mng.cpp
index 230b4e740e..b99ec8f4db 100644
--- a/src/d/d_cursor_mng.cpp
+++ b/src/d/d_cursor_mng.cpp
@@ -1,10 +1,7 @@
 #include "JSystem/JKernel/JKRHeap.h"
 
 #include "d/dolzel.h" // IWYU pragma: keep
-
 #include "d/d_cursor_mng.h"
-
-#include "../../libs/JSystem/include/JSystem/JKernel/JKRHeap.h"
 #include "d/d_com_inf_game.h"
 
 dCsr_mng_c* dCsr_mng_c::m_myObj;
diff --git a/src/d/d_debug_viewer.cpp b/src/d/d_debug_viewer.cpp
index 288e073259..b88f095ff9 100644
--- a/src/d/d_debug_viewer.cpp
+++ b/src/d/d_debug_viewer.cpp
@@ -8,8 +8,8 @@
 #include "JSystem/JUtility/JUTDbPrint.h"
 #include "JSystem/JUtility/JUTReport.h"
 
-J3DPacket* l_drawPacketList[1000];
-int l_drawPacketListNum;
+DUSK_GAME_DATA J3DPacket* l_drawPacketList[1000];
+DUSK_GAME_DATA int l_drawPacketListNum;
 
 J3DPacket* dDbVw_setDrawPacketList(J3DPacket* i_packet, int i_bufferType) {
     if (i_packet == NULL) {
diff --git a/src/d/d_demo.cpp b/src/d/d_demo.cpp
index 2f099f2c2a..a45b681693 100644
--- a/src/d/d_demo.cpp
+++ b/src/d/d_demo.cpp
@@ -67,7 +67,7 @@ static void unpause_streams(bool require_prelaunch_hidden) {
 }  // namespace
 #endif
 
-s16 dDemo_c::m_branchId = -1;
+DUSK_GAME_DATA s16 dDemo_c::m_branchId = -1;
 
 namespace {
 class jstudio_tAdaptor_message : public JStudio::TAdaptor_message {
@@ -232,41 +232,41 @@ f32 dDemo_actor_c::getPrm_Morf() {
     }
 }
 
-dDemo_system_c* dDemo_c::m_system;
+DUSK_GAME_DATA dDemo_system_c* dDemo_c::m_system;
 
-JStudio::TControl* dDemo_c::m_control;
+DUSK_GAME_DATA JStudio::TControl* dDemo_c::m_control;
 
-JStudio_JStage::TCreateObject* dDemo_c::m_stage;
+DUSK_GAME_DATA JStudio_JStage::TCreateObject* dDemo_c::m_stage;
 
-JStudio_JAudio2::TCreateObject* dDemo_c::m_audio;
+DUSK_GAME_DATA JStudio_JAudio2::TCreateObject* dDemo_c::m_audio;
 
-dDemo_particle_c* dDemo_c::m_particle;
+DUSK_GAME_DATA dDemo_particle_c* dDemo_c::m_particle;
 
-JStudio::TCreateObject* dDemo_c::m_message;
+DUSK_GAME_DATA JStudio::TCreateObject* dDemo_c::m_message;
 
-JStudio::TFactory* dDemo_c::m_factory;
+DUSK_GAME_DATA JStudio::TFactory* dDemo_c::m_factory;
 
-jmessage_tControl* dDemo_c::m_mesgControl;
+DUSK_GAME_DATA jmessage_tControl* dDemo_c::m_mesgControl;
 
-dDemo_object_c* dDemo_c::m_object;
+DUSK_GAME_DATA dDemo_object_c* dDemo_c::m_object;
 
-const u8* dDemo_c::m_data;
+DUSK_GAME_DATA const u8* dDemo_c::m_data;
 
-int dDemo_c::m_frame;
+DUSK_GAME_DATA int dDemo_c::m_frame;
 
-cXyz* dDemo_c::m_translation;
+DUSK_GAME_DATA cXyz* dDemo_c::m_translation;
 
-f32 dDemo_c::m_rotationY;
+DUSK_GAME_DATA f32 dDemo_c::m_rotationY;
 
-u32 dDemo_c::m_frameNoMsg;
+DUSK_GAME_DATA u32 dDemo_c::m_frameNoMsg;
 
-s32 dDemo_c::m_mode;
+DUSK_GAME_DATA s32 dDemo_c::m_mode;
 
-u32 dDemo_c::m_status;
+DUSK_GAME_DATA u32 dDemo_c::m_status;
 
-u16 dDemo_c::m_branchType;
+DUSK_GAME_DATA u16 dDemo_c::m_branchType;
 
-const u8* dDemo_c::m_branchData;
+DUSK_GAME_DATA const u8* dDemo_c::m_branchData;
 
 #if DEBUG
 u16 dDemo_c::m_branchNum = 0;
diff --git a/src/d/d_drawlist.cpp b/src/d/d_drawlist.cpp
index b3c685092f..b5ed876126 100644
--- a/src/d/d_drawlist.cpp
+++ b/src/d/d_drawlist.cpp
@@ -14,14 +14,18 @@
 #include "m_Do/m_Do_mtx.h"
 
 #if TARGET_PC
+#include "dusk/game_clock.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/logging.h"
+#include "helpers/gx_helper.h"
+
+#include "JSystem/JKernel/JKRHeap.h"
+
+#include <absl/container/flat_hash_map.h>
+#include <tracy/Tracy.hpp>
+
 #include <cstdio>
 #include <typeindex>
-#include "JSystem/JKernel/JKRHeap.h"
-#include "absl/container/flat_hash_map.h"
-#include "client/TracyScoped.hpp"
-#include "dusk/frame_interpolation.h"
-#include "dusk/gx_helper.h"
-#include "dusk/logging.h"
 
 static const void* getInterpKey(const void* base, int idx) {
     return reinterpret_cast<const void*>(reinterpret_cast<uintptr_t>(base) ^ idx);
@@ -529,14 +533,14 @@ void dDlst_2DT2_c::draw() {
     dComIfGp_getCurrentGrafPort()->setup2D();
 }
 
-static u8 l_frontZMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_frontZMat[] = {
     0x61, 0x40, 0x00, 0x00, 0x07, 0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x10,
     0x00, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x01, 0x61, 0x00, 0x00, 0x40, 0x10, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_frontNoZSubMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_frontNoZSubMat[] = {
     0x61, 0x40, 0x00, 0x00, 0x06, 0x61, 0x41, 0x00, 0x09, 0x35, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -547,14 +551,14 @@ static Vec l_shadowVolPos[] = {
     {1.0f, -1.0f, 0.0f},  {1.0f, -1.0f, -300.0f},  {1.0f, 1.0f, 0.0f},  {1.0f, 1.0f, -300.0f},
 };
 
-static u8 l_shadowVolDL[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowVolDL[] = {
     0x80, 0x00, 0x18, 0x06, 0x02, 0x03, 0x07, 0x00, 0x04, 0x05, 0x01, 0x06, 0x04, 0x00, 0x02,
     0x07, 0x05, 0x04, 0x06, 0x03, 0x01, 0x05, 0x07, 0x02, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_shadowProjMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowProjMat[] = {
     0x61, 0x28, 0x38, 0x03, 0xC0, 0x61, 0xC0, 0x08, 0xFF, 0xFF, 0x61, 0xC1, 0x08, 0xE6, 0x70,
     0x61, 0x43, 0x00, 0x00, 0x01, 0x61, 0x40, 0x00, 0x00, 0x07, 0x61, 0x41, 0x00, 0x04, 0xAD,
     0x61, 0xF3, 0x64, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x01, 0x10,
@@ -563,7 +567,7 @@ static u8 l_shadowProjMat[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_shadowVolMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowVolMat[] = {
     0x61, 0x28, 0x38, 0x00, 0x00, 0x61, 0xC0, 0x08, 0xFF, 0xFC, 0x61, 0xC1, 0x08, 0xFF, 0x90,
     0x61, 0x43, 0x00, 0x00, 0x41, 0x61, 0x40, 0x00, 0x00, 0x0D, 0x61, 0x41, 0x00, 0x01, 0x35,
     0x61, 0xF3, 0x7F, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x10,
@@ -572,7 +576,7 @@ static u8 l_shadowVolMat[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_clearMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_clearMat[] = {
     0x61, 0x28, 0x38, 0x00, 0x00, 0x61, 0xC0, 0x08, 0xFF, 0xFF, 0x61, 0xC1, 0x08, 0xFF, 0xA0,
     0x61, 0x40, 0x00, 0x00, 0x06, 0x61, 0x41, 0x00, 0x00, 0x14, 0x61, 0xF3, 0x7F, 0x00, 0x00,
     0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x09, 0x00,
@@ -581,7 +585,7 @@ static u8 l_clearMat[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_frontMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_frontMat[] = {
     0x61, 0x28, 0x38, 0x00, 0x00, 0x61, 0xC0, 0x08, 0xFF, 0xFF, 0x61, 0xC1, 0x08, 0xFF, 0x90,
     0x61, 0x43, 0x00, 0x00, 0x41, 0x61, 0x40, 0x00, 0x00, 0x07, 0x61, 0x41, 0x00, 0x01, 0x15,
     0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x10, 0x09, 0x00,
@@ -590,7 +594,7 @@ static u8 l_frontMat[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_backSubMat[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_backSubMat[] = {
     0x61, 0x41, 0x00, 0x09, 0x35, 0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x10,
     0x00, 0x00, 0x10, 0x09, 0x00, 0x00, 0x00, 0x01, 0x61, 0x00, 0x00, 0x80, 0x10, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -604,7 +608,7 @@ static Vec l_simpleShadowPos[] = {
     {1.0f, 1.0f, 1.0f},    {-1.0f, 1.0f, 1.0f},
 };
 
-static u8 l_shadowVolumeDL[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowVolumeDL[] = {
     0x98, 0x00, 0x05, 0x03, 0x09, 0x01, 0x07, 0x05, 0x98, 0x00, 0x05, 0x04, 0x06, 0x00, 0x08,
     0x02, 0x98, 0x00, 0x04, 0x04, 0x05, 0x06, 0x07, 0x98, 0x00, 0x04, 0x02, 0x03, 0x04, 0x05,
     0x98, 0x00, 0x04, 0x08, 0x09, 0x02, 0x03, 0x98, 0x00, 0x04, 0x06, 0x07, 0x08, 0x09, 0x98,
@@ -613,7 +617,7 @@ static u8 l_shadowVolumeDL[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_shadowSealTexDL[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowSealTexDL[] = {
     0x61, 0x28, 0x38, 0x03, 0xC0, 0x61, 0x40, 0x00, 0x00, 0x06, 0x61, 0x41, 0x00, 0x06, 0x15,
     0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x10, 0x09, 0x00,
     0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x40, 0x01, 0x80, 0x00, 0x04, 0x0A, 0x00, 0x00, 0x0B,
@@ -622,7 +626,7 @@ static u8 l_shadowSealTexDL[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_shadowSealTex2DL[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowSealTex2DL[] = {
     0x61, 0x28, 0x38, 0x03, 0xC0, 0x61, 0x40, 0x00, 0x00, 0x06, 0x61, 0x41, 0x00, 0x06, 0x15,
     0x10, 0x00, 0x00, 0x10, 0x3F, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x10, 0x09, 0x00,
     0x00, 0x00, 0x00, 0x61, 0x00, 0x00, 0x40, 0x01, 0x80, 0x00, 0x04, 0x0A, 0x00, 0x00, 0x0B,
@@ -631,7 +635,7 @@ static u8 l_shadowSealTex2DL[] ATTRIBUTE_ALIGN(32) = {
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static u8 l_shadowSealDL[] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_shadowSealDL[] = {
     0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,
     0x00, 0x05, 0x00, 0x61, 0x28, 0x38, 0x00, 0x00, 0x61, 0xC0, 0x08, 0xFF, 0xFF, 0x61, 0xC1,
     0x08, 0xFF, 0xB0, 0x61, 0x40, 0x00, 0x00, 0x06, 0x61, 0x41, 0x00, 0x06, 0xED, 0x10, 0x00,
@@ -1078,7 +1082,7 @@ void dDlst_shadowReal_c::reset() {
 void dDlst_shadowReal_c::imageDraw(Mtx param_0) {
 #ifdef TARGET_PC
     Mtx render_proj_mtx;
-    if (dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 2), render_proj_mtx)) {
+    if (dusk::interp::lookup_replacement(getInterpKey(mpModels[0], 2), render_proj_mtx)) {
         GXSetProjection(render_proj_mtx, GX_ORTHOGRAPHIC);
     } else
 #endif
@@ -1099,7 +1103,7 @@ void dDlst_shadowReal_c::imageDraw(Mtx param_0) {
                 shape_pkt = (*models)->getShapePacket(j);
 #ifdef TARGET_PC
                 Mtx view_mtx;
-                if (dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 1), view_mtx)) {
+                if (dusk::interp::lookup_replacement(getInterpKey(mpModels[0], 1), view_mtx)) {
                     shape_pkt->setBaseMtxPtr(&view_mtx);
                 } else
 #endif
@@ -1128,8 +1132,8 @@ void dDlst_shadowReal_c::draw() {
     GXSetCurrentMtx(GX_PNMTX0);
 #ifdef TARGET_PC
     Mtx view_mtx, recv_proj_mtx;
-    const auto have_view_mtx = dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 1), view_mtx);
-    const auto have_recv_proj_mtx = dusk::frame_interp::lookup_replacement(getInterpKey(mpModels[0], 3), recv_proj_mtx);
+    const auto have_view_mtx = dusk::interp::lookup_replacement(getInterpKey(mpModels[0], 1), view_mtx);
+    const auto have_recv_proj_mtx = dusk::interp::lookup_replacement(getInterpKey(mpModels[0], 3), recv_proj_mtx);
     if (have_view_mtx && have_recv_proj_mtx) {
         cMtx_concat(recv_proj_mtx, view_mtx, recv_proj_mtx);
         GXLoadTexMtxImm(recv_proj_mtx, GX_TEXMTX0, GX_MTX3x4);
@@ -1297,9 +1301,9 @@ u8 dDlst_shadowReal_c::setShadowRealMtx(cXyz* param_0, cXyz* param_1, f32 param_
     
 #ifdef TARGET_PC
     const auto keybase = mpModels[0];
-    dusk::frame_interp::record_final_mtx(mViewMtx, getInterpKey(keybase, 1));
-    dusk::frame_interp::record_final_mtx(mRenderProjMtx, getInterpKey(keybase, 2));
-    dusk::frame_interp::record_final_mtx(mReceiverProjMtx, getInterpKey(keybase, 3));
+    dusk::interp::record_final_mtx(mViewMtx, getInterpKey(keybase, 1));
+    dusk::interp::record_final_mtx(mRenderProjMtx, getInterpKey(keybase, 2));
+    dusk::interp::record_final_mtx(mReceiverProjMtx, getInterpKey(keybase, 3));
 #endif
     cMtx_concat(mReceiverProjMtx, mViewMtx, mReceiverProjMtx);
     return r29;
@@ -1361,6 +1365,16 @@ bool dDlst_shadowReal_c::add(J3DModel* i_model) {
     return true;
 }
 
+#if TARGET_PC
+static MtxP get_simple_shadow_mtx(Mtx worldMtx, const void* key, Mtx storage) {
+    if (!dusk::interp::lookup_replacement(key, storage)) {
+        cMtx_copy(worldMtx, storage);
+    }
+    cMtx_concat(j3dSys.getViewMtx(), storage, storage);
+    return storage;
+}
+#endif
+
 void dDlst_shadowSimple_c::draw() {
     static GXColor l_color = {0, 0, 0, 64};
     l_color.a = mAlpha;
@@ -1368,31 +1382,23 @@ void dDlst_shadowSimple_c::draw() {
     GXSetTevColor(GX_TEVREG0, l_color);
     GXClearVtxDesc();
     GXSetVtxDesc(GX_VA_POS, GX_INDEX8);
-#ifdef TARGET_PC
-    Mtx volume_mtx;
-    if (dusk::frame_interp::lookup_replacement(mVolumeMtxKey, volume_mtx)) {
-        cMtx_concat(j3dSys.getViewMtx(), volume_mtx, volume_mtx);
-        GXLoadPosMtxImm(volume_mtx, GX_PNMTX0);
-    } else
+#if TARGET_PC
+    Mtx volumeMtx;
+    GXLoadPosMtxImm(get_simple_shadow_mtx(mVolumeMtx, mVolumeMtxKey, volumeMtx), GX_PNMTX0);
+#else
+    GXLoadPosMtxImm(mVolumeMtx, GX_PNMTX0);
 #endif
-    {
-        GXLoadPosMtxImm(mVolumeMtx, GX_PNMTX0);
-    }
     GXSetCurrentMtx(GX_PNMTX0);
     GXCallDisplayList(l_frontMat, 0x40);
     GXCallDisplayList(l_shadowVolumeDL, 0x40);
     GXCallDisplayList(l_backSubMat, 0x20);
     GXCallDisplayList(l_shadowVolumeDL, 0x40);
-#ifdef TARGET_PC
-    Mtx shadow_mtx;
-    if (dusk::frame_interp::lookup_replacement(mMtxKey, shadow_mtx)) {
-        cMtx_concat(j3dSys.getViewMtx(), shadow_mtx, shadow_mtx);
-        GXLoadPosMtxImm(shadow_mtx, GX_PNMTX1);
-    } else
+#if TARGET_PC
+    Mtx shadowMtx;
+    GXLoadPosMtxImm(get_simple_shadow_mtx(mMtx, mMtxKey, shadowMtx), GX_PNMTX1);
+#else
+    GXLoadPosMtxImm(mMtx, GX_PNMTX1);
 #endif
-    {
-        GXLoadPosMtxImm(mMtx, GX_PNMTX1);
-    }
     GXSetCurrentMtx(GX_PNMTX1);
 
     if (mpTexObj != NULL) {
@@ -1447,9 +1453,11 @@ void dDlst_shadowSimple_c::set(cXyz* param_0, f32 param_1, f32 param_2, cXyz* pa
     mDoMtx_stack_c::scaleM(param_2, f30 + f30 + 16.0f, param_2 * param_5);
 #if TARGET_PC
     mVolumeMtxKey = getInterpKey(param_0, 0x1);
-    dusk::frame_interp::record_final_mtx(mDoMtx_stack_c::get(), mVolumeMtxKey);
-#endif
+    dusk::interp::record_final_mtx(mDoMtx_stack_c::get(), mVolumeMtxKey);
+    cMtx_copy(mDoMtx_stack_c::get(), mVolumeMtx);
+#else
     cMtx_concat(j3dSys.getViewMtx(), mDoMtx_stack_c::get(), mVolumeMtx);
+#endif
     f32 f31 = JMAFastSqrt(1.0f - param_3->x * param_3->x);
     f32 f29;
     f32 f28;
@@ -1474,11 +1482,13 @@ void dDlst_shadowSimple_c::set(cXyz* param_0, f32 param_1, f32 param_2, cXyz* pa
     mDoMtx_stack_c::get()[2][3] = param_0->z;
     mDoMtx_stack_c::YrotM(param_4);
     mDoMtx_stack_c::scaleM(param_2, 1.0f, param_2 * param_5);
-#ifdef TARGET_PC
+#if TARGET_PC
     mMtxKey = getInterpKey(param_0, 0x2);
-    dusk::frame_interp::record_final_mtx(mDoMtx_stack_c::get(), mMtxKey);
-#endif
+    dusk::interp::record_final_mtx(mDoMtx_stack_c::get(), mMtxKey);
+    cMtx_copy(mDoMtx_stack_c::get(), mMtx);
+#else
     cMtx_concat(j3dSys.getViewMtx(), mDoMtx_stack_c::get(), mMtx);
+#endif
     mpTexObj = param_6;
 }
 
@@ -1534,7 +1544,7 @@ void dDlst_shadowControl_c::reset() {
 }
 
 void dDlst_shadowControl_c::imageDraw(Mtx param_0) {
-    static u8 l_matDL[] ATTRIBUTE_ALIGN(32) = {
+    ATTRIBUTE_ALIGN(32) static u8 l_matDL[] = {
         0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x10, 0x10,
         0x00, 0x00, 0x04, 0x00, 0x61, 0x28, 0x38, 0x00, 0x00, 0x61, 0xC0, 0x08, 0xFF, 0xF2,
         0x61, 0xC1, 0x08, 0xFF, 0x90, 0x61, 0x43, 0x00, 0x00, 0x41, 0x61, 0xF3, 0x7F, 0x00,
@@ -1639,7 +1649,7 @@ void dDlst_shadowControl_c::draw(Mtx param_0) {
     GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
 #ifdef TARGET_PC
     Mtx draw_mtx;
-    if (dusk::frame_interp::lookup_replacement(param_0, draw_mtx)) {
+    if (dusk::interp::lookup_replacement(param_0, draw_mtx)) {
         GXLoadPosMtxImm(draw_mtx, GX_PNMTX0);
     } else {
 #endif
@@ -1811,7 +1821,7 @@ int dDlst_shadowControl_c::setSimple(cXyz* param_0, f32 param_1, f32 param_2, cX
     return 1;
 }
 
-TGXTexObj dDlst_shadowControl_c::mSimpleTexObj;
+DUSK_GAME_DATA TGXTexObj dDlst_shadowControl_c::mSimpleTexObj;
 
 void dDlst_shadowControl_c::setSimpleTex(ResTIMG const* i_timg) {
     mDoLib_setResTimgObj(i_timg, &mSimpleTexObj, 0, NULL);
@@ -1988,7 +1998,7 @@ void dDlst_list_c::drawXluListItem3d() {
 }
 
 int dDlst_list_c::set(dDlst_base_c**& p_start, dDlst_base_c**& p_end, dDlst_base_c* p_newDlst) {
-    if (p_start >= p_end) {
+    if (p_start >= p_end IF_DUSK(|| !dusk::game_clock::is_sim_frame())) {
         return 0;
     }
     *p_start = p_newDlst;
@@ -2027,15 +2037,15 @@ void dDlst_list_c::draw(dDlst_base_c** p_start, dDlst_base_c** p_end) {
     }
 }
 
-dDlst_2DT2_c dDlst_list_c::mWipeDlst;
+DUSK_GAME_DATA dDlst_2DT2_c dDlst_list_c::mWipeDlst;
 
-GXColor dDlst_list_c::mWipeColor = {0, 0, 0, 0};
+DUSK_GAME_DATA GXColor dDlst_list_c::mWipeColor = {0, 0, 0, 0};
 
-u8 dDlst_list_c::mWipe;
+DUSK_GAME_DATA u8 dDlst_list_c::mWipe;
 
-f32 dDlst_list_c::mWipeRate;
+DUSK_GAME_DATA f32 dDlst_list_c::mWipeRate;
 
-f32 dDlst_list_c::mWipeSpeed;
+DUSK_GAME_DATA f32 dDlst_list_c::mWipeSpeed;
 
 void dDlst_list_c::wipeIn(f32 i_wipeSpeed, GXColor& i_wipeColor) {
     mWipe = true;
@@ -2071,10 +2081,10 @@ void dDlst_list_c::calcWipe() {
 }
 
 #if TARGET_PC
-void dDlst_list_c::refresh3DlineMats(const cXyz& eye) {
+void dDlst_list_c::refresh3DlineMats() {
     for (int i = 0; i < 3; i++) {
         for (mDoExt_3DlineMat_c* mat = m3DLineMatSortPacket[i].getFirstMat(); mat != NULL; mat = mat->field_0x4) {
-            mat->refreshGeometryForPresentationEye(eye);
+            mat->refreshGeometryForPresentation();
         }
     }
 }
diff --git a/src/d/d_ev_camera.cpp b/src/d/d_ev_camera.cpp
index 67cda5863b..78a2d0b657 100644
--- a/src/d/d_ev_camera.cpp
+++ b/src/d/d_ev_camera.cpp
@@ -13,12 +13,12 @@
 #include "d/actor/d_a_alink.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
 
-#ifdef __MWERKS__
-#define LOAD_4BYTE_STRING_LITERAL(x) (*(u32*)(x))
-#else
 #define LOAD_4BYTE_STRING_LITERAL(x) read_big_endian_u32(x)
+#else
+#define LOAD_4BYTE_STRING_LITERAL(x) (*(u32*)(x))
 #endif
 
 namespace {
diff --git a/src/d/d_event.cpp b/src/d/d_event.cpp
index 3ae3becd93..4200b1ed75 100644
--- a/src/d/d_event.cpp
+++ b/src/d/d_event.cpp
@@ -13,7 +13,9 @@
 #include "SSystem/SComponent/c_counter.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 namespace {
 static u8 event_debug_evnt() {
diff --git a/src/d/d_event_manager.cpp b/src/d/d_event_manager.cpp
index 9da313c239..70b818c922 100644
--- a/src/d/d_event_manager.cpp
+++ b/src/d/d_event_manager.cpp
@@ -15,7 +15,9 @@
 #include "SSystem/SComponent/c_counter.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 #if DEBUG
 static dEvM_HIO_c l_HIO;
@@ -335,6 +337,17 @@ bool dEvent_manager_c::setObjectArchive(DUSK_CONST char* arcname) {
 
     if (arcname != NULL) {
         rt = dComIfG_getObjectRes(arcname, DataFileName);
+#if TARGET_PC
+        if (rt != nullptr && strcmp(arcname, "Prayer") == 0) {
+            // pointer to Prayer event `011get_item` prm0 in its event_list.dat
+            u8* itemNo = static_cast<u8*>(rt) + 0x927;
+            *itemNo =
+                dusk::mods::item_check("prayer_reward", dItemNo_KAKERA_HEART_e, NULL);
+            // set the proper item give tag
+            u32* prm1 = reinterpret_cast<u32*>(static_cast<u8*>(rt) + 0x928);
+            *prm1 = dusk::mods::item_give_tag("prayer_reward");
+        }
+#endif
         int base_status = mEventList[BASE_ACTOR].init((char*)rt, -1);
 
         #if DEBUG
diff --git a/src/d/d_eye_hl.cpp b/src/d/d_eye_hl.cpp
index 16161b5ee7..80cc416f17 100644
--- a/src/d/d_eye_hl.cpp
+++ b/src/d/d_eye_hl.cpp
@@ -35,7 +35,7 @@ void dEyeHL_c::remove() {
     dEyeHL_mng_c::remove(this);
 }
 
-dEyeHL_c* dEyeHL_mng_c::m_obj;
+DUSK_GAME_DATA dEyeHL_c* dEyeHL_mng_c::m_obj;
 
 void dEyeHL_mng_c::update() {
     dEyeHL_c* obj = m_obj;
diff --git a/src/d/d_file_sel_info.cpp b/src/d/d_file_sel_info.cpp
index d54bc4424d..377754b834 100644
--- a/src/d/d_file_sel_info.cpp
+++ b/src/d/d_file_sel_info.cpp
@@ -14,8 +14,10 @@
 #include <cstdio>
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
 #include "dusk/version.hpp"
+#include "helpers/string.hpp"
+#endif
 
 dFile_info_c::dFile_info_c(JKRArchive* i_archive, u8 param_1) {
     mArchive = i_archive;
@@ -46,8 +48,19 @@ void dFile_info_c::screenSet() {
 
     J2DTextBox* info_text[4];
     
-
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        info_text[0] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_s_t_01'));
+        info_text[1] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_p_t_01'));
+        mFileInfo.Scr->search(MULTI_CHAR('f_s_t_02'))->hide();
+        mFileInfo.Scr->search(MULTI_CHAR('f_p_t_02'))->hide();
+    } else {
+        info_text[0] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('f_s_t_02'));
+        info_text[1] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('f_p_t_02'));
+        mFileInfo.Scr->search(MULTI_CHAR('w_s_t_01'))->hide();
+        mFileInfo.Scr->search(MULTI_CHAR('w_p_t_01'))->hide();
+    }
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     info_text[0] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_s_t_01'));
     info_text[1] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_p_t_01'));
     mFileInfo.Scr->search(MULTI_CHAR('f_s_t_02'))->hide();
@@ -66,7 +79,19 @@ void dFile_info_c::screenSet() {
     dMeter2Info_getString(0x3D0, info_text[0]->getStringPtr(), NULL);  // Save time
     dMeter2Info_getString(0x3D1, info_text[1]->getStringPtr(), NULL);  // Total play time
 
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        info_text[0] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_name01'));
+        info_text[1] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_new_1'));
+        mFileInfo.Scr->search(MULTI_CHAR('f_name01'))->hide();
+        mFileInfo.Scr->search(MULTI_CHAR('f_new_1'))->hide();
+    } else {
+        info_text[0] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('f_name01'));
+        info_text[1] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('f_new_1'));
+        mFileInfo.Scr->search(MULTI_CHAR('w_name01'))->hide();
+        mFileInfo.Scr->search(MULTI_CHAR('w_new_1'))->hide();
+    }
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     info_text[0] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_name01'));
     info_text[1] = (J2DTextBox*)mFileInfo.Scr->search(MULTI_CHAR('w_new_1'));
     mFileInfo.Scr->search(MULTI_CHAR('f_name01'))->hide();
diff --git a/src/d/d_file_sel_warning.cpp b/src/d/d_file_sel_warning.cpp
index e2d767453b..97b667bb45 100644
--- a/src/d/d_file_sel_warning.cpp
+++ b/src/d/d_file_sel_warning.cpp
@@ -4,13 +4,17 @@
 
 #include "d/dolzel.h" // IWYU pragma: keep
 
+#include "JSystem/J2DGraph/J2DAnmLoader.h"
+#include "JSystem/J2DGraph/J2DScreen.h"
+#include "JSystem/J2DGraph/J2DTextBox.h"
+#include "d/d_com_inf_game.h"
 #include "d/d_file_sel_warning.h"
 #include "d/d_msg_string.h"
 #include "d/d_pane_class.h"
-#include "JSystem/J2DGraph/J2DScreen.h"
-#include "JSystem/J2DGraph/J2DAnmLoader.h"
-#include "JSystem/J2DGraph/J2DTextBox.h"
-#include "d/d_com_inf_game.h"
+
+#if TARGET_PC
+#include "dusk/version.hpp"
+#endif
 
 typedef void (dFile_warning_c::*procFunc)();
 static procFunc fileWarningProc[] = {&dFile_warning_c::modeWait, &dFile_warning_c::modeMove};
@@ -63,7 +67,19 @@ void dFile_warning_c::screenSet() {
     JUT_ASSERT(0, mpRootPane != NULL);
     field_0x34 = mpRootPane->getTranslateY();
 
-#if REGION_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mFileWarn.Scr->search(MULTI_CHAR('ms_for_2'))->hide();
+        mFileWarn.Scr->search(MULTI_CHAR('ms_for_3'))->hide();
+
+        field_0x20 = static_cast<J2DTextBox*>(mFileWarn.Scr->search(MULTI_CHAR('w_msg_jp')));
+    } else {
+        mFileWarn.Scr->search(MULTI_CHAR('w_msg_jp'))->hide();
+        mFileWarn.Scr->search(MULTI_CHAR('ms_for_2'))->hide();
+
+        field_0x20 = static_cast<J2DTextBox*>(mFileWarn.Scr->search(MULTI_CHAR('ms_for_3')));
+    }
+#elif REGION_JPN
     mFileWarn.Scr->search(MULTI_CHAR('ms_for_2'))->hide();
     mFileWarn.Scr->search(MULTI_CHAR('ms_for_3'))->hide();
 
diff --git a/src/d/d_file_select.cpp b/src/d/d_file_select.cpp
index 19cdcfe81c..ed73d5f9cf 100644
--- a/src/d/d_file_select.cpp
+++ b/src/d/d_file_select.cpp
@@ -24,8 +24,12 @@
 #include <cstring>
 
 #if TARGET_PC
+#include "dusk/game_mode.hpp"
 #include "dusk/menu_pointer.h"
-#include "dusk/string.hpp"
+#include "dusk/mods/svc/save.hpp"
+#include "dusk/utilities.hpp"
+#include "dusk/version.hpp"
+#include "helpers/string.hpp"
 
 namespace {
 constexpr u8 pointer_target(u8 group, u8 index) noexcept {
@@ -253,6 +257,10 @@ dFile_select_c::~dFile_select_c() {
 void dFile_select_c::_create() {
     int i;
 
+#if TARGET_PC
+    dusk::mods::svc::save_no_slot();
+#endif
+
     mDoGph_gInf_c::setFadeColor(static_cast<JUtility::TColor&>(g_blackColor));
     
     stick = JKR_NEW STControl(2, 2, 1, 1, 0.9f, 0.5f, 0, 0x2000);
@@ -1303,12 +1311,42 @@ void dFile_select_c::selectDataOpenMove() {
 void dFile_select_c::selectDataNameMove() {
     bool isHeaderTxtChange = headerTxtChangeAnm();
     bool isFileRecScale = fileRecScaleAnm2();
-    bool isNameMove = nameMoveAnm();
+    IF_NOT_DUSK(bool isNameMove = nameMoveAnm();)
     bool isModoruTxtDisp = modoruTxtDispAnm();
 
+#ifdef TARGET_PC
+    const dusk::gamemode::GameMode* gameMode =
+        dusk::gamemode::getGameModeManager().getCurrentGameMode();
+    if (gameMode) {
+        if (isHeaderTxtChange == true && isFileRecScale == true && isModoruTxtDisp == true) {
+            if (mGameModeSaveStartBuildUi) {
+                gameMode->invokeOnNewSaveSelectFunction(&mGameModeNewSaveState);
+                mGameModeSaveStartBuildUi = false;
+            }
+            if (mGameModeNewSaveState == GAME_MODE_STATE_RETURN) {
+                backToDataSelectMove();
+                mGameModeSaveStartBuildUi = true;
+                mGameModeNewSaveState = GAME_MODE_STATE_PENDING;
+                return;
+            }
+            if (mGameModeNewSaveState != GAME_MODE_STATE_PROCEED) {
+                return;
+            }
+        } else {
+            return;
+        }
+    }
+#endif
+
+    IF_DUSK(bool isNameMove = nameMoveAnm();)
+
     if (isHeaderTxtChange == true && isFileRecScale == true && isNameMove == true &&
         isModoruTxtDisp == true)
     {
+#ifdef TARGET_PC
+        mGameModeSaveStartBuildUi = true;
+        mGameModeNewSaveState = GAME_MODE_STATE_PENDING;
+#endif
         mDataSelProc = DATASELPROC_NAME_INPUT_WAIT;
     }
 }
@@ -1388,6 +1426,15 @@ void dFile_select_c::menuSelectStart() {
         mIsSelectEnd = true;
         mDataSelProc = DATASELPROC_NEXT_MODE_WAIT;
         dComIfGs_setDataNum(mSelectNum);
+#if TARGET_PC
+        dusk::mods::svc::save_slot_loaded(mSelectNum, &mSaveData[mSelectNum]);
+
+        const dusk::gamemode::GameMode* gameMode =
+            dusk::gamemode::getGameModeManager().getCurrentGameMode();
+        if (gameMode) {
+            gameMode->invokeOnSaveLoadedFunction();
+        }
+#endif
     } else if (mSelectMenuNum == 0) {
         mSelIcon->setAlphaRate(0.0f);
         yesnoMenuMoveAnmInitSet(0x473, 0x47d);
@@ -1738,6 +1785,21 @@ void dFile_select_c::nameInput2() {
     case 2:
         dComIfGs_setHorseName(mpName->getInputStrPtr());
         mIsSelectEnd = true;
+#if TARGET_PC
+        dusk::mods::svc::save_slot_new(mSelectNum);
+        const dusk::gamemode::GameMode* gameMode =
+                dusk::gamemode::getGameModeManager().getCurrentGameMode();
+        if (gameMode) {
+            gameMode->invokeOnNewSaveFunction();
+        }
+
+        // only do OnSaveLoaded callback here if hiding the brightness check screen
+        if (dusk::getSettings().game.hideTvSettingsScreen) {
+            if (gameMode) {
+                gameMode->invokeOnSaveLoadedFunction();
+            }
+        }
+#endif
         mDataSelProc = DATASELPROC_NEXT_MODE_WAIT;
     }
 }
@@ -2664,6 +2726,9 @@ void dFile_select_c::DataEraseWait2() {
         mDataSelProc = DATASELPROC_ERROR_MSG_PANE_MOVE;
     } else if (field_0x03b4 == 1) {
         mDoAud_seStart(Z2SE_SY_FILE_DELETE_OK, NULL, 0, 0);
+#if TARGET_PC
+        dusk::mods::svc::save_slot_erased(mSelectNum);
+#endif
         field_0x03b1 = 0;
         mDeleteEfPane[mSelectNum]->alphaAnimeStart(0);
         mFileInfoNoDatBasePane[mSelectNum]->alphaAnimeStart(0);
@@ -2767,6 +2832,9 @@ void dFile_select_c::DataCopyWait2() {
             mDataSelProc = DATASELPROC_ERROR_MSG_PANE_MOVE;
         } else if (field_0x03b4 == 1) {
             mDoAud_seStart(Z2SE_SY_FILE_COPY_OK, NULL, 0, 0);
+#if TARGET_PC
+            dusk::mods::svc::save_slot_copied(mCpDataNum, mCpDataToNum);
+#endif
             field_0x03b1 = 0;
             mCopyEfPane[mSelectNum]->alphaAnimeStart(0);
             mCopyEfPane[mCpDataToNum]->alphaAnimeStart(0);
@@ -3184,8 +3252,10 @@ void dFile_select_c::screenSet() {
     static u64 l_nouseTag[15] = {MULTI_CHAR('w_mcheck'), MULTI_CHAR('w_tabi1'),  MULTI_CHAR('w_tabi2'),  MULTI_CHAR('w_tabi3'), MULTI_CHAR('w_doko_c'),
                                  MULTI_CHAR('w_uwa_c'),  MULTI_CHAR('w_cp_chu'), MULTI_CHAR('w_cpsita'), MULTI_CHAR('w_cp_x'),  'w_de',
                                  MULTI_CHAR('w_de_chu'), MULTI_CHAR('w_desita'), MULTI_CHAR('w_de_x'),   MULTI_CHAR('w_name'),  MULTI_CHAR('w_h_name')};
-
-#if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+#if TARGET_PC
+    static u64 l_tagName21_jpn[2] = {MULTI_CHAR('w_tabi_s'), MULTI_CHAR('w_tabi_x')};
+    static u64 l_tagName21[2] = {MULTI_CHAR('t_for'), MULTI_CHAR('t_for1')};
+#elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     static u64 l_tagName21[2] = {MULTI_CHAR('w_tabi_s'), MULTI_CHAR('w_tabi_x')};
 #else
     static u64 l_tagName21[2] = {MULTI_CHAR('t_for'), MULTI_CHAR('t_for1')};
@@ -3194,7 +3264,10 @@ void dFile_select_c::screenSet() {
     static u64 l_tagName18[3] = {MULTI_CHAR('w_de_ef0'), MULTI_CHAR('w_de_ef1'), MULTI_CHAR('w_de_ef2')};
     static u64 l_tagName19[3] = {MULTI_CHAR('w_cp_ef0'), MULTI_CHAR('w_cp_ef1'), MULTI_CHAR('w_cp_ef2')};
 
-#if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+#if TARGET_PC
+    static u64 l_tagName20_jpn[2] = {MULTI_CHAR('w_er_msg'), MULTI_CHAR('w_er_msR')};
+    static u64 l_tagName20[2] = {MULTI_CHAR('er_for0'), MULTI_CHAR('er_for1')};
+#elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     static u64 l_tagName20[2] = {MULTI_CHAR('w_er_msg'), MULTI_CHAR('w_er_msR')};
 #else
     static u64 l_tagName20[2] = {MULTI_CHAR('er_for0'), MULTI_CHAR('er_for1')};
@@ -3230,7 +3303,19 @@ void dFile_select_c::screenSet() {
     mBbtnPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('w_n_bbtn'), 2, NULL);
     mAbtnPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('w_n_abtn'), 2, NULL);
 
-#if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mModoruTxtPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('w_modo'), 2, NULL);
+        mKetteiTxtPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('w_kete'), 2, NULL);
+        fileSel.Scr->search(MULTI_CHAR('f_modo'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('f_kete'))->hide();
+    } else {
+        mModoruTxtPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('f_modo'), 2, NULL);
+        mKetteiTxtPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('f_kete'), 2, NULL);
+        fileSel.Scr->search(MULTI_CHAR('w_modo'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('w_kete'))->hide();
+    }
+#elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     mModoruTxtPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('w_modo'), 2, NULL);
     mKetteiTxtPane = JKR_NEW CPaneMgrAlpha(fileSel.Scr, MULTI_CHAR('w_kete'), 2, NULL);
     fileSel.Scr->search(MULTI_CHAR('f_modo'))->hide();
@@ -3306,7 +3391,17 @@ void dFile_select_c::screenSet() {
         fileSel.Scr->search(l_nouseTag[i])->hide();
     }
 
-#if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        fileSel.Scr->search(MULTI_CHAR('t_for'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('t_for1'))->hide();
+    } else {
+        fileSel.Scr->search(MULTI_CHAR('w_tabi_s'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('w_tabi_x'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('w_mgn1'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('w_mgn2'))->hide();
+    }
+#elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     fileSel.Scr->search(MULTI_CHAR('t_for'))->hide();
     fileSel.Scr->search(MULTI_CHAR('t_for1'))->hide();
 #else
@@ -3317,10 +3412,20 @@ void dFile_select_c::screenSet() {
 #endif
 
     for (int i = 0; i < 2; i++) {
-        mHeaderTxtPane[i] = JKR_NEW CPaneMgrAlpha(fileSel.Scr, l_tagName21[i], 0, NULL);
+        mHeaderTxtPane[i] = JKR_NEW CPaneMgrAlpha(fileSel.Scr, DUSK_IF_ELSE(dusk::version::isRegionJpn() ? l_tagName21_jpn[i] : l_tagName21[i], l_tagName21[i]), 0, NULL);
         ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setFont(fileSel.font[0]);
         ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setString(512, "");
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
+            ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
+            ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
+        } else {
+            ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setFontSize(24.0f, 24.0f);
+            ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setLineSpace(20.0f);
+            ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setCharSpace(0.0f);
+        }
+#elif VERSION == VERSION_GCN_JPN
         ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
         ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
         ((J2DTextBox*)mHeaderTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
@@ -3361,8 +3466,15 @@ void dFile_select_c::screenSet() {
     field_0x0208 = 0;
     field_0x0209 = 0;
     mErrorMsgPane = fileSel.Scr->search(MULTI_CHAR('w_er_n'));
-
-#if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        fileSel.Scr->search(MULTI_CHAR('er_for0'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('er_for1'))->hide();
+    } else {
+        fileSel.Scr->search(MULTI_CHAR('w_er_msg'))->hide();
+        fileSel.Scr->search(MULTI_CHAR('w_er_msR'))->hide();
+    }
+#elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     fileSel.Scr->search(MULTI_CHAR('er_for0'))->hide();
     fileSel.Scr->search(MULTI_CHAR('er_for1'))->hide();
 #else
@@ -3373,17 +3485,27 @@ void dFile_select_c::screenSet() {
     fileSel.Scr->search(MULTI_CHAR('w_er_msE'))->hide();
 
     for (int i = 0; i < 2; i++) {
-        mErrorMsgTxtPane[i] = JKR_NEW CPaneMgrAlpha(fileSel.Scr, l_tagName20[i], 0, NULL);
+        mErrorMsgTxtPane[i] = JKR_NEW CPaneMgrAlpha(fileSel.Scr, DUSK_IF_ELSE(dusk::version::isRegionJpn() ? l_tagName20_jpn[i] : l_tagName20[i], l_tagName20[i]), 0, NULL);
         ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setFont(fileSel.font[0]);
         ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setString(512, "");
 
-#if (VERSION != VERSION_GCN_JPN) && (VERSION != VERSION_WII_JPN)
+#if TARGET_PC || ((VERSION != VERSION_GCN_JPN) && (VERSION != VERSION_WII_JPN))
+        IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
         mErrorMsgTxtPane[i]->getPanePtr()->resize(440.0f, 198.0f);
+        IF_DUSK_BLOCK_END
 #endif
 
         ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
 
-#if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
+            ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
+        } else {
+            ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setLineSpace(21.0f);
+            ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setCharSpace(1.0f);
+        }
+#elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
         ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
         ((J2DTextBox*)mErrorMsgTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
 #else
@@ -3579,7 +3701,15 @@ void dFile_select_c::screenSetYesNo() {
 
     for (int i = 0; i < 2; i++) {
         mYnSelPane[i] = JKR_NEW CPaneMgr(mYnSel.ScrYn, l_tagName012[i], 0, NULL);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mYnSelTxtPane[i] = JKR_NEW CPaneMgr(mYnSel.ScrYn, l_tagName013[i], 0, NULL);
+            mYnSel.ScrYn->search(l_tagName013U[i])->hide();
+        } else {
+            mYnSelTxtPane[i] = JKR_NEW CPaneMgr(mYnSel.ScrYn, l_tagName013U[i], 0, NULL);
+            mYnSel.ScrYn->search(l_tagName013[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mYnSelTxtPane[i] = JKR_NEW CPaneMgr(mYnSel.ScrYn, l_tagName013[i], 0, NULL);
         mYnSel.ScrYn->search(l_tagName013U[i])->hide();
 #else
@@ -3657,7 +3787,15 @@ void dFile_select_c::screenSet3Menu() {
 
     for (int i = 0; i < 3; i++) {
         m3mSelPane[i] = JKR_NEW CPaneMgr(m3mSel.Scr3m, l_tagName1[i], 0, NULL);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            m3mSelTextPane[i] = JKR_NEW CPaneMgr(m3mSel.Scr3m, l_tagName011[i], 0, NULL);
+            m3mSel.Scr3m->search(l_tagName011U[i])->hide();
+        } else {
+            m3mSelTextPane[i] = JKR_NEW CPaneMgr(m3mSel.Scr3m, l_tagName011U[i], 0, NULL);
+            m3mSel.Scr3m->search(l_tagName011[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         m3mSelTextPane[i] = JKR_NEW CPaneMgr(m3mSel.Scr3m, l_tagName011[i], 0, NULL);
         m3mSel.Scr3m->search(l_tagName011U[i])->hide();
 #else
@@ -3777,7 +3915,12 @@ void dFile_select_c::headerTxtSet(u16 i_msgId, u8 i_type, u8 param_3) {
         SAFE_STRCPY(mHeaderStringPtr[dispIdx], "");
     } else {
         static f32 fontsize[2] = {21.0f, 27.0f};
-        #if VERSION == VERSION_GCN_JPN
+        #if TARGET_PC
+        static f32 linespace_jpn[2] = {22.0f, 20.0f};
+        static f32 charspace_jpn[2] = {2.0f, 3.0f};
+        static f32 linespace[2] = {21.0f, 20.0f};
+        static f32 charspace[2] = {0.0f, 0.0f};
+        #elif VERSION == VERSION_GCN_JPN
             static f32 linespace[2] = {22.0f, 20.0f};
             static f32 charspace[2] = {2.0f, 3.0f};
         #else
@@ -3787,8 +3930,8 @@ void dFile_select_c::headerTxtSet(u16 i_msgId, u8 i_type, u8 param_3) {
 
         ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr())->setFont(fileSel.font[i_type]);
         ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr())->setFontSize(fontsize[i_type], fontsize[i_type]);
-        ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr())->setLineSpace(linespace[i_type]);
-        ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr())->setCharSpace(charspace[i_type]);
+        ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr())->setLineSpace(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? linespace_jpn[i_type] : linespace[i_type], linespace[i_type]));
+        ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr())->setCharSpace(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? charspace_jpn[i_type] : charspace[i_type], charspace[i_type]));
         fileSel.mMessageString->getString(i_msgId,
                                           ((J2DTextBox*)mHeaderTxtPane[dispIdx]->getPanePtr()), NULL,
                                           fileSel.font[i_type], NULL, 0);
@@ -4016,11 +4159,43 @@ bool dFile_select_c::yesnoWakuAlpahAnm(u8 param_1) {
 }
 
 #if TARGET_PC
+
+static dusk::utils::PaneCache mSelDtPanes[] = {
+    {MULTI_CHAR('tate_n0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('tate_n1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('ken_n0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('ken_n1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fuku_n0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fuku_n1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fuku_n2'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('gray_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('b_base'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('b_base1'), 0.0f, 0.0f, false},
+};
+
+static dusk::utils::PaneCache fileSelPanes[] = {
+    {MULTI_CHAR('w_uzu00'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu01'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu02'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu03'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu04'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu05'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu06'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu07'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu08'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_uzu09'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_er_msg'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_er_msE'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_er_msR'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('er_for0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('er_for1'), 0.0f, 0.0f, false},
+};
+
 void dFile_select_c::fileSelectWide() {
     static bool cachedPanes = false;
     // Get pre-scale values for each pane
     if (!cachedPanes) {
-        for (PaneCache& entry : mSelDtPanes) {
+        for (dusk::utils::PaneCache& entry : mSelDtPanes) {
             J2DPane* pane = mSelDt.ScrDt->search(entry.tag);
             if (!entry.cached) {
                 entry.origTransX = pane->getTranslateX(); 
@@ -4028,7 +4203,7 @@ void dFile_select_c::fileSelectWide() {
                 entry.cached = true;
             }
         }
-        for (PaneCache& entry : fileSelPanes) {
+        for (dusk::utils::PaneCache& entry : fileSelPanes) {
             J2DPane* pane = fileSel.Scr->search(entry.tag);
             if (!entry.cached) {
                 entry.origTransX = pane->getTranslateX();
@@ -4042,13 +4217,13 @@ void dFile_select_c::fileSelectWide() {
     // Reset all panes
     mSelDt.ScrDt->scale(1.0f, 1.0f);
     mSelDt.ScrDt->translate(0.0f, 0.0f);
-    for (PaneCache& entry : mSelDtPanes) {
+    for (dusk::utils::PaneCache& entry : mSelDtPanes) {
         J2DPane* pane = mSelDt.ScrDt->search(entry.tag);
         pane->setBasePosition(J2DBasePosition_4);
         pane->scale(1.0f, 1.0f);
         pane->translate(entry.origTransX, entry.origTransY);
     }
-    for (PaneCache& entry : fileSelPanes) {
+    for (dusk::utils::PaneCache& entry : fileSelPanes) {
         J2DPane* pane = fileSel.Scr->search(entry.tag);
         pane->setBasePosition(J2DBasePosition_4);
         pane->scale(1.0f, 1.0f);
@@ -4120,7 +4295,7 @@ void dFile_select_c::fileSelectWide() {
         mSelDt.ScrDt->search(MULTI_CHAR('fuku_n2'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
 
         // Spirals & Memory Card Text
-        for (PaneCache& entry : fileSelPanes) {
+        for (dusk::utils::PaneCache& entry : fileSelPanes) {
             J2DPane* pane = fileSel.Scr->search(entry.tag);
             pane->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
         }
@@ -4146,7 +4321,7 @@ void dFile_select_c::fileSelectWide() {
         const f32 wideShiftFactor = mSelDt.ScrDt->search(MULTI_CHAR('gray_n'))->getTranslateX() * (wideScaleFactor - mDoGph_gInf_c::hudAspectScaleDown);
         const f32 ultraShiftFactor = mSelDt.ScrDt->search(MULTI_CHAR('gray_n'))->getTranslateX() * (ultraScaleFactor - mDoGph_gInf_c::hudAspectScaleDown);
 
-        for (PaneCache& entry : mSelDtPanes) {
+        for (dusk::utils::PaneCache& entry : mSelDtPanes) {
             const size_t index = &entry - mSelDtPanes;
             J2DPane* pane = mSelDt.ScrDt->search(entry.tag);
             pane->setBasePosition(J2DBasePosition_0);
@@ -4214,7 +4389,7 @@ void dFile_select_c::fileSelectWide() {
         }
 
         // Spirals & Memory Card Text
-        for (PaneCache& entry : fileSelPanes) {
+        for (dusk::utils::PaneCache& entry : fileSelPanes) {
             J2DPane* pane = fileSel.Scr->search(entry.tag);
             pane->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
         }
@@ -4256,15 +4431,15 @@ void dFile_select_c::_draw() {
         dComIfGd_set2DOpa(mSelIcon);
         dComIfGd_set2DOpa(mSelIcon2);
 
-        #if PLATFORM_GCN
-        #if TARGET_PC
+#if PLATFORM_GCN
+#if TARGET_PC
         dComIfGd_set2DOpaTop(&mFadeDlst);
-        #else
+#else
         mpFadePict->draw(mDoGph_gInf_c::getMinXF(), mDoGph_gInf_c::getMinYF(),
                            mDoGph_gInf_c::getWidthF(), mDoGph_gInf_c::getHeightF(), false, false,
                            false);
-        #endif
-        #endif
+#endif
+#endif
     }
 }
 
diff --git a/src/d/d_gameover.cpp b/src/d/d_gameover.cpp
index 7d421a187c..ac85b5d2b4 100644
--- a/src/d/d_gameover.cpp
+++ b/src/d/d_gameover.cpp
@@ -14,7 +14,9 @@
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include <cstring>
 
-#include "dusk/gx_helper.h"
+#if TARGET_PC
+#include "helpers/gx_helper.h"
+#endif
 
 class dGov_HIO_c : public mDoHIO_entry_c {
 public:
diff --git a/src/d/d_item.cpp b/src/d/d_item.cpp
index cb525139db..f89d4f37e8 100644
--- a/src/d/d_item.cpp
+++ b/src/d/d_item.cpp
@@ -269,13 +269,17 @@ static void (*item_func_ptr[256])() = {
     item_func_noentry,
 };
 
-inline void getItemFunc(u8 i_itemNo) {
+#if !TARGET_PC
+inline
+#endif
+void getItemFunc(u8 i_itemNo) {
     dComIfGs_onItemFirstBit(i_itemNo);
     item_func_ptr[i_itemNo]();
 }
 
-void execItemGet(u8 i_itemNo) {
+void execItemGet(u8 i_itemNo IF_DUSK_ARG(u32 i_itemGiveTag) IF_DUSK_ARG(fopAc_ac_c* i_giver)) {
     getItemFunc(i_itemNo);
+    IF_DUSK(dusk::mods::item_granted(i_itemNo, i_itemGiveTag, i_giver);)
 }
 
 static int (*item_getcheck_func_ptr[256])() = {
@@ -740,8 +744,12 @@ void item_func_ARMOR() {}
 void item_func_WEAR_ZORA() {}
 
 void item_func_MAGIC_LV1() {
+#if TARGET_PC
+    dComIfGs_onEventBit(0xD04);
+#else
     dComIfGp_setItemMagicCount(16);
     dComIfGp_setItemMaxMagicCount(16);
+#endif
 }
 
 void item_func_DUNGEON_EXIT_2() {
@@ -1151,7 +1159,15 @@ void item_func_M_MAYFLY() {}
 
 void item_func_F_MAYFLY() {}
 
-void item_func_POU_SPIRIT() {}
+void item_func_POU_SPIRIT() {
+#if TARGET_PC
+    dComIfGs_addPohSpiritNum();
+    if (dComIfGs_getPohSpiritNum() == 20) {
+        /* dSv_event_flag_c::F_0457 - Castle Town - Revived cat */
+        dComIfGs_onEventBit(dSv_event_flag_c::saveBitLabels[457]);
+    }
+#endif
+}
 
 void item_func_ANCIENT_DOCUMENT() {
     dComIfGs_setItem(SLOT_22, dItemNo_ANCIENT_DOCUMENT_e);
@@ -1410,7 +1426,11 @@ int item_getcheck_func_WEAR_ZORA() {
 }
 
 int item_getcheck_func_MAGIC_LV1() {
+#if TARGET_PC
+    return dComIfGs_isEventBit(0xD04);
+#else
     return -1;
+#endif
 }
 
 int item_getcheck_func_DUNGEON_EXIT_2() {
@@ -2187,4 +2207,4 @@ int addBombCount(u8 i_bombType, u8 i_addNum) {
     return i_addNum;
 }
 
-u8* dEnemyItem_c::mData;
+DUSK_GAME_DATA u8* dEnemyItem_c::mData;
diff --git a/src/d/d_item_data.cpp b/src/d/d_item_data.cpp
index 2a84fb615a..a9aaab12d3 100644
--- a/src/d/d_item_data.cpp
+++ b/src/d/d_item_data.cpp
@@ -2,7 +2,7 @@
 
 #include "d/d_item_data.h"
 
-dItem_itemResource dItem_data::item_resource[] = {
+DUSK_GAME_DATA dItem_itemResource dItem_data::item_resource[] = {
     {"F_gD_rupy", 0x0004,-0x0001,-0x0001, 0x0007,-0x0001, 0x0, -0x1, 0x002D, 0x64, 0x0000},
     {"F_gD_rupy", 0x0004,-0x0001,-0x0001, 0x0007,-0x0001, 0x0, -0x1, 0x002D, 0x3C, 0x0000},
     {"F_gD_rupy", 0x0004,-0x0001,-0x0001, 0x0007,-0x0001, 0x1, -0x1, 0x002D, 0x3C, 0x0000},
@@ -53,7 +53,11 @@ dItem_itemResource dItem_data::item_resource[] = {
     {"F_gD_rupy", 0x0004,-0x0001,-0x0001, 0x0007,-0x0001, 0x0, -0x1, 0x006B, 0x64, 0x0000},
     {"O_gD_marm", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x0041, 0x64, 0x01A9},
     {"O_gD_zora", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x004D, 0x64, 0x01AA},
+#if TARGET_PC
+    {"O_gD_Injy", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x002E, 0x64, 0x0000},
+#else
     {"O_gD_Injy", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x002D, 0x64, 0x0000},
+#endif
     {"O_gD_TKS", 0x0008,-0x0001, 0x0005,-0x0001,-0x0001, -0x1, -0x1, 0x0028, 0x64, 0x0000},
     {"O_gD_puL2", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x0047, 0x64, 0x0000},
     {"O_gD_puL2", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x0048, 0x64, 0x0000},
@@ -260,7 +264,7 @@ dItem_itemResource dItem_data::item_resource[] = {
     {"T_gD_key", 0x0003,-0x0001,-0x0001,-0x0001,-0x0001, -0x1, -0x1, 0x006E, 0x64, 0x0000},
 };
 
-dItem_fieldItemResource dItem_data::field_item_res[] = {
+DUSK_GAME_DATA dItem_fieldItemResource dItem_data::field_item_res[] = {
     {"Always", 0x0014,-0x0001, 0x0030, 0xFF, 0x1000},
     {"Always", 0x0017,-0x0001, 0x0031, 0x0, 0x1000},
     {"Always", 0x0017,-0x0001, 0x0031, 0x1, 0x1000},
@@ -518,7 +522,7 @@ dItem_fieldItemResource dItem_data::field_item_res[] = {
     {"T_g_key", 0x0003,-0x0001,-0x0001, 0xFF, 0x1000},
 };
 
-dItem_itemInfo dItem_data::item_info[] = {
+DUSK_GAME_DATA dItem_itemInfo dItem_data::item_info[] = {
     {15, 40, 30, 4}, {20, 70, 30, 4}, {20, 70, 30, 4},   {20, 70, 30, 4},    {20, 70, 30, 4},
     {20, 70, 30, 4}, {20, 70, 30, 4}, {20, 70, 30, 4},   {20, 40, 30, 4},    {20, 40, 30, 4},
     {40, 60, 30, 0}, {40, 60, 30, 0}, {40, 60, 30, 0},   {40, 60, 30, 0},    {20, 80, 50, 0},
diff --git a/src/d/d_k_wmark.cpp b/src/d/d_k_wmark.cpp
index f986808068..80c2523c8a 100644
--- a/src/d/d_k_wmark.cpp
+++ b/src/d/d_k_wmark.cpp
@@ -14,7 +14,7 @@
 #include "f_op/f_op_actor_mng.h"
 #include "m_Do/m_Do_lib.h"
 
-int dkWmark_c::m_nowID;
+DUSK_GAME_DATA int dkWmark_c::m_nowID;
 
 int dkWmark_c::create() {
     static cXyz wolfFootScale(1.1f, 1.0f, 0.6f);
diff --git a/src/d/d_kankyo.cpp b/src/d/d_kankyo.cpp
index 36949adc76..b8e397e0ad 100644
--- a/src/d/d_kankyo.cpp
+++ b/src/d/d_kankyo.cpp
@@ -32,11 +32,11 @@
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include <cstdlib>
 #include <cstring>
+
 #if TARGET_PC
-#include "dusk/imgui/ImGuiBloomWindow.hpp"
-#include "dusk/settings.h"
-#include "dusk/frame_interpolation.h"
 #include "dusk/game_clock.h"
+#include "dusk/imgui/ImGuiBloomWindow.hpp"
+static f32 timeScale = 1.0f;
 #endif
 
 static void GxXFog_set();
@@ -106,9 +106,9 @@ static u16 lightMaskData[8] = {
     GX_LIGHT0, GX_LIGHT1, GX_LIGHT2, GX_LIGHT3, GX_LIGHT4, GX_LIGHT5, GX_LIGHT6, GX_LIGHT7,
 };
 
-dScnKy_env_light_c g_env_light;
+DUSK_GAME_DATA dScnKy_env_light_c g_env_light;
 
-Z2EnvSeMgr g_mEnvSeMgr;
+DUSK_GAME_DATA Z2EnvSeMgr g_mEnvSeMgr;
 
 #if DEBUG
 dKankyo_HIO_c g_kankyoHIO;
@@ -1799,6 +1799,9 @@ void dScnKy_env_light_c::setLight_palno_get(u8* prev_envr_id_p, u8* next_envr_id
     u8 psel_idx = 0;
     int i;
     int sp14 = 0;
+#if TARGET_PC
+    const f32 timeScale = (pattern_ratio_p == &g_env_light.pat_ratio) ? ::timeScale : 1.0f;
+#endif
 
     if (*init_timer_p != 0) {
         (*init_timer_p)++;
@@ -2132,14 +2135,22 @@ void dScnKy_env_light_c::setLight_palno_get(u8* prev_envr_id_p, u8* next_envr_id
 
             if (g_env_light.mColPatMode == 0) {
                 if (pselect_p->change_rate > 0.0f) {
+#if TARGET_PC
+                    *pattern_ratio_p += timeScale * ((1.0f / 30) / pselect_p->change_rate);
+#else
                     *pattern_ratio_p += (1.0f / 30) / pselect_p->change_rate;
+#endif
                 }
 
                 // pattern change rate is faster in hyrule field
                 if (strcmp(dComIfGp_getStartStageName(), "F_SP121") == 0 &&
                     *prev_pat_p == *next_pat_p)
                 {
+#if TARGET_PC
+                    *pattern_ratio_p += timeScale * (1.0f / 15);
+#else
                     *pattern_ratio_p += (1.0f / 15);
+#endif
                 }
 
                 if (*pattern_ratio_p >= 1.0f) {
@@ -2332,6 +2343,10 @@ void dScnKy_env_light_c::setLight() {
         u8 next_pal_start_id;
         u8 prev_pal_end_id;
         u8 next_pal_end_id;
+#if TARGET_PC
+        const f32 deltaTime = dusk::game_clock::consume_interval(this);
+        timeScale = deltaTime / dusk::game_clock::kSimPeriod;
+#endif
         setLight_palno_get(&g_env_light.PrevCol, &g_env_light.UseCol, &g_env_light.wether_pat0,
                            &g_env_light.wether_pat1, &prev_pal_start_id, &prev_pal_end_id,
                            &next_pal_start_id, &next_pal_end_id, &color_ratio, &start_pat_pal_id,
@@ -2517,8 +2532,6 @@ void dScnKy_env_light_c::setLight() {
                 f32 sin = cM_ssin(S_fuwan_sin);
 
                 #if TARGET_PC
-                    const f32 deltaTime = dusk::game_clock::consume_interval(this);
-                    const f32 timeScale = deltaTime / dusk::game_clock::period_for_original_frames(1.0f);
                     S_fuwan_sin += (s16)((cM_rndF(2000.0f) + 500) * timeScale);
                 #else
                     S_fuwan_sin += (s16)cM_rndF(2000.0f) + 500;
@@ -8261,9 +8274,7 @@ static int dKy_Create(void* i_this) {
     kankyo_class* kankyo = (kankyo_class*)i_this;
     BOOL next_time_set = false;
 
-#if TARGET_PC
-    kankyo->base.draw_interp_frame = true;
-#endif
+    IF_DUSK(kankyo->base.draw_interp_frame = true);
 
     stage_envr_info_class* stage_envr_p = dComIfGp_getStageEnvrInfo();
     if (stage_envr_p != NULL && dComIfGp_getStartStageRoomNo() != -1) {
diff --git a/src/d/d_kankyo_rain.cpp b/src/d/d_kankyo_rain.cpp
index bcc8b228e6..dc01322291 100644
--- a/src/d/d_kankyo_rain.cpp
+++ b/src/d/d_kankyo_rain.cpp
@@ -12,8 +12,10 @@
 #include "m_Do/m_Do_graphic.h"
 #include "m_Do/m_Do_lib.h"
 #include <cstring>
+
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/version.hpp"
 #endif
 
 static void vectle_calc(DOUBLE_POS* i_pos, cXyz* o_out) {
@@ -127,24 +129,73 @@ static GXTexObj* load_cached_tex(CachedTexObjs<N>& cache, ResTIMG* img, GXTexMap
 }
 #endif
 
+#if TARGET_PC
+static void dKyr_place_sun(camera_class* camera, cXyz* o_sunpos) {
+    cXyz lightDir;
+    u32 stage_type = dStage_stagInfo_GetSTType(dComIfGp_getStage()->getStagInfo());
+    if (g_env_light.base_light.mColor.r == 0 && stage_type != ST_ROOM) {
+        dKyr_get_vectle_calc(&camera->view.lookat.eye, &g_env_light.base_light.mPosition,
+                             &lightDir);
+    } else {
+        dKyr_get_vectle_calc(&camera->view.lookat.eye, &g_env_light.sun_light_pos, &lightDir);
+    }
+    o_sunpos->x = camera->view.lookat.eye.x + 8000.0f * lightDir.x;
+    o_sunpos->y = camera->view.lookat.eye.y + 8000.0f * lightDir.y;
+    o_sunpos->z = camera->view.lookat.eye.z + 8000.0f * lightDir.z;
+}
+
+static void dKyr_place_lenzflare(camera_class* camera, cXyz* sunpos, cXyz* o_positions) {
+    cXyz eyeVect;
+    cXyz sunDirSmth;
+    cXyz camFwd;
+
+    dKy_set_eyevect_calc(camera, &eyeVect, 4000.0f, 4000.0f);
+    dKyr_get_vectle_calc(&eyeVect, sunpos, &sunDirSmth);
+    o_positions[0] = *sunpos;
+    o_positions[1] = *sunpos;
+
+    dKyr_get_vectle_calc(&camera->view.lookat.eye, &camera->view.lookat.center, &camFwd);
+
+    for (int i = 2; i < 8; i++) {
+        if (i == 2) {
+            f32 size = 250.0f + 600.0f * sunDirSmth.abs(camFwd);
+            o_positions[i].x = sunpos->x - sunDirSmth.x * size * i;
+            o_positions[i].y = sunpos->y - sunDirSmth.y * size * i;
+            o_positions[i].z = sunpos->z - sunDirSmth.z * size * i;
+        } else {
+            f32 size = 250.0f + 110.0f * sunDirSmth.abs(camFwd);
+            o_positions[i].x = sunpos->x - (4100.0f * sunDirSmth.x + sunDirSmth.x * size * i);
+            o_positions[i].y = sunpos->y - (4100.0f * sunDirSmth.y + sunDirSmth.y * size * i);
+            o_positions[i].z = sunpos->z - (4100.0f * sunDirSmth.z + sunDirSmth.z * size * i);
+        }
+    }
+}
+#endif
+
 void dKyr_lenzflare_move() {
     dKankyo_sun_Packet* sun_packet = g_env_light.mpSunPacket;
     dKankyo_sunlenz_Packet* lenz_packet = g_env_light.mpSunLenzPacket;
     camera_process_class* camera = dComIfGp_getCamera(0);
 
+#if !TARGET_PC
     cXyz eyeVect;
     cXyz field_0x3c;
     cXyz sunDirSmth;
     cXyz camFwd;
+#endif
 
     if (sun_packet->mVisibility < 0.0001f) {
         return;
     }
 
+#if TARGET_PC
+    dKyr_place_lenzflare(camera, sun_packet->mPos, lenz_packet->mPositions);
+#else
     dKy_set_eyevect_calc(camera, &eyeVect, 4000.0f, 4000.0f);
     dKyr_get_vectle_calc(&eyeVect, sun_packet->mPos, &sunDirSmth);
     lenz_packet->mPositions[0] = sun_packet->mPos[0];
     lenz_packet->mPositions[1] = sun_packet->mPos[0];
+#endif
 
     cXyz vect;
     cXyz proj;
@@ -160,6 +211,7 @@ void dKyr_lenzflare_move() {
     lenz_packet->field_0x94 *= S2DEG_CONSTANT;  // convert from short angle to degrees
     lenz_packet->field_0x94 += 180.0f;
 
+#if !TARGET_PC
     dKyr_get_vectle_calc(&camera->view.lookat.eye, &camera->view.lookat.center, &camFwd);
 
     for (int i = 2; i < 8; i++) {
@@ -175,6 +227,7 @@ void dKyr_lenzflare_move() {
             lenz_packet->mPositions[i].z = sun_packet->mPos[0].z - (4100.0f * sunDirSmth.z + sunDirSmth.z * size * i);
         }
     }
+#endif
 }
 
 static BOOL dKyr_moon_arrival_check() {
@@ -203,6 +256,10 @@ void dKyr_sun_move() {
 
     u32 stage_type = dStage_stagInfo_GetSTType(dComIfGp_getStage()->getStagInfo());
 
+#if TARGET_PC
+    dKyr_place_sun(camera_p2, &sun_packet->mPos[0]);
+    dKyr_get_vectle_calc(&camera_p2->view.lookat.eye, &sun_packet->mPos[0], &lightDir);
+#else
     if (g_env_light.base_light.mColor.r == 0 && stage_type != ST_ROOM) {
         dKyr_get_vectle_calc(&camera_p2->view.lookat.eye, &g_env_light.base_light.mPosition,
                              &lightDir);
@@ -213,6 +270,7 @@ void dKyr_sun_move() {
     sun_packet->mPos[0].x = camera_p2->view.lookat.eye.x + 8000.0f * lightDir.x;
     sun_packet->mPos[0].y = camera_p2->view.lookat.eye.y + 8000.0f * lightDir.y;
     sun_packet->mPos[0].z = camera_p2->view.lookat.eye.z + 8000.0f * lightDir.z;
+#endif
 
     f32 horizon_y = (sun_packet->mPos[0].y - camera_p2->view.lookat.eye.y) / 8000.0f;
     if (horizon_y < 0.0f) {
@@ -2386,10 +2444,12 @@ void dKyr_drawSun(Mtx drawMtx, cXyz* ppos, GXColor& unused, u8** tex) {
     u8 draw_sun = false;
     u16 date = dComIfGs_getDate();
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+    IF_DUSK_BLOCK(dusk::version::isRegionJpn())
     if (g_env_light.hide_vrbox) {
         return;
     }
+    IF_DUSK_BLOCK_END
 #endif
 
     if (strcmp(dComIfGp_getStartStageName(), "F_SP200") == 0) {
@@ -2410,15 +2470,17 @@ void dKyr_drawSun(Mtx drawMtx, cXyz* ppos, GXColor& unused, u8** tex) {
         sunpos.y = ppos->y;
         sunpos.z = ppos->z;
 
+        IF_DUSK(dKyr_place_sun(camera, &sunpos));
+
         u32 stage_type = dStage_stagInfo_GetSTType(dComIfGp_getStage()->getStagInfo());
         if (g_env_light.base_light.mColor.r == 0 && stage_type != ST_ROOM) {
             if (g_env_light.daytime > 285.0f || g_env_light.daytime < 105.0f) {
                 draw_moon = false;
             }
 
-            spB4.x = ppos->x;
-            spB4.y = ppos->y;
-            spB4.z = ppos->z;
+            spB4.x = DUSK_IF_ELSE(sunpos.x, ppos->x);
+            spB4.y = DUSK_IF_ELSE(sunpos.y, ppos->y);
+            spB4.z = DUSK_IF_ELSE(sunpos.z, ppos->z);
         } else {
             if (strcmp(dComIfGp_getStartStageName(), "F_SP200") == 0 && dComIfG_play_c::getLayerNo(0) == 0) {
                 spB4 = envlight->moon_pos;
@@ -2584,7 +2646,8 @@ void dKyr_drawSun(Mtx drawMtx, cXyz* ppos, GXColor& unused, u8** tex) {
                 };
 
                 if (strcmp(dComIfGp_getStartStageName(), "F_SP200") != 0) {
-                    dKyr_get_vectle_calc(&camera->view.lookat.eye, &camera->view.lookat.center, &camfwd);
+                    dKyr_get_vectle_calc(&camera->view.lookat.eye,
+                                         &camera->view.lookat.center, &camfwd);
                     f32 cam_distXZ = JMAFastSqrt((camfwd.x * camfwd.x) + (camfwd.z * camfwd.z));
                     f32 cam_theta = atan2f(camfwd.x, camfwd.z);
                     f32 cam_phi = atan2f(camfwd.y, cam_distXZ);
@@ -2754,10 +2817,12 @@ void dKyr_drawLenzflare(Mtx drawMtx, cXyz* ppos, GXColor& param_2, u8** tex) {
     static s16 S_rot_work1 = 0;
     static s16 S_rot_work2 = 0;
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+    IF_DUSK_BLOCK(dusk::version::isRegionJpn())
     if (g_env_light.hide_vrbox) {
         return;
     }
+    IF_DUSK_BLOCK_END
 #endif
 
     Mtx camMtx;
@@ -2777,6 +2842,13 @@ void dKyr_drawLenzflare(Mtx drawMtx, cXyz* ppos, GXColor& param_2, u8** tex) {
     f32 spA8 = sun_packet->mVisibility * sun_packet->mVisibility;
 
     if (!(sun_visibility < 0.1f)) {
+#if TARGET_PC
+        cXyz sunpos;
+        cXyz positions[8];
+        dKyr_place_sun(camera, &sunpos);
+        dKyr_place_lenzflare(camera, &sunpos, positions);
+        ppos = positions;
+#endif
         dKy_set_eyevect_calc2(camera, &spFC, 8000.0f, 8000.0f);
 
         GXColor color_reg0;
@@ -2956,25 +3028,25 @@ void dKyr_drawLenzflare(Mtx drawMtx, cXyz* ppos, GXColor& param_2, u8** tex) {
                 spE4.y = sp9C;
                 spE4.z = 0.0f;
                 cMtx_multVec(camMtx, &spE4, &spD8);
-                pos[0].x = sun_packet->mPos[0].x + spD8.x;
-                pos[0].y = sun_packet->mPos[0].y + spD8.y;
-                pos[0].z = sun_packet->mPos[0].z + spD8.z;
+                pos[0].x = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).x + spD8.x;
+                pos[0].y = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).y + spD8.y;
+                pos[0].z = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).z + spD8.z;
 
                 spE4.x = sp98;
                 spE4.y = sp94;
                 spE4.z = 0.0f;
                 cMtx_multVec(camMtx, &spE4, &spD8);
-                pos[1].x = sun_packet->mPos[0].x + spD8.x;
-                pos[1].y = sun_packet->mPos[0].y + spD8.y;
-                pos[1].z = sun_packet->mPos[0].z + spD8.z;
+                pos[1].x = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).x + spD8.x;
+                pos[1].y = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).y + spD8.y;
+                pos[1].z = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).z + spD8.z;
 
                 spE4.x = sp90;
                 spE4.y = sp8C;
                 spE4.z = 0.0f;
                 cMtx_multVec(camMtx, &spE4, &spD8);
-                pos[2].x = sun_packet->mPos[0].x + spD8.x;
-                pos[2].y = sun_packet->mPos[0].y + spD8.y;
-                pos[2].z = sun_packet->mPos[0].z + spD8.z;
+                pos[2].x = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).x + spD8.x;
+                pos[2].y = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).y + spD8.y;
+                pos[2].z = DUSK_IF_ELSE(sunpos, sun_packet->mPos[0]).z + spD8.z;
 
                 GXBegin(GX_TRIANGLES, GX_VTXFMT0, 3);
                 GXPosition3f32(pos[0].x, pos[0].y, pos[0].z);
@@ -4223,10 +4295,12 @@ void dKyr_drawStar(Mtx drawMtx, u8** tex) {
         csXyz(0, 30000, 19000),
     };
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+    IF_DUSK_BLOCK(dusk::version::isRegionJpn())
     if (g_env_light.hide_vrbox) {
         return;
     }
+    IF_DUSK_BLOCK_END
 #endif
 
     if (star_packet->mEffectNum != 0) {
@@ -4770,10 +4844,12 @@ void drawVrkumo(Mtx drawMtx, GXColor& color, u8** tex) {
     int pass = 1;
     f32 spC4 = 0.0f;
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+    IF_DUSK_BLOCK(dusk::version::isRegionJpn())
     if (g_env_light.hide_vrbox) {
         return;
     }
+    IF_DUSK_BLOCK_END
 #endif
 
     cXyz sp15C;
@@ -6197,12 +6273,9 @@ static void dKyr_evil_draw2(Mtx drawMtx, u8** tex) {
         dKyr_set_btitex(&texobj, (ResTIMG*)tex[1]);
 #endif
 
-#if TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            rot += 0.7f;
-        }
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        rot += 0.7f;
+        IF_DUSK_BLOCK_END
         MTXRotRad(rotMtx, 'Z', DEG_TO_RAD(rot));
         MTXConcat(camMtx, rotMtx, camMtx);
 
@@ -6441,12 +6514,9 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
         dKyr_set_btitex(&texobj, (ResTIMG*)tex[0]);
 #endif
 
-#if TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            rot += 1.0f;
-        }
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        rot += 1.0f;
+        IF_DUSK_BLOCK_END
         MTXRotRad(rotMtx, 'Z', DEG_TO_RAD(rot));
         MTXConcat(camMtx, rotMtx, camMtx);
 
diff --git a/src/d/d_kyeff.cpp b/src/d/d_kyeff.cpp
index 984478f74d..1ba4ffa96f 100644
--- a/src/d/d_kyeff.cpp
+++ b/src/d/d_kyeff.cpp
@@ -118,7 +118,7 @@ static int dKyeff_Create(kankyo_class* i_this) {
 
     if (strcmp(dComIfGp_getStartStageName(), "Name") == 0) {
         camera_process_class* camera = dComIfGp_getCamera(0);
-        OSTime time = OSGetTime();
+        OSTime time = DUSK_IF_ELSE(OSGetSystemTime(), OSGetTime());
         OSTicksToCalendarTime(time, &calendar);
 
         g_env_light.global_wind_influence.vec.x = 1.0f;
diff --git a/src/d/d_lib.cpp b/src/d/d_lib.cpp
index 80aa72ff3c..902e6d4b24 100644
--- a/src/d/d_lib.cpp
+++ b/src/d/d_lib.cpp
@@ -32,7 +32,7 @@ static void dummy1(mDoExt_btkAnm* btk, cXyz& pos) {
     dDbVw_drawLineOpa(pos, pos, color, 0, 0);
 }
 
-Quaternion ZeroQuat = {
+DUSK_GAME_DATA Quaternion ZeroQuat = {
     0.0f,
     0.0f,
     0.0f,
@@ -300,7 +300,7 @@ BOOL dLib_checkActorInRectangle(fopAc_ac_c* param_0, fopAc_ac_c* param_1, cXyz c
 }
 
 u32 dLib_getExpandSizeFromAramArchive(JKRAramArchive* i_aramArchive, char const* param_2) {
-    u8 header[32] ATTRIBUTE_ALIGN(32);
+    ATTRIBUTE_ALIGN(32) u8 header[32];
     JUT_ASSERT(1252, i_aramArchive != NULL);
     u32 address = i_aramArchive->getAramAddress(param_2);
     if (address == 0) {
@@ -311,16 +311,21 @@ u32 dLib_getExpandSizeFromAramArchive(JKRAramArchive* i_aramArchive, char const*
     JUT_ASSERT(1260, readAddress == header);
     JKRArchive::SDIFileEntry* entry = i_aramArchive->findFsResource(param_2, 0);
     JUT_ASSERT(1263, entry != NULL);
+#if TARGET_PC
+    if (u32 size; i_aramArchive->getOverlayFileSize(entry, &size)) {
+        return ALIGN_NEXT(size, 32);
+    }
+#endif
     u32 uVar1 = ALIGN_NEXT(JKRDecompExpandSize(header), 32);
     u32 uVar5 = ALIGN_NEXT(entry->data_size, 32);
     return uVar1 > uVar5 ? uVar1 : uVar5;
 }
 
-OSTime dLib_time_c::m_diffTime;
+DUSK_GAME_DATA OSTime dLib_time_c::m_diffTime;
 
-OSTime dLib_time_c::m_stopTime;
+DUSK_GAME_DATA OSTime dLib_time_c::m_stopTime;
 
-bool dLib_time_c::m_timeStopped;
+DUSK_GAME_DATA bool dLib_time_c::m_timeStopped;
 
 OSTime dLib_time_c::getTime() {
     if (!m_timeStopped) {
diff --git a/src/d/d_map.cpp b/src/d/d_map.cpp
index 404123f594..88cc1d19ba 100644
--- a/src/d/d_map.cpp
+++ b/src/d/d_map.cpp
@@ -337,7 +337,7 @@ f32 renderingAmap_c::getIconSize(u8 i_typeGroup) const {
     return iconSize;
 }
 
-dMap_prm_res_s* dMap_HIO_prm_res_dst_s::m_res;
+DUSK_GAME_DATA dMap_prm_res_s* dMap_HIO_prm_res_dst_s::m_res;
 
 inline u8 twoValueLineInterpolation(u8 param_0, u8 param_1, f32 param_2) {
     return ((f32)param_0 + (param_2 * ((f32)param_1 - (f32)param_0)));
diff --git a/src/d/d_map_path.cpp b/src/d/d_map_path.cpp
index cafbb93e38..41d5108e32 100644
--- a/src/d/d_map_path.cpp
+++ b/src/d/d_map_path.cpp
@@ -16,23 +16,14 @@
 
 #ifdef TARGET_PC
 #include "dusk/settings.h"
+#include "dusk/hq_minimap.hpp"
 #include "m_Do/m_Do_graphic.h"
 #include <dolphin/gx/GXAurora.h>
 #include <aurora/math.hpp>
 
 #include <algorithm>
-#include <array>
 #include <cmath>
-#include <functional>
 #include <limits>
-#include <numbers>
-#include <span>
-
-constexpr u16 kMapIconResolutionMultiplier = 4;
-constexpr u16 kMapImageSide = 16 * kMapIconResolutionMultiplier;
-constexpr u32 kMapImageTotalPixels = kMapImageSide * kMapImageSide;
-
-typedef std::function<u8(size_t, size_t)> PaintI8Fn;
 
 u16 scaled_map_axis(u16 value, f32 scale) {
     const auto scaledValue =
@@ -59,27 +50,6 @@ aurora::Vec2<u16> map_render_size_for(u16 width, u16 height) {
         scaled_map_axis(height, irScaleY * hudScale),
     };
 }
-
-void paint_i8(std::span<u8> dst, size_t width, PaintI8Fn paint) {
-    const auto blocksAcross = width >> 3;
-
-    for (size_t i = 0; i < dst.size(); i++) {
-        // 8x4 block swizzling for I8
-        const auto blockIdx = i >> 5;
-        const auto localIdx = i & 31;
-
-        const auto blockY = blockIdx / blocksAcross;
-        const auto blockX = blockIdx % blocksAcross;
-
-        const auto localY = localIdx >> 3;
-        const auto localX = localIdx & 7;
-
-        const auto x = (blockX << 3) + localX;
-        const auto y = (blockY << 2) + localY;
-
-        dst[i] = paint(x, y);
-    }
-}
 #endif
 
 void dMpath_n::dTexObjAggregate_c::create() {
@@ -100,106 +70,11 @@ void dMpath_n::dTexObjAggregate_c::create() {
         JUT_ASSERT(72, image != NULL);
         JUT_ASSERT(73, image->minFilter == GX_NEAR);
         JUT_ASSERT(74, image->magFilter == GX_NEAR);
+        IF_DUSK(dusk::hq_minimap::register_pointer(data[lp1], reinterpret_cast<u8*>(image) + image->imageOffset));
         mDoLib_setResTimgObj(image, mp_texObj[lp1], 0, NULL);
     }
 
-#if TARGET_PC
-    static bool hqTexsDrawn = false;
-
-    static u8 hqCircleData[kMapImageTotalPixels];
-    static u8 hqCircleAltData[kMapImageTotalPixels];
-    static u8 hqNijumaruData[kMapImageTotalPixels];
-    static u8 hqEnterData[kMapImageTotalPixels];
-    static u8 hqTryForceData[kMapImageTotalPixels];
-
-    if (!hqTexsDrawn) {
-        constexpr auto center = kMapImageSide / 2.0f;
-        constexpr auto radiusSq = center * center;
-
-        // 6: map_icon_circle16x16_4i.bti - simple circle
-        paint_i8(std::span{hqCircleData}, kMapImageSide, [=](auto x, auto y) {
-            const auto dx = (x + 0.5f) - center;
-            const auto dy = (y + 0.5f) - center;
-            return (dx * dx + dy * dy < radiusSq) ? 0x11 : 0;
-        });
-
-        // 4: im_map_icon_circle_4i.bti - outlined circle
-        paint_i8(std::span{hqCircleAltData}, kMapImageSide, [=](auto x, auto y) {
-            constexpr auto innerRadius = kMapImageSide * 3.0f / 8.0f;
-            constexpr auto innerRadiusSq = innerRadius * innerRadius;
-
-            const auto dx = (x + 0.5f) - center;
-            const auto dy = (y + 0.5f) - center;
-            const auto dSq = dx * dx + dy * dy;
-
-            return dSq < radiusSq ? (dSq < innerRadiusSq ? 0x22 : 0x11) : 0;
-        });
-
-        // 3: im_map_icon_nijumaru_4i.bti - concentric rings
-        paint_i8(std::span{hqNijumaruData}, kMapImageSide, [=](auto x, auto y) {
-            constexpr u8 nijumaruRings[] = {0x11, 0x22, 0x11, 0x11, 0x22, 0x22};
-
-            const auto dx = (x + 0.5f) - center;
-            const auto dy = (y + 0.5f) - center;
-            const auto dSq = dx * dx + dy * dy;
-
-            if (dSq < radiusSq) {
-                const auto ringIndex =
-                    static_cast<size_t>(std::trunc(std::sqrt(dSq) / kMapImageSide * 12));
-                return nijumaruRings[ringIndex];
-            }
-            return u8{0};
-        });
-
-        // 2: im_map_icon_enter_4i.bti - outlined octagram
-        paint_i8(std::span{hqEnterData}, kMapImageSide, [=](auto x, auto y) {
-            constexpr auto outlineWidth = kMapImageSide / 6.0f;
-
-            const auto adx = std::abs((x + 0.5f) - center);
-            const auto ady = std::abs((y + 0.5f) - center);
-            const auto dist =
-                std::min(adx + ady, std::max(adx, ady) * std::numbers::sqrt2_v<float>) -
-                kMapImageSide / 2.0f;
-
-            return dist > 0.0f ? 0 : (dist > -outlineWidth ? 0x22 : 0x33);
-        });
-
-        // 5: im_map_icon_try_force_4i.bti - outlined circle with triangle
-        paint_i8(std::span{hqTryForceData}, kMapImageSide, [=](auto x, auto y) {
-            constexpr auto innerRadiusNorm = 5.0f / 12.0f;
-            constexpr auto innerRadius = kMapImageSide * innerRadiusNorm;
-            constexpr auto innerRadiusSq = innerRadius * innerRadius;
-            constexpr auto triRadius = kMapImageSide * innerRadiusNorm / 2.0f;
-
-            const auto dx = (x + 0.5f) - center;
-            const auto dy = (y + 0.5f) - center;
-            const auto dSq = dx * dx + dy * dy;
-            const auto triSideDist = (std::numbers::sqrt3_v<float> * std::abs(dx) - dy) * 0.5f;
-            const auto insideTri = std::max(dy, triSideDist) < triRadius;
-
-            return insideTri ? 0x22 : (dSq < radiusSq ? (dSq < innerRadiusSq ? 0x33 : 0x22) : 0);
-        });
-
-        hqTexsDrawn = true;
-    }
-
-    constexpr auto replacements = std::to_array<std::pair<size_t, const u8*> >({
-        {2, hqEnterData},
-        {3, hqNijumaruData},
-        {4, hqCircleAltData},
-        {5, hqTryForceData},
-        {6, hqCircleData},
-    });
-
-    for (const auto& [idx, data] : replacements) {
-        JKR_DELETE(mp_texObj[idx]);
-        const auto texobj = JKR_NEW TGXTexObj();
-        GXInitTexObj(
-            texobj, data, kMapImageSide, kMapImageSide, GX_TF_I8, GX_CLAMP, GX_CLAMP, GX_FALSE);
-        GXInitTexObjLOD(texobj, GX_NEAR, GX_NEAR, 0.0f, 0.0f, 0.0f, GX_FALSE, GX_FALSE, GX_ANISO_1);
-        mp_texObj[idx] = texobj;
-    }
-#endif
+    IF_DUSK(dusk::hq_minimap::initialize_if_needed());
 }
 
 void dMpath_n::dTexObjAggregate_c::remove() {
@@ -659,7 +534,7 @@ void dRenderingFDAmap_c::postRenderingMap() {
     dComIfGp_getCurrentGrafPort()->setup2D();
 }
 
-dMpath_n::dTexObjAggregate_c dMpath_n::m_texObjAgg;
+DUSK_GAME_DATA dMpath_n::dTexObjAggregate_c dMpath_n::m_texObjAgg;
 
 void dRenderingFDAmap_c::renderingDecoration(dDrawPath_c::line_class const* p_line) {
     s32 width = getDecorationLineWidth(p_line->field_0x1);
diff --git a/src/d/d_map_path_dmap.cpp b/src/d/d_map_path_dmap.cpp
index f2a41e8fd3..f9d2f4d5f9 100644
--- a/src/d/d_map_path_dmap.cpp
+++ b/src/d/d_map_path_dmap.cpp
@@ -226,11 +226,11 @@ void dMapInfo_n::getFloorParameter(f32 param_0, s8* i_floorNo, f32* param_2, f32
     }
 }
 
-s8 dMapInfo_c::mNowStayFloorNo;
+DUSK_GAME_DATA s8 dMapInfo_c::mNowStayFloorNo;
 
-int dMapInfo_c::mNowStayRoomNo;
+DUSK_GAME_DATA int dMapInfo_c::mNowStayRoomNo;
 
-u8 dMapInfo_c::mNowStayFloorNoDecisionFlg;
+DUSK_GAME_DATA u8 dMapInfo_c::mNowStayFloorNoDecisionFlg;
 
 s8 dMapInfo_c::calcFloorNo(f32 param_0, bool i_chkMinMax, int i_roomNo) {
     f32 sp10;
@@ -330,24 +330,24 @@ void dMapInfo_c::create() {
 
 void dMapInfo_c::remove() {}
 
-dDrawPath_c::layer_data* dMpath_c::mLayerList;
+DUSK_GAME_DATA dDrawPath_c::layer_data* dMpath_c::mLayerList;
 
 // these are needed for sinit, but its got reversed reg alloc?
-f32 dMpath_c::mMinX = FLT_MAX;
+DUSK_GAME_DATA f32 dMpath_c::mMinX = FLT_MAX;
 
-f32 dMpath_c::mMaxX = -FLT_MAX;
+DUSK_GAME_DATA f32 dMpath_c::mMaxX = -FLT_MAX;
 
-f32 dMpath_c::mMinZ = FLT_MAX;
+DUSK_GAME_DATA f32 dMpath_c::mMinZ = FLT_MAX;
 
-f32 dMpath_c::mMaxZ = -FLT_MAX;
+DUSK_GAME_DATA f32 dMpath_c::mMaxZ = -FLT_MAX;
 
-f32 dMpath_c::mAllCenterX;
+DUSK_GAME_DATA f32 dMpath_c::mAllCenterX;
 
-f32 dMpath_c::mAllCenterZ;
+DUSK_GAME_DATA f32 dMpath_c::mAllCenterZ;
 
-f32 dMpath_c::mAllSizeX;
+DUSK_GAME_DATA f32 dMpath_c::mAllSizeX;
 
-f32 dMpath_c::mAllSizeZ;
+DUSK_GAME_DATA f32 dMpath_c::mAllSizeZ;
 
 static bool data_80450E88;
 
@@ -355,11 +355,11 @@ bool dMpath_c::isExistMapPathData() {
     return data_80450E88;
 }
 
-int dMapInfo_c::mNextRoomNo = -1;
+DUSK_GAME_DATA int dMapInfo_c::mNextRoomNo = -1;
 
-s8 dMpath_c::mBottomFloorNo = 127;
+DUSK_GAME_DATA s8 dMpath_c::mBottomFloorNo = 127;
 
-s8 dMpath_c::mTopFloorNo = -128;
+DUSK_GAME_DATA s8 dMpath_c::mTopFloorNo = -128;
 
 int dMpath_c::getTopBottomFloorNo(s8* i_topFloorNo, s8* i_bottomFloorNo) {
     if (isExistMapPathData()) {
diff --git a/src/d/d_menu_calibration.cpp b/src/d/d_menu_calibration.cpp
index bc256547d7..e596609292 100644
--- a/src/d/d_menu_calibration.cpp
+++ b/src/d/d_menu_calibration.cpp
@@ -14,7 +14,9 @@
 #include "m_Do/m_Do_controller_pad.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "helpers/string.hpp"
+#endif
 
 // Need 0xC bytes of padding with no symbol between dMenu_Calibration_c::__vtable and the end of
 // .data
@@ -25,7 +27,7 @@ public:
     virtual void virt_func_0() = 0;
 };
 class dummy_child_class : dummy_abstract_class {
-#ifdef TARGET_PC
+#if TARGET_PC
     virtual void virt_func_0() {}
 #else
     virtual void virt_func_0();
diff --git a/src/d/d_menu_collect.cpp b/src/d/d_menu_collect.cpp
index 4e3ddf25f2..32c0a360c2 100644
--- a/src/d/d_menu_collect.cpp
+++ b/src/d/d_menu_collect.cpp
@@ -5,39 +5,41 @@
 
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_menu_collect.h"
-#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
-#include "JSystem/J3DGraphLoader/J3DAnmLoader.h"
+#include <cstring>
+#include <os.h>
+#include "JSystem/J2DGraph/J2DAnmLoader.h"
+#include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "JSystem/J3DGraphLoader/J3DAnmLoader.h"
+#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include "d/actor/d_a_alink.h"
-#include "d/d_select_cursor.h"
+#include "d/d_item.h"
+#include "d/d_lib.h"
+#include "d/d_menu_collect.h"
 #include "d/d_menu_fishing.h"
 #include "d/d_menu_insect.h"
 #include "d/d_menu_letter.h"
 #include "d/d_menu_option.h"
 #include "d/d_menu_save.h"
 #include "d/d_menu_skill.h"
+#include "d/d_menu_window.h"
+#include "d/d_meter2_info.h"
 #include "d/d_meter_HIO.h"
 #include "d/d_msg_class.h"
 #include "d/d_msg_object.h"
 #include "d/d_msg_string.h"
 #include "d/d_pane_class.h"
-#include "d/d_item.h"
-#include "d/d_lib.h"
-#include "d/d_meter2_info.h"
-#include <os.h>
-#include <cstring>
+#include "d/d_select_cursor.h"
+#include "dusk/version.hpp"
 #include "m_Do/m_Do_graphic.h"
 #include "m_Do/m_Do_mtx.h"
-#include "JSystem/J2DGraph/J2DAnmLoader.h"
-#include "JSystem/J2DGraph/J2DGrafContext.h"
-#include "d/d_menu_window.h"
-#include "JSystem/J3DGraphBase/J3DMaterial.h"
 
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
+#include "dusk/utilities.hpp"
 #endif
 
 typedef void (dMenu_Collect2D_c::*initFunc)();
@@ -100,11 +102,44 @@ dMenu_Collect2D_c::~dMenu_Collect2D_c() {
 }
 
 #if TARGET_PC
+static dusk::utils::PaneCache mpScreenPanes[] = {
+    {MULTI_CHAR('sa_tex_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('op_tex_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('heart_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('wolf_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('item_0_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('item_1_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('item_2_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fish_3_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('lett_4_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('maki_5_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fuku_n0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fuku_n1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('fuku_n2'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('tate_n0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('tate_n1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('ken_n0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('ken_n1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('kabu_6n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('t_t00'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('f_t00'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('itemn_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('infotxtn'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('sa_op_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('title_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('menu_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('w_er_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('center_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('info_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('lavel_n'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('modelbgn'), 0.0f, 0.0f, false},
+};
+
 void dMenu_Collect2D_c::menuCollectWide() {
     static bool cachedPanes = false;
     // Get pre-scale values for each pane
     if (!cachedPanes) {
-        for (PaneCache& entry : mpScreenPanes) {
+        for (dusk::utils::PaneCache& entry : mpScreenPanes) {
             J2DPane* pane = mpScreen->search(entry.tag);
             if (!entry.cached) {
                 entry.origTransX = pane->getTranslateX();
@@ -118,7 +153,7 @@ void dMenu_Collect2D_c::menuCollectWide() {
     // Reset all panes
     mpScreen->scale(1.0f, 1.0f);
     mpScreen->translate(0.0f, 0.0f);
-    for (PaneCache& entry : mpScreenPanes) {
+    for (dusk::utils::PaneCache& entry : mpScreenPanes) {
         J2DPane* pane = mpScreen->search(entry.tag);
         pane->scale(1.0f, 1.0f);
         pane->translate(entry.origTransX, entry.origTransY);
@@ -438,7 +473,21 @@ void dMenu_Collect2D_c::screenSet() {
     static const u64 text_a_tag[5] = {MULTI_CHAR('atext1_1'), MULTI_CHAR('atext1_2'), MULTI_CHAR('atext1_3'), MULTI_CHAR('atext1_4'), MULTI_CHAR('atext1_5')};
     static const u64 text_b_tag[5] = {MULTI_CHAR('btext1_1'), MULTI_CHAR('btext1_2'), MULTI_CHAR('btext1_3'), MULTI_CHAR('btext1_4'), MULTI_CHAR('btext1_5')};
 
-#if REGION_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('t_t00')))->setFont(mDoExt_getRubyFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('t_t00')))->setString(0x20, "");
+        dMeter2Info_getStringKanji(
+            0x3E1, static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('t_t00')))->getStringPtr(), NULL);
+        mpScreen->search(MULTI_CHAR('f_t00'))->hide();
+    } else {
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_t00')))->setFont(mDoExt_getRubyFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_t00')))->setString(0x20, "");
+        dMeter2Info_getStringKanji(
+            0x3E1, static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_t00')))->getStringPtr(), NULL);
+        mpScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+#elif REGION_JPN
     static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('t_t00')))->setFont(mDoExt_getRubyFont());
     static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('t_t00')))->setString(0x20, "");
     dMeter2Info_getStringKanji(
@@ -453,7 +502,31 @@ void dMenu_Collect2D_c::screenSet() {
 #endif
 
     for (int i = 0; i < 3; i++) {
-#if REGION_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            static_cast<J2DTextBox*>(mpScreen->search(text_sv[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpScreen->search(text_op[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpScreen->search(text_sv[i]))->setString(0x20, "");
+            static_cast<J2DTextBox*>(mpScreen->search(text_op[i]))->setString(0x20, "");
+            dMeter2Info_getStringKanji(
+                0x60, static_cast<J2DTextBox*>(mpScreen->search(text_sv[i]))->getStringPtr(), NULL);
+            dMeter2Info_getStringKanji(
+                0x5F, static_cast<J2DTextBox*>(mpScreen->search(text_op[i]))->getStringPtr(), NULL);
+            mpScreen->search(ftext_sv[i])->hide();
+            mpScreen->search(ftext_op[i])->hide();
+        } else {
+            static_cast<J2DTextBox*>(mpScreen->search(ftext_sv[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpScreen->search(ftext_op[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpScreen->search(ftext_sv[i]))->setString(0x20, "");
+            static_cast<J2DTextBox*>(mpScreen->search(ftext_op[i]))->setString(0x20, "");
+            dMeter2Info_getStringKanji(
+                0x60, static_cast<J2DTextBox*>(mpScreen->search(ftext_sv[i]))->getStringPtr(), NULL);
+            dMeter2Info_getStringKanji(
+                0x5F, static_cast<J2DTextBox*>(mpScreen->search(ftext_op[i]))->getStringPtr(), NULL);
+            mpScreen->search(text_sv[i])->hide();
+            mpScreen->search(text_op[i])->hide();
+        }
+#elif REGION_JPN
         static_cast<J2DTextBox*>(mpScreen->search(text_sv[i]))->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpScreen->search(text_op[i]))->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpScreen->search(text_sv[i]))->setString(0x20, "");
@@ -487,7 +560,49 @@ void dMenu_Collect2D_c::screenSet() {
         static_cast<J2DTextBox*>(mpScreenIcon->search(text_b_tag[i]))->setString(0x20, "");
     }
 
-#if REGION_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n00')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n01')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n02')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n03')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n00')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n01')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n02')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n03')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text1')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text1')))->setString(0x100, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')))->setString(0x100, "");
+
+        mpScreen->search(MULTI_CHAR('item_n04'))->hide();
+        mpScreen->search(MULTI_CHAR('item_n05'))->hide();
+        mpScreen->search(MULTI_CHAR('item_n06'))->hide();
+        mpScreen->search(MULTI_CHAR('item_n07'))->hide();
+        mpScreen->search(MULTI_CHAR('f_text1'))->hide();
+        mpScreen->search(MULTI_CHAR('f_text0'))->hide();
+    } else {
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n04')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n05')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n06')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n07')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n04')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n05')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n06')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n07')))->setString(0x20, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text1')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')))->setFont(mDoExt_getMesgFont());
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text1')))->setString(0x100, "");
+        static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')))->setString(0x100, "");
+
+        mpScreen->search(MULTI_CHAR('item_n00'))->hide();
+        mpScreen->search(MULTI_CHAR('item_n01'))->hide();
+        mpScreen->search(MULTI_CHAR('item_n02'))->hide();
+        mpScreen->search(MULTI_CHAR('item_n03'))->hide();
+        mpScreen->search(MULTI_CHAR('i_text1'))->hide();
+        mpScreen->search(MULTI_CHAR('i_text0'))->hide();
+    }
+#elif REGION_JPN
     static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n00')))->setFont(mDoExt_getMesgFont());
     static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n01')))->setFont(mDoExt_getMesgFont());
     static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n02')))->setFont(mDoExt_getMesgFont());
@@ -2337,35 +2452,69 @@ void dMenu_Collect2D_c::_draw() {
     mpScreen->draw(0.0f, 0.0f, grafPort);
 
     if (mItemNameString == 0) {
-#if REGION_JPN
+#if TARGET_PC
+        TEXT_SPAN stringPtr1;
+        if (dusk::version::isRegionJpn()) {
+            stringPtr1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text1')))->getStringPtr();
+        } else {
+            stringPtr1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text1')))->getStringPtr();
+        }
+#elif REGION_JPN
         TEXT_SPAN stringPtr1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text1')))->getStringPtr();
 #else
         TEXT_SPAN stringPtr1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text1')))->getStringPtr();
 #endif
         SAFE_STRCPY(stringPtr1, "");
 
-#if REGION_JPN
+#if TARGET_PC
+        TEXT_SPAN stringPtr0;
+        if (dusk::version::isRegionJpn()) {
+            stringPtr0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')))->getStringPtr();
+        } else {
+            stringPtr0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')))->getStringPtr();
+        }
+#elif REGION_JPN
         TEXT_SPAN stringPtr0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')))->getStringPtr();
 #else
         TEXT_SPAN stringPtr0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')))->getStringPtr();
 #endif
         SAFE_STRCPY(stringPtr0, "");
     } else {
-#if REGION_JPN
+#if TARGET_PC
+        J2DTextBox* textBox1;
+        if (dusk::version::isRegionJpn()) {
+            textBox1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text1')));
+        } else {
+            textBox1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text1')));
+        }
+#elif REGION_JPN
         J2DTextBox* textBox1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text1')));
 #else
         J2DTextBox* textBox1 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text1')));
 #endif
         mpString->getString(mItemNameString, textBox1, NULL, NULL, NULL, 0);
 
-#if REGION_JPN
+#if TARGET_PC
+        J2DTextBox* textBox0;
+        if (dusk::version::isRegionJpn()) {
+            textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')));
+        } else {
+            textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')));
+        }
+#elif REGION_JPN
         J2DTextBox* textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')));
 #else
         J2DTextBox* textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')));
 #endif
         mpString->getString(mItemNameString, textBox0, NULL, NULL, NULL, 0);
 
-#if REGION_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')));
+        } else {
+            textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')));
+        }
+#elif REGION_JPN
         textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('i_text0')));
 #else
         textBox0 = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('f_text0')));
@@ -2448,7 +2597,29 @@ void dMenu_Collect2D_c::setItemNameString(u8 param_0, u8 param_1) {
         if (uVar6 == 0) {
             setItemNameStringNull();
         } else {
-#if REGION_JPN
+#if TARGET_PC
+            if (dusk::version::isRegionJpn()) {
+                TEXT_SPAN stringPtr =
+                static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n00')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+                stringPtr = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n01')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+                stringPtr = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n02')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+                stringPtr = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n03')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+            } else {
+                TEXT_SPAN stringPtr =
+                static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n04')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+                stringPtr = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n05')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+                stringPtr = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n06')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+                stringPtr = static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n07')))->getStringPtr();
+                dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
+            }
+#elif REGION_JPN
             TEXT_SPAN stringPtr =
                 static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('item_n00')))->getStringPtr();
             dMeter2Info_getStringKanji(uVar6, stringPtr, NULL);
@@ -2475,7 +2646,26 @@ void dMenu_Collect2D_c::setItemNameString(u8 param_0, u8 param_1) {
 
 void dMenu_Collect2D_c::setItemNameStringNull() {
     mItemNameString = 0;
-#if REGION_JPN
+#if TARGET_PC
+    J2DTextBox* textBox;
+    if (dusk::version::isRegionJpn()) {
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n00'));
+        SAFE_STRCPY(textBox->getStringPtr(), "");
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n01'));
+        SAFE_STRCPY(textBox->getStringPtr(), "");
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n02'));
+        SAFE_STRCPY(textBox->getStringPtr(), "");
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n03'));
+    } else {
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n04'));
+        SAFE_STRCPY(textBox->getStringPtr(), "");
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n05'));
+        SAFE_STRCPY(textBox->getStringPtr(), "");
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n06'));
+        SAFE_STRCPY(textBox->getStringPtr(), "");
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n07'));
+    }
+#elif REGION_JPN
     J2DTextBox* textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n00'));
     SAFE_STRCPY(textBox->getStringPtr(), "");
     textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('item_n01'));
@@ -2862,7 +3052,7 @@ u8 dMenu_Collect3D_c::getMaskMdlVisible() {
     return 2;
 }
 
-f32 dMenu_Collect3D_c::mViewOffsetY = -100.0f;
+DUSK_GAME_DATA f32 dMenu_Collect3D_c::mViewOffsetY = -100.0f;
 
 void dMenu_Collect3D_c::setupItem3D(Mtx param_0) {
     GXSetViewport(0.0f, mViewOffsetY, FB_WIDTH, FB_HEIGHT, 0.0f, 1.0f);
diff --git a/src/d/d_menu_dmap.cpp b/src/d/d_menu_dmap.cpp
index ec046959d6..f8514e3817 100644
--- a/src/d/d_menu_dmap.cpp
+++ b/src/d/d_menu_dmap.cpp
@@ -21,12 +21,16 @@
 #include "d/d_msg_string.h"
 #include "d/d_meter_haihai.h"
 #include "d/d_menu_window.h"
-#include "dusk/settings.h"
 #include "f_op/f_op_msg_mng.h"
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/settings.h"
+#include "dusk/version.hpp"
+#include "helpers/string.hpp"
+#endif
 
 #if (PLATFORM_WII || PLATFORM_SHIELD)
 #define POINTER_OPT dComIfGs_getOptPointer()
@@ -300,6 +304,16 @@ void dMenu_DmapBg_c::buttonIconScreenInit() {
     static u64 const cont_bt[5] = {MULTI_CHAR('cont_bt'), MULTI_CHAR('cont_bt1'), MULTI_CHAR('cont_bt2'), MULTI_CHAR('cont_bt3'), MULTI_CHAR('cont_bt4')};
     static u64 const font_at[5] = {MULTI_CHAR('font_at'), MULTI_CHAR('font_at1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4')};
     static u64 const font_bt[5] = {MULTI_CHAR('font_bt'), MULTI_CHAR('font_bt1'), MULTI_CHAR('font_bt2'), MULTI_CHAR('font_bt3'), MULTI_CHAR('font_bt4')};
+
+    #if TARGET_PC
+    static u64 const c_tag_jpn[2] = {
+        MULTI_CHAR('c_text_s'), MULTI_CHAR('c_text')
+    };
+
+    static u64 const c_tag[2] = {
+        MULTI_CHAR('f_text_s'), MULTI_CHAR('f_text')
+    };
+    #else
     static u64 const c_tag[2] = {
         #if VERSION == VERSION_GCN_JPN
         MULTI_CHAR('c_text_s'), MULTI_CHAR('c_text')
@@ -307,6 +321,7 @@ void dMenu_DmapBg_c::buttonIconScreenInit() {
         MULTI_CHAR('f_text_s'), MULTI_CHAR('f_text')
         #endif
     };
+    #endif
 
     mButtonScreen = JKR_NEW J2DScreen();
     JUT_ASSERT(916, mButtonScreen != NULL);
@@ -346,7 +361,25 @@ void dMenu_DmapBg_c::buttonIconScreenInit() {
     mpJButton = NULL;
 
     for (int i = 0; i < 5; i++) {
-        #if VERSION == VERSION_GCN_JPN
+        #if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            ((J2DTextBox*)mButtonScreen->search(cont_at[i]))->setFont(mDoExt_getMesgFont());
+            ((J2DTextBox*)mButtonScreen->search(cont_bt[i]))->setFont(mDoExt_getMesgFont());
+            ((J2DTextBox*)mButtonScreen->search(cont_at[i]))->setString(32, "");
+            ((J2DTextBox*)mButtonScreen->search(cont_bt[i]))->setString(32, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                ((J2DTextBox*)mButtonScreen->search(font_at[i]))->hide();
+                ((J2DTextBox*)mButtonScreen->search(font_bt[i]))->hide();
+            }
+        } else {
+            ((J2DTextBox*)mButtonScreen->search(font_at[i]))->setFont(mDoExt_getMesgFont());
+            ((J2DTextBox*)mButtonScreen->search(font_bt[i]))->setFont(mDoExt_getMesgFont());
+            ((J2DTextBox*)mButtonScreen->search(font_at[i]))->setString(32, "");
+            ((J2DTextBox*)mButtonScreen->search(font_bt[i]))->setString(32, "");
+            ((J2DTextBox*)mButtonScreen->search(cont_at[i]))->hide();
+            ((J2DTextBox*)mButtonScreen->search(cont_bt[i]))->hide();
+        }
+        #elif VERSION == VERSION_GCN_JPN
         ((J2DTextBox*)mButtonScreen->search(cont_at[i]))->setFont(mDoExt_getMesgFont());
         ((J2DTextBox*)mButtonScreen->search(cont_bt[i]))->setFont(mDoExt_getMesgFont());
         ((J2DTextBox*)mButtonScreen->search(cont_at[i]))->setString(32, "");
@@ -368,7 +401,7 @@ void dMenu_DmapBg_c::buttonIconScreenInit() {
 
     J2DTextBox* textBox;
     for (int i = 0; i < 2; i++) {
-        textBox = ((J2DTextBox*)mButtonScreen->search(c_tag[i]));
+        textBox = (J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? c_tag_jpn[i] : c_tag[i], c_tag[i]));
         textBox->setFont(mDoExt_getMesgFont());
         textBox->setString(32, "");
     }
@@ -385,6 +418,14 @@ void dMenu_DmapBg_c::buttonIconScreenInit() {
 }
 
 void dMenu_DmapBg_c::setAButtonString(u32 i_msgNo) {
+#if TARGET_PC
+    static u64 const cont_at_jpn[5] = {
+        MULTI_CHAR('cont_at'), MULTI_CHAR('cont_at1'), MULTI_CHAR('cont_at2'), MULTI_CHAR('cont_at3'), MULTI_CHAR('cont_at4')
+    };
+    static u64 const cont_at[5] = {
+        MULTI_CHAR('font_at'), MULTI_CHAR('font_at1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4')
+    };
+#else
     static u64 const cont_at[5] = {
         #if VERSION == VERSION_GCN_JPN
         MULTI_CHAR('cont_at'), MULTI_CHAR('cont_at1'), MULTI_CHAR('cont_at2'), MULTI_CHAR('cont_at3'), MULTI_CHAR('cont_at4')
@@ -392,16 +433,26 @@ void dMenu_DmapBg_c::setAButtonString(u32 i_msgNo) {
         MULTI_CHAR('font_at'), MULTI_CHAR('font_at1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4')
         #endif
     };
+#endif
+
     for (int i = 0; i < 5; i++) {
         if (i_msgNo == 0) {
-            SAFE_STRCPY(((J2DTextBox*)mButtonScreen->search(cont_at[i]))->getStringPtr(), "");
+            SAFE_STRCPY(((J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? cont_at_jpn[i] : cont_at[i], cont_at[i])))->getStringPtr(), "");
         } else {
-            dMeter2Info_getStringKanji(i_msgNo, ((J2DTextBox*)mButtonScreen->search(cont_at[i]))->getStringPtr(), NULL);
+            dMeter2Info_getStringKanji(i_msgNo, ((J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? cont_at_jpn[i] : cont_at[i], cont_at[i])))->getStringPtr(), NULL);
         }
     }
 }
 
 void dMenu_DmapBg_c::setBButtonString(u32 i_msgNo) {
+#if TARGET_PC
+    static u64 const cont_bt_jpn[5] = {
+        MULTI_CHAR('cont_bt'), MULTI_CHAR('cont_bt1'), MULTI_CHAR('cont_bt2'), MULTI_CHAR('cont_bt3'), MULTI_CHAR('cont_bt4')
+    };
+    static u64 const cont_bt[5] = {
+        MULTI_CHAR('font_bt'), MULTI_CHAR('font_bt1'), MULTI_CHAR('font_bt2'), MULTI_CHAR('font_bt3'), MULTI_CHAR('font_bt4')
+    };
+#else
     static u64 const cont_bt[5] = {
         #if VERSION == VERSION_GCN_JPN
         MULTI_CHAR('cont_bt'), MULTI_CHAR('cont_bt1'), MULTI_CHAR('cont_bt2'), MULTI_CHAR('cont_bt3'), MULTI_CHAR('cont_bt4')
@@ -409,11 +460,13 @@ void dMenu_DmapBg_c::setBButtonString(u32 i_msgNo) {
         MULTI_CHAR('font_bt'), MULTI_CHAR('font_bt1'), MULTI_CHAR('font_bt2'), MULTI_CHAR('font_bt3'), MULTI_CHAR('font_bt4')
         #endif
     };
+#endif
+
     for (int i = 0; i < 5; i++) {
         if (i_msgNo == 0) {
-            SAFE_STRCPY(((J2DTextBox*)mButtonScreen->search(cont_bt[i]))->getStringPtr(), "");
+            SAFE_STRCPY(((J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? cont_bt_jpn[i] : cont_bt[i], cont_bt[i])))->getStringPtr(), "");
         } else {
-            dMeter2Info_getStringKanji(i_msgNo, ((J2DTextBox*)mButtonScreen->search(cont_bt[i]))->getStringPtr(), NULL);
+            dMeter2Info_getStringKanji(i_msgNo, ((J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? cont_bt_jpn[i] : cont_bt[i], cont_bt[i])))->getStringPtr(), NULL);
         }
     }
 }
@@ -422,9 +475,17 @@ static f32 player_px;
 
 static f32 player_py;
 
-dMenu_Dmap_c* dMenu_Dmap_c::myclass;
+DUSK_GAME_DATA dMenu_Dmap_c* dMenu_Dmap_c::myclass;
 
 void dMenu_DmapBg_c::setCButtonString(u32 i_msgNo) {
+#if TARGET_PC
+    static u64 const c_tag_jpn[2] = {
+        MULTI_CHAR('c_text_s'), MULTI_CHAR('c_text')
+    };
+    static u64 const c_tag[2] = {
+        MULTI_CHAR('f_text_s'), MULTI_CHAR('f_text')
+    };
+#else
     static u64 const c_tag[2] = {
         #if VERSION == VERSION_GCN_JPN
         MULTI_CHAR('c_text_s'), MULTI_CHAR('c_text')
@@ -432,6 +493,7 @@ void dMenu_DmapBg_c::setCButtonString(u32 i_msgNo) {
         MULTI_CHAR('f_text_s'), MULTI_CHAR('f_text')
         #endif
     };
+#endif
     int i;
 
     u32 msgNo;
@@ -443,12 +505,12 @@ void dMenu_DmapBg_c::setCButtonString(u32 i_msgNo) {
 
     if (msgNo == 0) {
         for (i = 0; i < 2; i++) {
-            SAFE_STRCPY(((J2DTextBox*)mButtonScreen->search(c_tag[i]))->getStringPtr(), "");
+            SAFE_STRCPY(((J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? c_tag_jpn[i] : c_tag[i], c_tag[i])))->getStringPtr(), "");
         }
         mpCButton->setAlphaRate(0.5f);
     } else {
         for (i = 0; i < 2; i++) {
-            dMeter2Info_getStringKanji(msgNo, ((J2DTextBox*)mButtonScreen->search(c_tag[i]))->getStringPtr(), NULL);
+            dMeter2Info_getStringKanji(msgNo, ((J2DTextBox*)mButtonScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? c_tag_jpn[i] : c_tag[i], c_tag[i])))->getStringPtr(), NULL);
         }
         mpCButton->setAlphaRate(1.0f);
     }
@@ -507,7 +569,16 @@ void dMenu_DmapBg_c::baseScreenInit() {
     mpDrawCursor->setAlphaRate(1.0f);
     mpDrawCursor->setParam(0.95f, 0.9f, 0.1f, 0.6f, 0.5f);
 
-    #if VERSION == VERSION_GCN_JPN
+    #if TARGET_PC
+    J2DTextBox* uVar9;
+    if (dusk::version::isRegionJpn()) {
+        uVar9 = (J2DTextBox*)mBaseScreen->search(MULTI_CHAR('t_t00'));
+        mBaseScreen->search(MULTI_CHAR('f_t_00'))->hide();
+    } else {
+        uVar9 = (J2DTextBox*)mBaseScreen->search(MULTI_CHAR('f_t_00'));
+        mBaseScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+    #elif VERSION == VERSION_GCN_JPN
     J2DTextBox* uVar9 = (J2DTextBox*)mBaseScreen->search(MULTI_CHAR('t_t00'));
     mBaseScreen->search(MULTI_CHAR('f_t_00'))->hide();
     #else
@@ -537,7 +608,12 @@ void dMenu_DmapBg_c::setFloorMessage() {
         0x036E, 0x036F, 0x03DC, 0x03DD, 0x03D9, 0x03D8,
     };
 
-    #if VERSION == VERSION_GCN_JPN
+    #if TARGET_PC
+    u64 tag0 = dusk::version::isRegionJpn() ? MULTI_CHAR('ffoor0_0') : MULTI_CHAR('floor0_0');
+    #define FLOOR_TAG(A, B) (tag0 | (A<<16) | (B))
+    u64 tag1 = dusk::version::isRegionJpn() ? MULTI_CHAR('floor0_0') : MULTI_CHAR('ffoor0_0');
+    #define FFOOR_TAG(A, B) (tag1 | (A<<16) | (B))
+    #elif VERSION == VERSION_GCN_JPN
     #define FLOOR_TAG(A, B) (MULTI_CHAR('ffoor0_0') | (A<<16) | (B))
     #define FFOOR_TAG(A, B) (MULTI_CHAR('floor0_0') | (A<<16) | (B))
     #else
@@ -904,8 +980,10 @@ void dMenu_DmapBg_c::dMapBgWide() {
     mButtonScreen->search(MULTI_CHAR('c_btn'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
     mButtonScreen->search(MULTI_CHAR('c_text_s'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
     mButtonScreen->search(MULTI_CHAR('c_text'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
-    mButtonScreen->search(MULTI_CHAR('f_text_s'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
-    mButtonScreen->search(MULTI_CHAR('f_text'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+        mButtonScreen->search(MULTI_CHAR('f_text_s'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+        mButtonScreen->search(MULTI_CHAR('f_text'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
+    }
 
     // Decorations
     mButtonScreen->search(MULTI_CHAR('kazari_n'))->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
@@ -1034,7 +1112,7 @@ void dMenu_DmapBg_c::draw() {
             -35.0f + (local_224.x - local_218.x),
             -35.0f + (local_224.y - local_218.y));
 #if TARGET_PC
-        if (!dusk::frame_interp::is_enabled()) {
+        if (!dusk::interp::is_enabled()) {
             field_0xdda = 0;
         }
 #else
@@ -2696,7 +2774,7 @@ void dMenu_Dmap_c::zoomIn_proc() {
 
 void dMenu_Dmap_c::zoomOut_init_proc() {
 #if TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
+    if (dusk::interp::is_enabled()) {
         mpDrawBg->resetScrollArrowMask();
     }
 #endif
diff --git a/src/d/d_menu_dmap_map.cpp b/src/d/d_menu_dmap_map.cpp
index e3239d3678..b0be1dbf4b 100644
--- a/src/d/d_menu_dmap_map.cpp
+++ b/src/d/d_menu_dmap_map.cpp
@@ -11,12 +11,13 @@
 #include "d/d_menu_dmap_map.h"
 #include "f_op/f_op_msg_mng.h"
 #include "m_Do/m_Do_graphic.h"
+
 #if TARGET_PC
 #include <dolphin/gx/GXExtra.h>
 #endif
 
 struct dMdm_HIO_prm_res_dst_s {
-    static void* m_res;
+    static DUSK_GAME_DATA void* m_res;
 };
 
 bool renderingDmap_c::hasMap() const {
@@ -172,7 +173,7 @@ int renderingDmap_c::getLineWidth(int param_0) {
     return var_r31;
 }
 
-static u32 const l_paletteDmap_m[60] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u32 const l_paletteDmap_m[60] = {
     0x00000000,
     0x00000000,
     0x80008000,
@@ -288,7 +289,7 @@ void renderingDmap_c::afterDrawPath() {
     renderingPlusDoor_c::afterDrawPath();
 }
 
-void* dMdm_HIO_prm_res_dst_s::m_res;
+DUSK_GAME_DATA void* dMdm_HIO_prm_res_dst_s::m_res;
 
 void dMenu_DmapMap_c::_create(u16 param_0, u16 param_1, u16 param_2, u16 param_3,
                               void* res) {
@@ -680,7 +681,7 @@ f32 dMenu_DmapMapCtrl_c::getZoomCmPerPixel() {
     return var_f29;
 }
 
-static u32 l_data[61] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u32 l_data[61] = {
     0x80008000,
     0x80008000,
     0x00000000,
@@ -939,13 +940,13 @@ void dMenu_StageMapCtrl_c::_create(u16 param_0, u16 param_1, u16 param_2, u16 pa
     _create(param_0, param_1, param_2, param_3, var_r31, param_4);
 }
 
-f32 dMenu_StageMapCtrl_c::m_zoomCenterMinX;
+DUSK_GAME_DATA f32 dMenu_StageMapCtrl_c::m_zoomCenterMinX;
 
-f32 dMenu_StageMapCtrl_c::m_zoomCenterMaxX;
+DUSK_GAME_DATA f32 dMenu_StageMapCtrl_c::m_zoomCenterMaxX;
 
-f32 dMenu_StageMapCtrl_c::m_zoomCenterMinZ;
+DUSK_GAME_DATA f32 dMenu_StageMapCtrl_c::m_zoomCenterMinZ;
 
-f32 dMenu_StageMapCtrl_c::m_zoomCenterMaxZ;
+DUSK_GAME_DATA f32 dMenu_StageMapCtrl_c::m_zoomCenterMaxZ;
 
 void dMenu_StageMapCtrl_c::_create(u16 width, u16 height, u16 param_2, u16 param_3,
                                    s8 param_4, void* param_5) {
diff --git a/src/d/d_menu_fishing.cpp b/src/d/d_menu_fishing.cpp
index 6a3d0aefe8..84e62b2385 100644
--- a/src/d/d_menu_fishing.cpp
+++ b/src/d/d_menu_fishing.cpp
@@ -16,16 +16,18 @@
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
 #include "dusk/version.hpp"
+#include "helpers/string.hpp"
+#endif
 
 typedef void (dMenu_Fishing_c::*initFunc)();
-initFunc map_init_process[] = {
+DUSK_GAME_DATA initFunc map_init_process[] = {
     &dMenu_Fishing_c::wait_init,
 };
 
 typedef void (dMenu_Fishing_c::*moveFunc)();
-moveFunc map_move_process[] = {
+DUSK_GAME_DATA moveFunc map_move_process[] = {
     &dMenu_Fishing_c::wait_move,
 };
 
@@ -305,7 +307,16 @@ void dMenu_Fishing_c::screenSetBase() {
     mpFishInfoParent[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('info_blu'), 0, NULL);
     mpFishInfoParent[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('info_red'), 0, NULL);
 
-    #if (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
+    #if TARGET_PC
+    J2DTextBox* textBox;
+    if (dusk::version::isRegionJpn()) {
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('t_t00'));
+        mpScreen->search(MULTI_CHAR('f_t00'))->hide();
+    } else {
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('f_t00'));
+        mpScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+    #elif (VERSION == VERSION_GCN_JPN) || (VERSION == VERSION_WII_JPN)
     J2DTextBox* textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('t_t00'));
     mpScreen->search(MULTI_CHAR('f_t00'))->hide();
     #else
@@ -334,7 +345,9 @@ void dMenu_Fishing_c::screenSetBase() {
         field_0x19c[1][i]->setString(0x20, "");
 
         mpFishNameString[i] = (J2DTextBox*)mpScreen->search(name_0[i]);
+        IF_DUSK_BLOCK(dusk::version::isGcn())
         mpScreen->search(fname_0[i])->hide();
+        IF_DUSK_BLOCK_END
         mpFishNameString[i]->setFont(mDoExt_getSubFont());
         mpFishNameString[i]->setString(0x20, "");
         dMeter2Info_getStringKanji(name_id[i], mpFishNameString[i]->getStringPtr(), NULL);
diff --git a/src/d/d_menu_fmap.cpp b/src/d/d_menu_fmap.cpp
index 64cd70cc0f..57c329a61f 100644
--- a/src/d/d_menu_fmap.cpp
+++ b/src/d/d_menu_fmap.cpp
@@ -1,29 +1,34 @@
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include <cstdio>
-#include <cstring>
+#include "d/d_menu_fmap.h"
+#include "SSystem/SComponent/c_math.h"
 #include "JSystem/JKernel/JKRAramArchive.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JKernel/JKRMemArchive.h"
-#include "SSystem/SComponent/c_math.h"
-#include "d/actor/d_a_midna.h"
-#include "d/actor/d_a_player.h"
+#include <cstdio>
+#include <cstring>
+#include "f_op/f_op_msg_mng.h"
 #include "d/d_com_inf_game.h"
 #include "d/d_lib.h"
-#include "d/d_menu_fmap.h"
 #include "d/d_menu_fmap2D.h"
 #include "d/d_menu_fmap_map.h"
 #include "d/d_menu_window.h"
-#include "d/d_meter2_draw.h"
-#include "d/d_meter2_info.h"
 #include "d/d_meter_HIO.h"
 #include "d/d_meter_map.h"
+#include "d/d_meter2_draw.h"
+#include "d/d_meter2_info.h"
 #include "d/d_msg_object.h"
 #include "d/d_msg_scrn_explain.h"
 #include "d/d_stage.h"
+#include "d/actor/d_a_player.h"
+#include "d/actor/d_a_midna.h"
+
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/memory.h"
-#include "dusk/string.hpp"
-#include "f_op/f_op_msg_mng.h"
+#include "dusk/version.hpp"
+#include "helpers/string.hpp"
+#endif
 
 static dMf_HIO_c g_fmHIO;
 
@@ -93,7 +98,7 @@ static dMenu_Fmap_c::process move_process[30] = {
     &dMenu_Fmap_c::howl_demo3_move,
 };
 
-dMf_HIO_c* dMf_HIO_c::mMySelfPointer;
+DUSK_GAME_DATA dMf_HIO_c* dMf_HIO_c::mMySelfPointer;
 
 dMf_HIO_c::dMf_HIO_c() {
     mMySelfPointer = this;
@@ -136,7 +141,7 @@ const char* dMenuFmap_getStartStageName(void* i_fieldData) {
     return dComIfGp_getStartStageName();
 }
 
-dMenu_Fmap_c* dMenu_Fmap_c::MyClass;
+DUSK_GAME_DATA dMenu_Fmap_c* dMenu_Fmap_c::MyClass;
 
 dMenu_Fmap_c::dMenu_Fmap_c(JKRExpHeap* i_heap, STControl* i_stick, CSTControl* i_cstick,
                            u8 i_process, u8 i_regionCursor, u8 i_stageCursor, f32 i_stageTransX,
@@ -778,7 +783,6 @@ void dMenu_Fmap_c::all_map_proc() {
             {
                 setAreaName(mTitleName[mpDraw2DBack->getSelectRegion()]);
                 mpDraw2DBack->setSpotCursor(0);
-
             } else {
                 setAreaNameZero();
             }
@@ -1148,7 +1152,7 @@ void dMenu_Fmap_c::zoom_spot_to_region_init() {
     field_0x1ec = 1.0f;
 #if TARGET_PC
     // Frame interp note: field_0x122d used to be set every draw, causing flickering. Do it here instead.
-    if (dusk::frame_interp::is_enabled()) {
+    if (dusk::interp::is_enabled()) {
         mpDraw2DBack->resetScrollArrowMask();
     }
 #endif
@@ -1213,7 +1217,8 @@ void dMenu_Fmap_c::spot_map_proc() {
     {
         mpDraw2DBack->stageMapMove(mpStick, 1, true);
     } else if (dMw_Z_TRIGGER() && mpDraw2DTop->isWarpAccept()) {
-#if VERSION >= VERSION_GCN_JPN
+#if TARGET_PC || VERSION >= VERSION_GCN_JPN
+        IF_DUSK_BLOCK(dusk::version::isRegionJpn())
         //! JPN version added a check to make sure if Arbiter's Grounds is cleared that
         //! the Mirror Chamber Statue has been spun before allowing portal warping from the map screen.
         if (dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[265]) && !dComIfGs_isEventBit(dSv_event_flag_c::saveBitLabels[361])) {
@@ -1223,7 +1228,7 @@ void dMenu_Fmap_c::spot_map_proc() {
             mPrevProcessAlt = mProcess;
             setProcess(PROC_PORTAL_WARP_FORBID);
             Z2GetAudioMgr()->seStart(Z2SE_SYS_ERROR, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
-        } else 
+        } IF_DUSK_BLOCK_END else
 #endif
         if (mpDraw2DTop->checkPlayerWarpAccept()) {
             mIsWarpMap = true;
@@ -1267,7 +1272,7 @@ void dMenu_Fmap_c::spot_map_proc() {
         f32 pos_y = mpDraw2DBack->getMapAreaGlobalCenterPosY() - mDoGph_gInf_c::getHeightF() * 0.5f;
         mpMenuFmapMap->getPointStagePathInnerNo(getNowFmapRegionData(), pos_x, pos_y,
                                                 mStayStageNo, &stage_no, &room_no);
-        
+
         if (mStageCursor != stage_no || mResetAreaName) {
             mStageCursor = stage_no;
             mRoomCursor = room_no;
diff --git a/src/d/d_menu_fmap2D.cpp b/src/d/d_menu_fmap2D.cpp
index 8b4e4b59b9..58db87ee68 100644
--- a/src/d/d_menu_fmap2D.cpp
+++ b/src/d/d_menu_fmap2D.cpp
@@ -17,13 +17,13 @@
 #include "d/d_msg_scrn_explain.h"
 #include "m_Do/m_Do_graphic.h"
 #include "d/actor/d_a_midna.h"
-#if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#include "dusk/ui/touch_controls.hpp"
-#endif
 #include <cstring>
 
 #if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/ui/touch_controls.hpp"
+#include "dusk/version.hpp"
+
 void dMenu_Fmap2DBack_c::fMapBackWide() {
     mpBaseScreen->scale(mDoGph_gInf_c::hudAspectScaleUp, 1.0f);
     mpBaseScreen->translate(mDoGph_gInf_c::getSafeMinXF(), 0.0f);
@@ -358,13 +358,10 @@ void dMenu_Fmap2DBack_c::draw() {
         scrollAreaDraw();
     }
 
-#ifdef TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        blinkMove(30);
-        moveLightDropAnime();
-    }
+    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+    blinkMove(30);
+    moveLightDropAnime();
+    IF_DUSK_BLOCK_END
     setCenterPosX(field_0x11dc, 1);
     drawIcon(mTransX, mTransZ, mAlphaRate, field_0xfa8 * mSpotTextureFadeAlpha);
 
@@ -399,16 +396,13 @@ void dMenu_Fmap2DBack_c::draw() {
                         (mArrowPos3DZ + control_ypos + fVar3) - fVar5, &mArrowPos2DX,
                         &mArrowPos2DY);
 
-#ifdef TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            field_0x11e0 -= g_fmapHIO.mCursorSpeed;
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        field_0x11e0 -= g_fmapHIO.mCursorSpeed;
 
-            if (field_0x11e0 < 0.0f) {
-                field_0x11e0 += 360.0f;
-            }
+        if (field_0x11e0 < 0.0f) {
+            field_0x11e0 += 360.0f;
         }
+        IF_DUSK_BLOCK_END
 
         mpPointParent->getPanePtr()->rotate(mpPointParent->getSizeX() / 2.0f,
                                             mpPointParent->getSizeY() / 2.0f, ROTATE_Z,
@@ -448,7 +442,7 @@ void dMenu_Fmap2DBack_c::draw() {
     if (field_0x122d) {
         mpMeterHaihai->drawHaihai(field_0x122d);
 #if TARGET_PC
-        if (!dusk::frame_interp::is_enabled()) {
+        if (!dusk::interp::is_enabled()) {
             field_0x122d = 0;
         }
 #else
@@ -1868,21 +1862,18 @@ void dMenu_Fmap2DBack_c::calcBlink() {
                                  t * (g_fmapHIO.mMapBlink[i + 1].mUnselectedRegion.mBlinkSpeed -
                                       g_fmapHIO.mMapBlink[i].mUnselectedRegion.mBlinkSpeed);
 
-#if TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        field_0x1218++;
-        if (field_0x1218 >= selected_blink_speed) {
-            field_0x1218 = 0;
-        }
-
-        field_0x121a++;
-        if (field_0x121a >= unselected_blink_speed) {
-            field_0x121a = 0;
-        }
+    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+    field_0x1218++;
+    if (field_0x1218 >= selected_blink_speed) {
+        field_0x1218 = 0;
     }
 
+    field_0x121a++;
+    if (field_0x121a >= unselected_blink_speed) {
+        field_0x121a = 0;
+    }
+    IF_DUSK_BLOCK_END
+
     f32 t_selected = 0.0f;
     f32 t_unselected = 0.0f;
 
@@ -2417,7 +2408,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     static const u64 area_name[3] = {MULTI_CHAR('i_name_s'), MULTI_CHAR('i_name') ,MULTI_CHAR('i_name1')};
     static const u64 farea_name[3] = {MULTI_CHAR('f_name_1'), MULTI_CHAR('f_name3'), MULTI_CHAR('f_name2')};
     for (int i = 0; i < 3; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(area_name[i]))->setFont(mDoExt_getRubyFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(area_name[i]))->setString(0x40, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(farea_name[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(farea_name[i]))->setFont(mDoExt_getRubyFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(farea_name[i]))->setString(0x40, "");
+            mpTitleScreen->search(area_name[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(area_name[i]))
             ->setFont(mDoExt_getRubyFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(area_name[i]))->setString(0x40, "");
@@ -2445,7 +2448,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     };
 #endif
     for (int i = 0; i < 7; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(sfont_name[i]))->setFont(mDoExt_getRubyFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(sfont_name[i]))->setString(0x40, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(ffont_name[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(ffont_name[i]))->setFont(mDoExt_getRubyFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(ffont_name[i]))->setString(0x40, "");
+            mpTitleScreen->search(sfont_name[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(sfont_name[i]))
             ->setFont(mDoExt_getRubyFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(sfont_name[i]))->setString(0x40, "");
@@ -2462,7 +2477,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     static const u64 cont_zt[5] = {MULTI_CHAR('cont_zt'), MULTI_CHAR('cont_zt1'), MULTI_CHAR('cont_zt2'), MULTI_CHAR('cont_zt3'), MULTI_CHAR('cont_zt4')};
     static const u64 font_zt[5] = {MULTI_CHAR('font_zt1'), MULTI_CHAR('font_zt2'), MULTI_CHAR('font_zt3'), MULTI_CHAR('font_zt4'), MULTI_CHAR('font_zt5')};
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(cont_zt[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(cont_zt[i]))->setString(0x20, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(font_zt[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(font_zt[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(font_zt[i]))->setString(0x20, "");
+            mpTitleScreen->search(cont_zt[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(cont_zt[i]))
             ->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(cont_zt[i]))->setString(0x20, "");
@@ -2483,7 +2510,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     static const u64 font_bt[5] = {MULTI_CHAR('font_bt1'), MULTI_CHAR('font_bt2'), MULTI_CHAR('font_bt3'), MULTI_CHAR('font_bt4'), MULTI_CHAR('font_bt5')};
 #endif
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(cont_bt[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(cont_bt[i]))->setString(0x20, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(font_bt[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(font_bt[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(font_bt[i]))->setString(0x20, "");
+            mpTitleScreen->search(cont_bt[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(cont_bt[i]))
             ->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(cont_bt[i]))->setString(0x20, "");
@@ -2500,7 +2539,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     static const u64 cont_at[5] = {MULTI_CHAR('cont_at'), MULTI_CHAR('cont_at1'), MULTI_CHAR('cont_at2'), MULTI_CHAR('cont_at3'), MULTI_CHAR('cont_at4')};
     static const u64 font_at[5] = {MULTI_CHAR('font_at1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4'), MULTI_CHAR('font_at5')};
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(cont_at[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(cont_at[i]))->setString(0x20, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(font_at[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(font_at[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(font_at[i]))->setString(0x20, "");
+            mpTitleScreen->search(cont_at[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(cont_at[i]))
             ->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(cont_at[i]))->setString(0x20, "");
@@ -2518,7 +2569,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     static const u64 juji_c[5] = {MULTI_CHAR('juji_c00'), MULTI_CHAR('juji_c01'), MULTI_CHAR('juji_c02'), MULTI_CHAR('juji_c03'), MULTI_CHAR('juji_c04')};
     static const u64 fuji_c[5] = {MULTI_CHAR('fuji_c00'), MULTI_CHAR('fuji_c01'), MULTI_CHAR('fuji_c02'), MULTI_CHAR('fuji_c03'), MULTI_CHAR('fuji_c04')};
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]))->setString(0x20, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(fuji_c[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(fuji_c[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(fuji_c[i]))->setString(0x20, "");
+            mpTitleScreen->search(juji_c[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]))
             ->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]))->setString(0x20, "");
@@ -2535,7 +2598,19 @@ dMenu_Fmap2DTop_c::dMenu_Fmap2DTop_c(JKRExpHeap* i_heap, STControl* i_stick) {
     static const u64 ast_c[5] = {MULTI_CHAR('ast_00'), MULTI_CHAR('ast_01'), MULTI_CHAR('ast_02'), MULTI_CHAR('ast_03'), MULTI_CHAR('ast_04')};
     static const u64 fst_c[5] = {MULTI_CHAR('fst_00'), MULTI_CHAR('fst_01'), MULTI_CHAR('fst_02'), MULTI_CHAR('fst_03'), MULTI_CHAR('fst_04')};
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]))->setString(0x20, "");
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTitleScreen->search(fst_c[i])->hide();
+            }
+        } else {
+            static_cast<J2DTextBox*>(mpTitleScreen->search(fst_c[i]))->setFont(mDoExt_getMesgFont());
+            static_cast<J2DTextBox*>(mpTitleScreen->search(fst_c[i]))->setString(0x20, "");
+            mpTitleScreen->search(ast_c[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]))
             ->setFont(mDoExt_getMesgFont());
         static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]))->setString(0x20, "");
@@ -2784,7 +2859,15 @@ void dMenu_Fmap2DTop_c::setMoyaAlpha(u8 i_alpha) {
 }
 
 void dMenu_Fmap2DTop_c::setTitleNameString(u32 param_0) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 sfont_name[7] = {
+        MULTI_CHAR('sfont00'), MULTI_CHAR('sfontl0'), MULTI_CHAR('sfontl1'), MULTI_CHAR('sfontl2'), MULTI_CHAR('sfontb0'), MULTI_CHAR('sfontb1'), MULTI_CHAR('sfontb2')
+    };
+    static const u64 ffont_name[7] = {
+        MULTI_CHAR('ffont00'), MULTI_CHAR('ffontl0'), MULTI_CHAR('ffontl1'), MULTI_CHAR('ffontl2'), MULTI_CHAR('ffontb0'), MULTI_CHAR('ffontb3'), MULTI_CHAR('ffontb4')
+    };
+    auto setTitleNameString_font_name = dusk::version::isJpnOrLessThanWiiJpn() ? sfont_name : ffont_name;
+#elif VERSION == VERSION_GCN_JPN
     static const u64 sfont_name[7] = {
         MULTI_CHAR('sfont00'), MULTI_CHAR('sfontl0'), MULTI_CHAR('sfontl1'), MULTI_CHAR('sfontl2'), MULTI_CHAR('sfontb0'), MULTI_CHAR('sfontb1'), MULTI_CHAR('sfontb2')
     };
@@ -2802,21 +2885,19 @@ void dMenu_Fmap2DTop_c::setTitleNameString(u32 param_0) {
 #endif
     for (int i = 0; i < 7; i++) {
         if (param_0 == 0) {
-            SAFE_STRCPY(((J2DTextBox*)(mpTitleScreen->search(setTitleNameString_font_name[i])))
-                       ->getStringPtr(),
-                   "");
+            SAFE_STRCPY(((J2DTextBox*)(mpTitleScreen->search(setTitleNameString_font_name[i])))->getStringPtr(), "");
         } else {
-            dMeter2Info_getStringKanji(
-                param_0,
-                ((J2DTextBox*)(mpTitleScreen->search(setTitleNameString_font_name[i])))
-                    ->getStringPtr(),
-                NULL);
+            dMeter2Info_getStringKanji(param_0, ((J2DTextBox*)(mpTitleScreen->search(setTitleNameString_font_name[i])))->getStringPtr(), NULL);
         }
     }
 }
 
 void dMenu_Fmap2DTop_c::setAreaNameString(u32 param_0) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 iarea_name[3] = {MULTI_CHAR('i_name_s'), MULTI_CHAR('i_name'), MULTI_CHAR('i_name1')};
+    static const u64 farea_name[3] = {MULTI_CHAR('f_name_1'), MULTI_CHAR('f_name3'), MULTI_CHAR('f_name2')};
+    auto setAreaNameString_area_name = dusk::version::isJpnOrLessThanWiiJpn() ? iarea_name : farea_name;
+#elif VERSION == VERSION_GCN_JPN
     static const u64 iarea_name[3] = {MULTI_CHAR('i_name_s'), MULTI_CHAR('i_name'), MULTI_CHAR('i_name1')};
 #define setAreaNameString_area_name iarea_name
 #else
@@ -2825,15 +2906,9 @@ void dMenu_Fmap2DTop_c::setAreaNameString(u32 param_0) {
 #endif
     for (int i = 0; i < 3; i++) {
         if (param_0 == 0) {
-            SAFE_STRCPY(((J2DTextBox*)(mpTitleScreen->search(setAreaNameString_area_name[i])))
-                       ->getStringPtr(),
-                   "");
+            SAFE_STRCPY(((J2DTextBox*)(mpTitleScreen->search(setAreaNameString_area_name[i])))->getStringPtr(), "");
         } else {
-            dMeter2Info_getStringKanji(
-                param_0,
-                ((J2DTextBox*)(mpTitleScreen->search(setAreaNameString_area_name[i])))
-                    ->getStringPtr(),
-                NULL);
+            dMeter2Info_getStringKanji(param_0, ((J2DTextBox*)(mpTitleScreen->search(setAreaNameString_area_name[i])))->getStringPtr(), NULL);
         }
     }
 }
@@ -2849,7 +2924,11 @@ void dMenu_Fmap2DTop_c::setZButtonString(u32 param_0, u8 i_alpha) {
                                          dusk::ui::ControlOverride::Default);
 #endif
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 cont_zt[5] = {MULTI_CHAR('cont_zt'), MULTI_CHAR('cont_zt1'), MULTI_CHAR('cont_zt2'), MULTI_CHAR('cont_zt3'), MULTI_CHAR('cont_zt4')};
+    static const u64 font_zt[5] = {MULTI_CHAR('font_zt1'), MULTI_CHAR('font_zt2'), MULTI_CHAR('font_zt3'), MULTI_CHAR('font_zt4'), MULTI_CHAR('font_zt5')};
+    auto setZButtonString_font_zt = dusk::version::isJpnOrLessThanWiiJpn() ? cont_zt : font_zt;
+#elif VERSION == VERSION_GCN_JPN
     static const u64 cont_zt[5] = {MULTI_CHAR('cont_zt'), MULTI_CHAR('cont_zt1'), MULTI_CHAR('cont_zt2'), MULTI_CHAR('cont_zt3'), MULTI_CHAR('cont_zt4')};
     #define setZButtonString_font_zt cont_zt
 #else
@@ -2864,10 +2943,7 @@ void dMenu_Fmap2DTop_c::setZButtonString(u32 param_0, u8 i_alpha) {
 #endif
     } else {
         for (int i = 0; i < 5; i++) {
-            dMeter2Info_getStringKanji(
-                param_0,
-                ((J2DTextBox*)(mpTitleScreen->search(setZButtonString_font_zt[i])))->getStringPtr(),
-                NULL);
+            dMeter2Info_getStringKanji(param_0, ((J2DTextBox*)(mpTitleScreen->search(setZButtonString_font_zt[i])))->getStringPtr(), NULL);
         }
 
         if (i_alpha == ALPHA_DEFAULT) {
@@ -2883,7 +2959,11 @@ void dMenu_Fmap2DTop_c::setZButtonString(u32 param_0, u8 i_alpha) {
 }
 
 void dMenu_Fmap2DTop_c::setBButtonString(u32 param_0, u8 i_alpha) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 cont_bt[5] = {MULTI_CHAR('cont_bt1'), MULTI_CHAR('cont_bt2'), MULTI_CHAR('cont_bt3'), MULTI_CHAR('cont_bt4'), MULTI_CHAR('cont_bt')};
+    static const u64 font_bt[5] = {MULTI_CHAR('font_bt1'), MULTI_CHAR('font_bt2'), MULTI_CHAR('font_bt3'), MULTI_CHAR('font_bt4'), MULTI_CHAR('font_bt5')};
+    auto setBButtonString_font_bt = dusk::version::isJpnOrLessThanWiiJpn() ? cont_bt : font_bt;
+#elif VERSION == VERSION_GCN_JPN
     static const u64 cont_bt[5] = {MULTI_CHAR('cont_bt1'), MULTI_CHAR('cont_bt2'), MULTI_CHAR('cont_bt3'), MULTI_CHAR('cont_bt4'), MULTI_CHAR('cont_bt')};
 #define setBButtonString_font_bt cont_bt
 #else
@@ -2894,10 +2974,7 @@ void dMenu_Fmap2DTop_c::setBButtonString(u32 param_0, u8 i_alpha) {
         mAlphaButtonB = ALPHA_MIN;
     } else {
         for (int i = 0; i < 5; i++) {
-            dMeter2Info_getStringKanji(
-                param_0,
-                ((J2DTextBox*)(mpTitleScreen->search(setBButtonString_font_bt[i])))->getStringPtr(),
-                NULL);
+            dMeter2Info_getStringKanji(param_0, ((J2DTextBox*)(mpTitleScreen->search(setBButtonString_font_bt[i])))->getStringPtr(), NULL);
         }
 
         if (i_alpha == ALPHA_DEFAULT) {
@@ -2909,7 +2986,11 @@ void dMenu_Fmap2DTop_c::setBButtonString(u32 param_0, u8 i_alpha) {
 }
 
 void dMenu_Fmap2DTop_c::setAButtonString(u32 param_0, u8 i_alpha) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 cont_at[5] = {MULTI_CHAR('cont_at'), MULTI_CHAR('cont_at1'), MULTI_CHAR('cont_at2'), MULTI_CHAR('cont_at3'), MULTI_CHAR('cont_at4')};
+    static const u64 font_at[5] = {MULTI_CHAR('font_at1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4'), MULTI_CHAR('font_at5')};
+    auto setAButtonString_font_at = dusk::version::isJpnOrLessThanWiiJpn() ? cont_at : font_at;
+#elif VERSION == VERSION_GCN_JPN
     static const u64 cont_at[5] = {MULTI_CHAR('cont_at'), MULTI_CHAR('cont_at1'), MULTI_CHAR('cont_at2'), MULTI_CHAR('cont_at3'), MULTI_CHAR('cont_at4')};
 #define setAButtonString_font_at cont_at
 #else
@@ -2920,10 +3001,7 @@ void dMenu_Fmap2DTop_c::setAButtonString(u32 param_0, u8 i_alpha) {
         mAlphaButtonA = ALPHA_MIN;
     } else {
         for (int i = 0; i < 5; i++) {
-            dMeter2Info_getStringKanji(
-                param_0,
-                ((J2DTextBox*)(mpTitleScreen->search(setAButtonString_font_at[i])))->getStringPtr(),
-                NULL);
+            dMeter2Info_getStringKanji(param_0, ((J2DTextBox*)(mpTitleScreen->search(setAButtonString_font_at[i])))->getStringPtr(), NULL);
         }
 
         if (i_alpha == ALPHA_DEFAULT) {
@@ -2936,21 +3014,24 @@ void dMenu_Fmap2DTop_c::setAButtonString(u32 param_0, u8 i_alpha) {
 
 void dMenu_Fmap2DTop_c::setCrossLRString(u32 param_0) {
 #if PLATFORM_GCN || (VERSION == VERSION_SHIELD)
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 juji_c[5] = {MULTI_CHAR('juji_c00'), MULTI_CHAR('juji_c01'), MULTI_CHAR('juji_c02'), MULTI_CHAR('juji_c03'), MULTI_CHAR('juji_c04')};
+    static const u64 fuji_c[5] = {MULTI_CHAR('fuji_c00'), MULTI_CHAR('fuji_c01'), MULTI_CHAR('fuji_c02'), MULTI_CHAR('fuji_c03'), MULTI_CHAR('fuji_c04')};
+#elif VERSION == VERSION_GCN_JPN
     static const u64 juji_c[5] = {MULTI_CHAR('juji_c00'), MULTI_CHAR('juji_c01'), MULTI_CHAR('juji_c02'), MULTI_CHAR('juji_c03'), MULTI_CHAR('juji_c04')};
 #else
     static const u64 juji_c[5] = {MULTI_CHAR('fuji_c00'), MULTI_CHAR('fuji_c01'), MULTI_CHAR('fuji_c02'), MULTI_CHAR('fuji_c03'), MULTI_CHAR('fuji_c04')};
 #endif
     if (param_0 == 0) {
         for (int i = 0; i < 5; i++) {
-            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]));
+            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? juji_c[i] : fuji_c[i], juji_c[i])));
             SAFE_STRCPY(text_box->getStringPtr(), "");
         }
         mpTitleScreen->search(MULTI_CHAR('juy_sha0'))->show();
         mAlphaDpad = 1;
     } else {
         for (int i = 0; i < 5; i++) {
-            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(juji_c[i]));
+            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? juji_c[i] : fuji_c[i], juji_c[i])));
             dMeter2Info_getStringKanji(param_0, text_box->getStringPtr(), NULL);
         }
         mpTitleScreen->search(MULTI_CHAR('juy_sha0'))->show();
@@ -2961,21 +3042,24 @@ void dMenu_Fmap2DTop_c::setCrossLRString(u32 param_0) {
 
 void dMenu_Fmap2DTop_c::set3DStickString(u32 param_0) {
 #if PLATFORM_GCN || (VERSION == VERSION_SHIELD)
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    static const u64 ast_c[5] = {MULTI_CHAR('ast_00'), MULTI_CHAR('ast_01'), MULTI_CHAR('ast_02'), MULTI_CHAR('ast_03'), MULTI_CHAR('ast_04')};
+    static const u64 fst_c[5] = {MULTI_CHAR('fst_00'), MULTI_CHAR('fst_01'), MULTI_CHAR('fst_02'), MULTI_CHAR('fst_03'), MULTI_CHAR('fst_04')};
+#elif VERSION == VERSION_GCN_JPN
     static const u64 ast_c[5] = {MULTI_CHAR('ast_00'), MULTI_CHAR('ast_01'), MULTI_CHAR('ast_02'), MULTI_CHAR('ast_03'), MULTI_CHAR('ast_04')};
 #else
     static const u64 ast_c[5] = {MULTI_CHAR('fst_00'), MULTI_CHAR('fst_01'), MULTI_CHAR('fst_02'), MULTI_CHAR('fst_03'), MULTI_CHAR('fst_04')};
 #endif
     if (param_0 == 0) {
         for (int i = 0; i < 5; i++) {
-            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]));
+            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? ast_c[i] : fst_c[i], ast_c[i])));
             SAFE_STRCPY(text_box->getStringPtr(), "");
         }
         mpTitleScreen->search(MULTI_CHAR('as_sha0'))->show();
         mAlphaAnalogStick = 1;
     } else {
         for (int i = 0; i < 5; i++) {
-            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(ast_c[i]));
+            J2DTextBox* text_box = static_cast<J2DTextBox*>(mpTitleScreen->search(DUSK_IF_ELSE(dusk::version::isJpnOrLessThanWiiJpn() ? ast_c[i] : fst_c[i], ast_c[i])));
             dMeter2Info_getStringKanji(param_0, text_box->getStringPtr(), NULL);
         }
         mpTitleScreen->search(MULTI_CHAR('as_sha0'))->show();
diff --git a/src/d/d_menu_fmap_map.cpp b/src/d/d_menu_fmap_map.cpp
index c500aff0be..8a3c34fbde 100644
--- a/src/d/d_menu_fmap_map.cpp
+++ b/src/d/d_menu_fmap_map.cpp
@@ -8,10 +8,11 @@
 #include "d/d_debug_viewer.h"
 #include "d/d_menu_fmap_map.h"
 #include "m_Do/m_Do_graphic.h"
+#include <cstring>
+
 #if TARGET_PC
 #include <dolphin/gx/GXExtra.h>
 #endif
-#include <cstring>
 
 static u8 twoValueLineInterpolation(u8 i_value1, u8 i_value2, f32 i_param) {
     return (u8)((f32)i_value1 + i_param * ((f32)i_value2 - (f32)i_value1));
@@ -505,7 +506,7 @@ void dMenu_FmapMap_c::_delete() {
     }
 }
 
-const dMfm_HIO_prm_res_src_s dMfm_HIO_prm_res_src_s::m_other = {30};
+DUSK_GAME_DATA const dMfm_HIO_prm_res_src_s dMfm_HIO_prm_res_src_s::m_other = {30};
 
 void dMenu_FmapMap_c::draw() {
     { int unused; }
diff --git a/src/d/d_menu_insect.cpp b/src/d/d_menu_insect.cpp
index aa18407b09..684dd1235c 100644
--- a/src/d/d_menu_insect.cpp
+++ b/src/d/d_menu_insect.cpp
@@ -24,6 +24,7 @@
 
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
+#include "dusk/version.hpp"
 #endif
 
 typedef void (dMenu_Insect_c::*initFunc)();
@@ -535,7 +536,16 @@ void dMenu_Insect_c::screenSetBase() {
             }
         }
     }
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    J2DTextBox* textBox;
+    if (dusk::version::isRegionJpn()) {
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('t_t00'));
+        mpScreen->search(MULTI_CHAR('f_t00'))->hide();
+    } else {
+        textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('f_t00'));
+        mpScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     J2DTextBox* textBox = (J2DTextBox*)mpScreen->search(MULTI_CHAR('t_t00'));
     mpScreen->search(MULTI_CHAR('f_t00'))->hide();
 #else
@@ -558,7 +568,19 @@ void dMenu_Insect_c::screenSetExplain() {
     if (field_0xf6 == 0) {
         mpExpSubWin[1]->hide();
     }
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpInfoText = JKR_NEW CPaneMgr(mpExpScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+        mpExpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        field_0x5c = (J2DTextBox*)mpExpScreen->search(MULTI_CHAR('w_msg_jp'));
+        mpExpScreen->search(MULTI_CHAR('ms_for_2'))->hide();
+    } else {
+        mpInfoText = JKR_NEW CPaneMgr(mpExpScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+        mpExpScreen->search(MULTI_CHAR('n_3line'))->hide();
+        field_0x5c = (J2DTextBox*)mpExpScreen->search(MULTI_CHAR('ms_for_2'));
+        mpExpScreen->search(MULTI_CHAR('w_msg_jp'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpInfoText = JKR_NEW CPaneMgr(mpExpScreen, MULTI_CHAR('mg_3line'), 0, NULL);
     mpExpScreen->search(MULTI_CHAR('n_e4line'))->hide();
     field_0x5c = (J2DTextBox*)mpExpScreen->search(MULTI_CHAR('w_msg_jp'));
diff --git a/src/d/d_menu_item_explain.cpp b/src/d/d_menu_item_explain.cpp
index bebcb2cdb0..e6134e6c8b 100644
--- a/src/d/d_menu_item_explain.cpp
+++ b/src/d/d_menu_item_explain.cpp
@@ -25,6 +25,10 @@
 #include "d/d_msg_scrn_3select.h"
 #include "d/d_msg_scrn_arrow.h"
 
+#if TARGET_PC
+#include "dusk/version.hpp"
+#endif
+
 typedef void (dMenu_ItemExplain_c::*initFunc)();
 static initFunc init_process[] = {
     &dMenu_ItemExplain_c::wait_init,      &dMenu_ItemExplain_c::open_init,
@@ -103,7 +107,16 @@ dMenu_ItemExplain_c::dMenu_ItemExplain_c(JKRExpHeap* i_heap, JKRArchive* i_archi
     mDescAlpha = 0.0f;
     field_0x78 = 0;
     mAlphaRatio = 201.0f;
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpInfoText = JKR_NEW CPaneMgr(mpInfoScreen, MULTI_CHAR('i_text4'), 0, NULL);
+        mpInfoScreen->search(MULTI_CHAR('i_text1'))->hide();
+    } else {
+        mpInfoText = JKR_NEW CPaneMgr(mpInfoScreen, MULTI_CHAR('i_text1'), 0, NULL);
+        mpInfoScreen->search(MULTI_CHAR('i_text4'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpInfoText = JKR_NEW CPaneMgr(mpInfoScreen, MULTI_CHAR('i_text4'), 0, NULL);
     mpInfoScreen->search(MULTI_CHAR('i_text1'))->hide();
 #else
@@ -114,7 +127,15 @@ dMenu_ItemExplain_c::dMenu_ItemExplain_c(JKRExpHeap* i_heap, JKRArchive* i_archi
     ((J2DTextBox*)(mpInfoText->getPanePtr()))->setString(0x200, "");
     mpInfoText->show();
     for (int i = 0; i < 4; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpNameText[i] = JKR_NEW CPaneMgr(mpInfoScreen, name_tag[i], 0, NULL);
+            mpInfoScreen->search(fame_tag[i])->hide();
+        } else {
+            mpNameText[i] = JKR_NEW CPaneMgr(mpInfoScreen, fame_tag[i], 0, NULL);
+            mpInfoScreen->search(name_tag[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpNameText[i] = JKR_NEW CPaneMgr(mpInfoScreen, name_tag[i], 0, NULL);
         mpInfoScreen->search(fame_tag[i])->hide();
 #else
diff --git a/src/d/d_menu_letter.cpp b/src/d/d_menu_letter.cpp
index 3f997bbda5..a1349e9fe5 100644
--- a/src/d/d_menu_letter.cpp
+++ b/src/d/d_menu_letter.cpp
@@ -21,6 +21,7 @@
 #include "dusk/achievements.h"
 #include "dusk/menu_pointer.h"
 #include "dusk/ui/touch_controls.hpp"
+#include "dusk/version.hpp"
 
 static void enable_turn_page_controls(bool enabled) {
     const auto controlOverride =
@@ -30,7 +31,9 @@ static void enable_turn_page_controls(bool enabled) {
 }
 #endif
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+#define D_MENU_LETTER_LINE_MAX (dusk::version::isRegionJpn() ? 9 : 12)
+#elif VERSION == VERSION_GCN_JPN
 #define D_MENU_LETTER_LINE_MAX 9
 #else
 #define D_MENU_LETTER_LINE_MAX 12
@@ -459,7 +462,16 @@ void dMenu_Letter_c::wait_move() {
         }
 
         if (mProcess == 1 || mProcess == 2) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+            J2DTextBox* textBox;
+            if (dusk::version::isRegionJpn()) {
+                textBox = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('t_t00'));
+                mpBaseScreen->search(MULTI_CHAR('f_t_00'))->hide();
+            } else {
+                textBox = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('f_t_00'));
+                mpBaseScreen->search(MULTI_CHAR('t_t00'))->hide();
+            }
+#elif VERSION == VERSION_GCN_JPN
             J2DTextBox* textBox = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('t_t00'));
             mpBaseScreen->search(MULTI_CHAR('f_t_00'))->hide();
 #else
@@ -811,6 +823,15 @@ void dMenu_Letter_c::screenSetMenu() {
     static const u64 tag_frame[6] = {
         MULTI_CHAR('flame_00'), MULTI_CHAR('flame_01'), MULTI_CHAR('flame_02'), MULTI_CHAR('flame_03'), MULTI_CHAR('flame_04'), MULTI_CHAR('flame_05'),
     };
+
+#if TARGET_PC
+    static const u64 tag_menu0_jpn[6] = {
+        MULTI_CHAR('menu_t0'), MULTI_CHAR('menu_t1'), MULTI_CHAR('menu_t2'), MULTI_CHAR('menu_t3'), MULTI_CHAR('menu_t4'), MULTI_CHAR('menu_t5'),
+    };
+    static const u64 tag_menu0[6] = {
+        MULTI_CHAR('fenu_t0'), MULTI_CHAR('fenu_t1'), MULTI_CHAR('fenu_t2'), MULTI_CHAR('fenu_t3'), MULTI_CHAR('fenu_t4'), MULTI_CHAR('fenu_t5'),
+    };
+#else
     static const u64 tag_menu0[6] = {
 #if VERSION == VERSION_GCN_JPN
         MULTI_CHAR('menu_t0'), MULTI_CHAR('menu_t1'), MULTI_CHAR('menu_t2'), MULTI_CHAR('menu_t3'), MULTI_CHAR('menu_t4'), MULTI_CHAR('menu_t5'),
@@ -818,6 +839,16 @@ void dMenu_Letter_c::screenSetMenu() {
         MULTI_CHAR('fenu_t0'), MULTI_CHAR('fenu_t1'), MULTI_CHAR('fenu_t2'), MULTI_CHAR('fenu_t3'), MULTI_CHAR('fenu_t4'), MULTI_CHAR('fenu_t5'),
 #endif
     };
+#endif
+
+#if TARGET_PC
+    static const u64 tag_menu1_jpn[6] = {
+        MULTI_CHAR('menu_f6'), MULTI_CHAR('menu_f7'), MULTI_CHAR('menu_t8'), MULTI_CHAR('menu_t9'), MULTI_CHAR('menu_t10'), MULTI_CHAR('menu_t11'),
+    };
+    static const u64 tag_menu1[6] = {
+        MULTI_CHAR('fenu_t6'), MULTI_CHAR('fenu_t7'), MULTI_CHAR('fenu_t8'), MULTI_CHAR('fenu_t9'), MULTI_CHAR('fenu_t10'), MULTI_CHAR('fenu_t11'),
+    };
+#else
     static const u64 tag_menu1[6] = {
 #if VERSION == VERSION_GCN_JPN
         MULTI_CHAR('menu_f6'), MULTI_CHAR('menu_f7'), MULTI_CHAR('menu_t8'), MULTI_CHAR('menu_t9'), MULTI_CHAR('menu_t10'), MULTI_CHAR('menu_t11'),
@@ -825,6 +856,8 @@ void dMenu_Letter_c::screenSetMenu() {
         MULTI_CHAR('fenu_t6'), MULTI_CHAR('fenu_t7'), MULTI_CHAR('fenu_t8'), MULTI_CHAR('fenu_t9'), MULTI_CHAR('fenu_t10'), MULTI_CHAR('fenu_t11'),
 #endif
     };
+#endif
+
     static const u64 tag_midoku[6] = {
         MULTI_CHAR('midoku_0'), MULTI_CHAR('midoku_1'), MULTI_CHAR('midoku_2'), MULTI_CHAR('midoku_3'), MULTI_CHAR('midoku_4'), MULTI_CHAR('midoku_5'),
     };
@@ -838,7 +871,27 @@ void dMenu_Letter_c::screenSetMenu() {
     JUT_ASSERT(1161, mpParent[0] != NULL);
     mpParent[0]->setAlphaRate(0.0f);
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x124[i][0] = (J2DTextBox*)mpMenuScreen->search(tag_sub0[i]);
+            field_0x124[i][1] = (J2DTextBox*)mpMenuScreen->search(tag_sub1[i]);
+            field_0x124[i][2] = (J2DTextBox*)mpMenuScreen->search(tag_name0[i]);
+            field_0x124[i][3] = (J2DTextBox*)mpMenuScreen->search(tag_name1[i]);
+            mpMenuScreen->search(ftag_sub0[i])->hide();
+            mpMenuScreen->search(ftag_sub1[i])->hide();
+            mpMenuScreen->search(ftag_name0[i])->hide();
+            mpMenuScreen->search(ftag_name1[i])->hide();
+        } else {
+            field_0x124[i][0] = (J2DTextBox*)mpMenuScreen->search(ftag_sub0[i]);
+            field_0x124[i][1] = (J2DTextBox*)mpMenuScreen->search(ftag_sub1[i]);
+            field_0x124[i][2] = (J2DTextBox*)mpMenuScreen->search(ftag_name0[i]);
+            field_0x124[i][3] = (J2DTextBox*)mpMenuScreen->search(ftag_name1[i]);
+            mpMenuScreen->search(tag_sub0[i])->hide();
+            mpMenuScreen->search(tag_sub1[i])->hide();
+            mpMenuScreen->search(tag_name0[i])->hide();
+            mpMenuScreen->search(tag_name1[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x124[i][0] = (J2DTextBox*)mpMenuScreen->search(tag_sub0[i]);
         field_0x124[i][1] = (J2DTextBox*)mpMenuScreen->search(tag_sub1[i]);
         field_0x124[i][2] = (J2DTextBox*)mpMenuScreen->search(tag_name0[i]);
@@ -868,8 +921,8 @@ void dMenu_Letter_c::screenSetMenu() {
     }
     for (int i = 0; i < 6; i++) {
         field_0x34[i][0] = mpMenuScreen->search(tag_frame[i]);
-        field_0x34[i][1] = mpMenuScreen->search(tag_menu0[i]);
-        field_0x34[i][2] = mpMenuScreen->search(tag_menu1[i]);
+        field_0x34[i][1] = mpMenuScreen->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? tag_menu0_jpn[i] : tag_menu0[i], tag_menu0[i]));
+        field_0x34[i][2] = mpMenuScreen->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? tag_menu1_jpn[i] : tag_menu1[i], tag_menu1[i]));
         field_0x34[i][3] = mpMenuScreen->search(tag_letter[i]);
         field_0x34[i][4] = mpMenuScreen->search(tag_midoku[i]);
         if (i < field_0x373) {
@@ -909,7 +962,27 @@ void dMenu_Letter_c::screenSetMenu() {
     mpDMYParent = JKR_NEW CPaneMgr(mpMenuDMYScreen, MULTI_CHAR('n_all'), 2, NULL);
     JUT_ASSERT(1285, mpDMYParent != NULL);
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x184[i][0] = (J2DTextBox*)mpMenuDMYScreen->search(tag_sub0[i]);
+            field_0x184[i][1] = (J2DTextBox*)mpMenuDMYScreen->search(tag_sub1[i]);
+            field_0x184[i][2] = (J2DTextBox*)mpMenuDMYScreen->search(tag_name0[i]);
+            field_0x184[i][3] = (J2DTextBox*)mpMenuDMYScreen->search(tag_name1[i]);
+            mpMenuDMYScreen->search(ftag_sub0[i])->hide();
+            mpMenuDMYScreen->search(ftag_sub1[i])->hide();
+            mpMenuDMYScreen->search(ftag_name0[i])->hide();
+            mpMenuDMYScreen->search(ftag_name1[i])->hide();
+        } else {
+            field_0x184[i][0] = (J2DTextBox*)mpMenuDMYScreen->search(ftag_sub0[i]);
+            field_0x184[i][1] = (J2DTextBox*)mpMenuDMYScreen->search(ftag_sub1[i]);
+            field_0x184[i][2] = (J2DTextBox*)mpMenuDMYScreen->search(ftag_name0[i]);
+            field_0x184[i][3] = (J2DTextBox*)mpMenuDMYScreen->search(ftag_name1[i]);
+            mpMenuDMYScreen->search(tag_sub0[i])->hide();
+            mpMenuDMYScreen->search(tag_sub1[i])->hide();
+            mpMenuDMYScreen->search(tag_name0[i])->hide();
+            mpMenuDMYScreen->search(tag_name1[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x184[i][0] = (J2DTextBox*)mpMenuDMYScreen->search(tag_sub0[i]);
         field_0x184[i][1] = (J2DTextBox*)mpMenuDMYScreen->search(tag_sub1[i]);
         field_0x184[i][2] = (J2DTextBox*)mpMenuDMYScreen->search(tag_name0[i]);
@@ -964,7 +1037,16 @@ void dMenu_Letter_c::screenSetBase() {
     mpParent[1] = JKR_NEW CPaneMgr(mpBaseScreen, MULTI_CHAR('n_all'), 2, NULL);
     JUT_ASSERT(1372, mpParent[1] != NULL);
     mpParent[1]->setAlphaRate(0.0f);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    J2DTextBox* piVar9;
+    if (dusk::version::isRegionJpn()) {
+        piVar9 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('t_t00'));
+        mpBaseScreen->search(MULTI_CHAR('f_t_00'))->hide();
+    } else {
+        piVar9 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('f_t_00'));
+        mpBaseScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     J2DTextBox* piVar9 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('t_t00'));
     mpBaseScreen->search(MULTI_CHAR('f_t_00'))->hide();
 #else
@@ -975,7 +1057,31 @@ void dMenu_Letter_c::screenSetBase() {
     piVar9->setFont(mDoExt_getSubFont());
     dComIfGp_setMessageCountNumber(field_0x374 + (field_0x36f + 1) * 100);
     mpString->getString(0x4d6, piVar9, NULL, NULL, NULL, 0);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    J2DTextBox* text1;
+    J2DTextBox* text2;
+    J2DTextBox* text3;
+    J2DTextBox* text4;
+    if (dusk::version::isRegionJpn()) {
+        text1 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('wps_text'));
+        text2 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('w_p_text'));
+        text3 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('g_ps_txt'));
+        text4 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('g_p_text'));
+        mpBaseScreen->search(MULTI_CHAR('fwpstex1'))->hide();
+        mpBaseScreen->search(MULTI_CHAR('fwp_tex1'))->hide();
+        mpBaseScreen->search(MULTI_CHAR('fgps_tx1'))->hide();
+        mpBaseScreen->search(MULTI_CHAR('fgp_tex1'))->hide();
+    } else {
+        text1 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('fwpstex1'));
+        text2 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('fwp_tex1'));
+        text3 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('fgps_tx1'));
+        text4 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('fgp_tex1'));
+        mpBaseScreen->search(MULTI_CHAR('wps_text'))->hide();
+        mpBaseScreen->search(MULTI_CHAR('w_p_text'))->hide();
+        mpBaseScreen->search(MULTI_CHAR('g_ps_txt'))->hide();
+        mpBaseScreen->search(MULTI_CHAR('g_p_text'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     J2DTextBox* text1 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('wps_text'));
     J2DTextBox* text2 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('w_p_text'));
     J2DTextBox* text3 = (J2DTextBox*)mpBaseScreen->search(MULTI_CHAR('g_ps_txt'));
@@ -1059,7 +1165,96 @@ void dMenu_Letter_c::screenSetLetter() {
     JUT_ASSERT(1511, fg != false);
     dPaneClass_showNullPane(mpLetterScreen[0]);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() == 0) {
+            field_0x2ec[0] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('t3f_s'), 0, NULL);
+            field_0x2ec[1] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('mg_3flin'), 0, NULL);
+            field_0x2f4[0] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('mg_3f_s'), 0, NULL);
+            field_0x2f4[1] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('mg_3f'), 0, NULL);
+            mpLetterScreen[0]->search('t4_s')->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('mg_e4lin'))->hide();
+            mpLetterScreen[0]->search('t3_s')->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('mg_3line'))->hide();
+            mpLineParent = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('jp_fri_n'), 0, NULL);
+            JUT_ASSERT(1530, mpLineParent != NULL);
+            for (int i = 0; i < 12; i++) {
+                static u64 const line_tag[12] = {
+                    MULTI_CHAR('line00'), MULTI_CHAR('line01'), MULTI_CHAR('line02'), MULTI_CHAR('line03'), MULTI_CHAR('line04'), MULTI_CHAR('line05'),
+                    MULTI_CHAR('line06'), MULTI_CHAR('line07'), MULTI_CHAR('line08'),
+                };
+
+                if (line_tag[i] != 0) {
+                    field_0x25c[i] = (J2DTextBox*)mpLetterScreen[0]->search(line_tag[i]);
+                } else {
+                    field_0x25c[i] = NULL;
+                }
+            }
+            mpLetterScreen[0]->search('jp_n')->hide();
+            mpLetterScreen[0]->search('us_n')->hide();
+
+            ((J2DTextBox*)field_0x2f4[0]->getPanePtr())->setLineSpace(((J2DTextBox*)field_0x2ec[0]->getPanePtr())->getLineSpace());
+            ((J2DTextBox*)field_0x2f4[1]->getPanePtr())->setLineSpace(((J2DTextBox*)field_0x2ec[1]->getPanePtr())->getLineSpace());
+        } else {
+            field_0x2ec[0] = JKR_NEW CPaneMgr(mpLetterScreen[0], 't3_s', 0, NULL);
+            field_0x2ec[1] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('mg_3line'), 0, NULL);
+            for (int i = 0; i < 2; i++) {
+                field_0x2f4[i] = NULL;
+            }
+            mpLetterScreen[0]->search('t4_s')->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('mg_e4lin'))->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('t3f_s'))->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('mg_3flin'))->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('mg_3f_s'))->hide();
+            mpLetterScreen[0]->search(MULTI_CHAR('mg_3f'))->hide();
+            mpLineParent = JKR_NEW CPaneMgr(mpLetterScreen[0], 'jp_n', 0, NULL);
+            JUT_ASSERT(1530, mpLineParent != NULL);
+            for (int i = 0; i < 12; i++) {
+                static u64 const line_tag[12] = {
+                    MULTI_CHAR('line21'), MULTI_CHAR('line22'), MULTI_CHAR('line23'), MULTI_CHAR('line24'), MULTI_CHAR('line25'), MULTI_CHAR('line26'),
+                    MULTI_CHAR('line27'), MULTI_CHAR('line28'), MULTI_CHAR('line29'),
+                };
+
+                if (line_tag[i] != 0) {
+                    field_0x25c[i] = (J2DTextBox*)mpLetterScreen[0]->search(line_tag[i]);
+                } else {
+                    field_0x25c[i] = NULL;
+                }
+            }
+
+            mpLetterScreen[0]->search(MULTI_CHAR('jp_fri_n'))->hide();
+            mpLetterScreen[0]->search('us_n')->hide();
+        }
+    } else {
+        static u64 const line_tag[12] = {
+            MULTI_CHAR('line09'), MULTI_CHAR('line10'), MULTI_CHAR('line11'), MULTI_CHAR('line12'), MULTI_CHAR('line13'), MULTI_CHAR('line14'),
+            MULTI_CHAR('line15'), MULTI_CHAR('line16'), MULTI_CHAR('line17'), MULTI_CHAR('line18'), MULTI_CHAR('line19'), MULTI_CHAR('line20'),
+        };
+
+        field_0x2ec[0] = JKR_NEW CPaneMgr(mpLetterScreen[0], 't4_s', 0, NULL);
+        field_0x2ec[1] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('mg_e4lin'), 0, NULL);
+        for (int i = 0; i < 2; i++) {
+            field_0x2f4[i] = NULL;
+        }
+        mpLetterScreen[0]->search(MULTI_CHAR('t3f_s'))->hide();
+        mpLetterScreen[0]->search(MULTI_CHAR('mg_3flin'))->hide();
+        mpLetterScreen[0]->search(MULTI_CHAR('mg_3f_s'))->hide();
+        mpLetterScreen[0]->search(MULTI_CHAR('mg_3f'))->hide();
+        mpLetterScreen[0]->search('t3_s')->hide();
+        mpLetterScreen[0]->search(MULTI_CHAR('mg_3line'))->hide();
+        mpLineParent = JKR_NEW CPaneMgr(mpLetterScreen[0], 'us_n', 0, NULL);
+        JUT_ASSERT(1530, mpLineParent != NULL);
+        for (int i = 0; i < 12; i++) {
+            if (line_tag[i] != 0) {
+                field_0x25c[i] = (J2DTextBox*)mpLetterScreen[0]->search(line_tag[i]);
+            } else {
+                field_0x25c[i] = NULL;
+            }
+        }
+        mpLetterScreen[0]->search(MULTI_CHAR('jp_fri_n'))->hide();
+        mpLetterScreen[0]->search('jp_n')->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() == 0) {
         field_0x2ec[0] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('t3f_s'), 0, NULL);
         field_0x2ec[1] = JKR_NEW CPaneMgr(mpLetterScreen[0], MULTI_CHAR('mg_3flin'), 0, NULL);
@@ -1148,20 +1343,20 @@ void dMenu_Letter_c::screenSetLetter() {
     mpLetterScreen[0]->search('jp_n')->hide();
 #endif
 
+#if TARGET_PC
+#define STR_BUF_LEN 528
+#elif VERSION == VERSION_GCN_JPN
+#define STR_BUF_LEN 528
+#else
+#define STR_BUF_LEN 512
+#endif
+
     for (int i = 0; i < 2; i++) {
         ((J2DTextBox*)field_0x2ec[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-        ((J2DTextBox*)field_0x2ec[i]->getPanePtr())->setString(0x210, "");
-#else
-        ((J2DTextBox*)field_0x2ec[i]->getPanePtr())->setString(0x200, "");
-#endif
+        ((J2DTextBox*)field_0x2ec[i]->getPanePtr())->setString(STR_BUF_LEN, "");
         if (field_0x2f4[i] != NULL) {
             ((J2DTextBox*)field_0x2f4[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-            ((J2DTextBox*)field_0x2f4[i]->getPanePtr())->setString(0x210, "");
-#else
-            ((J2DTextBox*)field_0x2f4[i]->getPanePtr())->setString(0x200, "");
-#endif
+            ((J2DTextBox*)field_0x2f4[i]->getPanePtr())->setString(STR_BUF_LEN, "");
         }
     }
     field_0x1e4[0] = (J2DTextBox*)mpLetterScreen[0]->search(MULTI_CHAR('p_texts'));
diff --git a/src/d/d_menu_option.cpp b/src/d/d_menu_option.cpp
index 94babc8342..6790684e7b 100644
--- a/src/d/d_menu_option.cpp
+++ b/src/d/d_menu_option.cpp
@@ -29,12 +29,13 @@
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
 #include "dusk/ui/touch_controls.hpp"
+#include "dusk/version.hpp"
 #endif
 
 typedef void (dMenu_Option_c::*initFunc)();
 static initFunc init[] = {
     &dMenu_Option_c::atten_init,
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
     &dMenu_Option_c::ruby_init,
 #endif
     &dMenu_Option_c::vib_init,
@@ -46,7 +47,7 @@ static initFunc init[] = {
 typedef void (dMenu_Option_c::*processFunc)();
 static processFunc process[] = {
     &dMenu_Option_c::atten_move,
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
     &dMenu_Option_c::ruby_move,
 #endif
     &dMenu_Option_c::vib_move,
@@ -68,25 +69,30 @@ static calibrationFunc calibration_process[] = {
     &dMenu_Option_c::calibration_close2_move,
 };
 
-enum SelectType {
-#if VERSION == VERSION_GCN_JPN
-    SelectType0_JPN,
-#endif
-    SelectType0,
-    SelectType1,
-    SelectType2,
-    SelectType3,
-    SelectType4,
-    SelectType5,
-    SelectType6,
-    SelectType7,
-    SelectType8,
-};
-
 #if TARGET_PC
 static dusk::menu_pointer::TargetId option_yes_no_target(u8 index) noexcept {
     return static_cast<dusk::menu_pointer::TargetId>(0x100 + index);
 }
+
+static u8 option_to_proc(u8 select) noexcept {
+    if (!dusk::version::isRegionJpn() && select >= 1) {
+        return static_cast<u8>(select + 1);
+    }
+    return select;
+}
+
+static u8 option_to_select(u8 proc) noexcept {
+    if (!dusk::version::isRegionJpn() && proc >= 2) {
+        return static_cast<u8>(proc - 1);
+    }
+    return proc;
+}
+
+#define OPTION_SELECT(proc_e) (option_to_select(proc_e))
+#define OPTION_PROC(select) (option_to_proc(select))
+#else
+#define OPTION_SELECT(proc_e) (proc_e)
+#define OPTION_PROC(select) (select)
 #endif
 
 dMenu_Option_c::dMenu_Option_c(JKRArchive* i_archive, STControl* i_stick) {
@@ -173,7 +179,9 @@ void dMenu_Option_c::_create() {
     
     mpTVButtonText = JKR_NEW CPaneMgr(mpTVScreen, MULTI_CHAR('a_text_n'), 0, NULL);
     JUT_ASSERT(298, mpTVButtonText != NULL);
+    IF_DUSK_BLOCK(dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn)
     mpTVScreen->search(MULTI_CHAR('g_abtn_n'))->hide();
+    IF_DUSK_BLOCK_END
 
     mpScreenIcon = JKR_NEW J2DScreen();
     JUT_ASSERT(325, mpScreenIcon != NULL);
@@ -271,11 +279,11 @@ void dMenu_Option_c::_create() {
     field_0x3e1 = 10;
     field_0x3e2 = 0xff;
     field_0x3e3 = 0xc0;
-    field_0x3ef = 0;
+    field_0x3ef = OPTION_SELECT(PROC_ATTEN_e);
     field_0x3f0 = 0xff;
     field_0x3f1 = 0xff;
     field_0x3f2 = 0;
-    field_0x3f5 = 0;
+    field_0x3f5 = OPTION_SELECT(PROC_ATTEN_e);
     field_0x3f3 = 5;
     field_0x3f4 = 5;
     field_0x334 = 0.0f;
@@ -499,9 +507,9 @@ void dMenu_Option_c::_move() {
     }
 
     if (mDoGph_gInf_c::getFader()->getStatus() == 1) {
-        if (mDoCPd_c::getTrigA(PAD_1) != 0 && field_0x3ef != SelectType3 && field_0x3f3 == 5) {
-            if (field_0x3f4 == 5 && field_0x3ef != SelectType4 && field_0x3ef != SelectType5 && field_0x3ef != SelectType6 &&
-                field_0x3ef != SelectType7)
+        if (mDoCPd_c::getTrigA(PAD_1) != 0 && field_0x3ef != OPTION_SELECT(PROC_CHANGE_MOVE_e) && field_0x3f3 == 5) {
+            if (field_0x3f4 == 5 && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e) &&
+                field_0x3ef != OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e))
             {
                 if (mDoCPd_c::getTrigStart(PAD_1) == 0 && mDoCPd_c::getTrigB(PAD_1) == 0) {
                     if (mDoCPd_c::getTrigUp(PAD_1) == 0 && mDoCPd_c::getTrigDown(PAD_1) == 0 &&
@@ -509,17 +517,17 @@ void dMenu_Option_c::_move() {
                     {
                         field_0x3f7 = 1;
                         field_0x3f5 = field_0x3ef;
-                        field_0x3ef = SelectType4;
+                        field_0x3ef = OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e);
                         dMeter2Info_set2DVibration();
-                        (this->*init[field_0x3ef])();
+                        (this->*init[OPTION_PROC(field_0x3ef)])();
                         goto skip;
                     }
                 }
             }
         }
 
-        if (mDoCPd_c::getTrigB(PAD_1) != 0 && field_0x3ef != SelectType3 && field_0x3f3 == 5 &&
-            field_0x3ef != SelectType4 && field_0x3ef != SelectType5 && field_0x3ef != SelectType6 && field_0x3ef != SelectType7)
+        if (mDoCPd_c::getTrigB(PAD_1) != 0 && field_0x3ef != OPTION_SELECT(PROC_CHANGE_MOVE_e) && field_0x3f3 == 5 &&
+            field_0x3ef != OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e))
         {
             if (field_0x3f4 == 5 && mDoCPd_c::getTrigStart(PAD_1) == 0 &&
                 mDoCPd_c::getTrigA(PAD_1) == 0 && mDoCPd_c::getTrigUp(PAD_1) == 0 &&
@@ -528,16 +536,16 @@ void dMenu_Option_c::_move() {
             {
                 field_0x3f7 = 0;
                 field_0x3f5 = field_0x3ef;
-                field_0x3ef = SelectType4;
+                field_0x3ef = OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e);
                 dMeter2Info_set2DVibration();
-                (this->*init[field_0x3ef])();
+                (this->*init[OPTION_PROC(field_0x3ef)])();
             }
         }
 
 #if TARGET_PC
-        if (field_0x3f4 == 5 && field_0x3ef != SelectType3 && field_0x3f3 == 5 &&
-            field_0x3ef != SelectType4 && field_0x3ef != SelectType5 && field_0x3ef != SelectType6 &&
-            field_0x3ef != SelectType7 && pointerConfirmSelect())
+        if (field_0x3f4 == 5 && field_0x3ef != OPTION_SELECT(PROC_CHANGE_MOVE_e) && field_0x3f3 == 5 &&
+            field_0x3ef != OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e) &&
+            field_0x3ef != OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e) && pointerConfirmSelect())
         {
             goto skip;
         }
@@ -545,7 +553,7 @@ void dMenu_Option_c::_move() {
     }
 skip:
     u8 oldValue = field_0x3ef;
-    if (field_0x3f3 == 5 && oldValue != SelectType4 && oldValue != SelectType5 && oldValue != SelectType6 && oldValue != SelectType7) {
+    if (field_0x3f3 == 5 && oldValue != OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e) && oldValue != OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e) && oldValue != OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e) && oldValue != OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e)) {
         dpdMenuMove();
     }
 
@@ -559,10 +567,10 @@ skip:
         field_0x3f0 = 0xff;
     }
 
-    (this->*process[field_0x3ef])();
+    (this->*process[OPTION_PROC(field_0x3ef)])();
     mpSelectScreen->animation();
     if (oldValue != field_0x3ef) {
-        (this->*init[field_0x3ef])();
+        (this->*init[OPTION_PROC(field_0x3ef)])();
     }
     
     setHIO(false);
@@ -624,8 +632,8 @@ void dMenu_Option_c::drawHaihai() {
     field_0x3f6 = 0;
     field_0x3f6 |= 1;
     field_0x3f6 |= 4;
-    if (selectType < SelectType4 && field_0x3f6 != 0 && field_0x3f3 == 5 && field_0x3ef != SelectType4 &&
-        field_0x3ef != SelectType5 && field_0x3ef != SelectType6 && field_0x3ef != SelectType7)
+    if (selectType < OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e) && field_0x3f6 != 0 && field_0x3f3 == 5 && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e) &&
+        field_0x3ef != OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e) && field_0x3ef != OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e))
     {
         mpMeterHaihai->_execute(0);
         Vec haihaiPosL =
@@ -776,8 +784,8 @@ void dMenu_Option_c::atten_move() {
             field_0x3e4 = 0;
             field_0x3da = -5;
         }
-        field_0x3ef = SelectType3;
-        field_0x3f5 = 0;
+        field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+        field_0x3f5 = OPTION_SELECT(PROC_ATTEN_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else if (rightTrigger) {
         if (field_0x3e4 == 0) {
@@ -787,16 +795,23 @@ void dMenu_Option_c::atten_move() {
             field_0x3e4 = 0;
             field_0x3da = 5;
         }
-        field_0x3ef = SelectType3;
-        field_0x3f5 = 0;
+        field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+        field_0x3f5 = OPTION_SELECT(PROC_ATTEN_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else {
         changeTVCheck();
     }
 }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
 void dMenu_Option_c::ruby_init() {
+#if TARGET_PC
+    if (!dusk::version::isRegionJpn()) {
+        vib_init();
+        return;
+    }
+#endif
+
     mpDrawCursor->setAlphaRate(1.0f);
     setCursorPos(1);
     setAButtonString(0x40c);
@@ -804,6 +819,12 @@ void dMenu_Option_c::ruby_init() {
 }
 
 void dMenu_Option_c::ruby_move() {
+#if TARGET_PC
+    if (!dusk::version::isRegionJpn()) {
+        vib_move();
+        return;
+    }
+#endif
 
     bool upTrigger = mpStick->checkUpTrigger();
     bool downTrigger= mpStick->checkDownTrigger();
@@ -813,10 +834,10 @@ void dMenu_Option_c::ruby_move() {
     if (field_0x3f3 != 5) {
         (this->*tv_process[field_0x3f3])();
     } else if (upTrigger) {
-        field_0x3ef = SelectType0_JPN;
+        field_0x3ef = OPTION_SELECT(PROC_ATTEN_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else if (downTrigger) {
-        field_0x3ef = SelectType1;
+        field_0x3ef = OPTION_SELECT(PROC_VIB_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else if (leftTrigger) {
         if (field_0x3e5_JPN == 0) {
@@ -826,8 +847,8 @@ void dMenu_Option_c::ruby_move() {
             field_0x3e5_JPN = 0;
             field_0x3da = -5;
         }
-        field_0x3ef = SelectType3;
-        field_0x3f5 = SelectType0;
+        field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+        field_0x3f5 = OPTION_SELECT(PROC_RUBY_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else if (rightTrigger) {
         if (field_0x3e5_JPN == 0) {
@@ -837,8 +858,8 @@ void dMenu_Option_c::ruby_move() {
             field_0x3e5_JPN = 0;
             field_0x3da = 5;
         }
-        field_0x3ef = SelectType3;
-        field_0x3f5 = SelectType0;
+        field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+        field_0x3f5 = OPTION_SELECT(PROC_RUBY_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else {
         changeTVCheck();
@@ -848,26 +869,36 @@ void dMenu_Option_c::ruby_move() {
 
 void dMenu_Option_c::vib_init() {
     mpDrawCursor->setAlphaRate(1.0f);
-    setCursorPos(SelectType1);
+    setCursorPos(OPTION_SELECT(PROC_VIB_e));
     setAButtonString(0x40C);
     setBButtonString(0x3F9);
 }
 
 void dMenu_Option_c::vib_move() {
     bool upTrigger = mpStick->checkUpTrigger();
-    bool downTrigger = mpStick->checkDownTrigger();
+    IF_NOT_DUSK(bool downTrigger =) mpStick->checkDownTrigger();
     bool leftTrigger = checkLeftTrigger();
     bool rightTrigger = checkRightTrigger();
 
     if (field_0x3f3 != 5) {
         (this->*tv_process[field_0x3f3])();
     } else if (upTrigger) {
-        field_0x3ef = SelectType0;
+#if TARGET_PC
+        field_0x3ef = OPTION_SELECT(dusk::version::isRegionJpn() ? PROC_RUBY_e : PROC_ATTEN_e);
+#elif VERSION == VERSION_GCN_JPN
+        field_0x3ef = PROC_RUBY_e;
+#else
+        field_0x3ef = PROC_ATTEN_e;
+#endif
         Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
-    } else if (downTrigger) {
-        field_0x3ef = SelectType2;
+    }
+#ifndef TARGET_PC
+    else if (downTrigger) {
+        field_0x3ef = OPTION_SELECT(PROC_SOUND_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
-    } else if (leftTrigger) {
+    } 
+#endif
+    else if (leftTrigger) {
         if (isRumbleSupported()) {
             if (field_0x3ea == 0) {
                 field_0x3ea = 1;
@@ -877,8 +908,8 @@ void dMenu_Option_c::vib_move() {
                 field_0x3ea = 0;
                 field_0x3da = -5;
             }
-            field_0x3ef = SelectType3;
-            field_0x3f5 = SelectType1;
+            field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+            field_0x3f5 = OPTION_SELECT(PROC_VIB_e);
             Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f,
                                      0);
         }
@@ -892,8 +923,8 @@ void dMenu_Option_c::vib_move() {
                 field_0x3ea = 0;
                 field_0x3da = 5;
             }
-            field_0x3ef = SelectType3;
-            field_0x3f5 = SelectType1;
+            field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+            field_0x3f5 = OPTION_SELECT(PROC_VIB_e);
             Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f,
                                      0);
         }
@@ -904,7 +935,7 @@ void dMenu_Option_c::vib_move() {
 
 void dMenu_Option_c::sound_init() {
     mpDrawCursor->setAlphaRate(1.0f);
-    setCursorPos(SelectType2);
+    setCursorPos(OPTION_SELECT(PROC_SOUND_e));
     setAButtonString(0x40C);
     setBButtonString(0x3F9);
 }
@@ -918,7 +949,7 @@ void dMenu_Option_c::sound_move() {
     if (field_0x3f3 != 5) {
         (this->*tv_process[field_0x3f3])();
     } else if (upTrigger) {
-        field_0x3ef = SelectType1;
+        field_0x3ef = OPTION_SELECT(PROC_VIB_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else if (leftTrigger) {
         if (field_0x3e9 == 2) {
@@ -943,8 +974,8 @@ void dMenu_Option_c::sound_move() {
         }
         mDoAud_setOutputMode(dMo_soundMode[field_0x3e9]);
         setSoundMode(dMo_soundMode[field_0x3e9]);
-        field_0x3ef = SelectType3;
-        field_0x3f5 = SelectType2;
+        field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+        field_0x3f5 = OPTION_SELECT(PROC_SOUND_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else if (rightTrigger) {
         if (field_0x3e9 == 0) {
@@ -969,8 +1000,8 @@ void dMenu_Option_c::sound_move() {
         }
         mDoAud_setOutputMode(dMo_soundMode[field_0x3e9]);
         setSoundMode(dMo_soundMode[field_0x3e9]);
-        field_0x3ef = SelectType3;
-        field_0x3f5 = SelectType2;
+        field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+        field_0x3f5 = OPTION_SELECT(PROC_SOUND_e);
         Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
     } else {
         changeTVCheck();
@@ -991,33 +1022,29 @@ void dMenu_Option_c::change_move() {
         field_0x3da++;
     }
     u8 index;
-    switch (field_0x3f5) {
-#if VERSION == VERSION_GCN_JPN
-    case SelectType0_JPN:
-        index = SelectType0_JPN;
+    switch (OPTION_PROC(field_0x3f5)) {
+    case PROC_ATTEN_e:
+        index = field_0x3f5;
         if (field_0x3da == 0) {
             setAttenString();
         }
         break;
-#endif
-    case SelectType0:
-        index = SelectType0;
+    case PROC_RUBY_e:
+        index = field_0x3f5;
         if (field_0x3da == 0) {
-#if VERSION == VERSION_GCN_JPN
+            IF_DUSK_BLOCK(dusk::version::isRegionJpn())
             setRubyString();
-#else
-            setAttenString();
-#endif
+            IF_DUSK_BLOCK_END
         }
         break;
-    case SelectType1:
-        index = SelectType1;
+    case PROC_VIB_e:
+        index = field_0x3f5;
         if (field_0x3da == 0) {
             setVibString();
         }
         break;
-    case SelectType2:
-        index = SelectType2;
+    case PROC_SOUND_e:
+        index = field_0x3f5;
         if (field_0x3da == 0) {
             setSoundString();
         }
@@ -1083,7 +1110,7 @@ void dMenu_Option_c::confirm_open_move() {
     }
     if (status == 1 && yesNoMenuMove == 1 && field_0x374 == 1.0f) {
         yesnoCursorShow();
-        field_0x3ef = SelectType5;
+        field_0x3ef = OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e);
     }
     mpWarning->_move();
     setAnimation();
@@ -1113,21 +1140,21 @@ void dMenu_Option_c::confirm_move_move() {
             field_0x3f9 = i;
             if (clicked) {
                 yesNoSelectStart();
-                field_0x3ef = SelectType7;
+                field_0x3ef = OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e);
                 dMeter2Info_set2DVibrationM();
                 mpWarning->_move();
                 setAnimation();
                 return;
             }
             yesnoSelectAnmSet();
-            field_0x3ef = SelectType6;
+            field_0x3ef = OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e);
             mpWarning->_move();
             setAnimation();
             return;
         }
         if (clicked) {
             yesNoSelectStart();
-            field_0x3ef = SelectType7;
+            field_0x3ef = OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e);
             dMeter2Info_set2DVibrationM();
             mpWarning->_move();
             setAnimation();
@@ -1138,12 +1165,12 @@ void dMenu_Option_c::confirm_move_move() {
 
     if (mDoCPd_c::getTrigA(PAD_1) != 0) {
         yesNoSelectStart();
-        field_0x3ef = SelectType7;
+        field_0x3ef = OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e);
         dMeter2Info_set2DVibrationM();
     } else if (mDoCPd_c::getTrigB(PAD_1) != 0) {
         field_0x3f9 = 0;
         yesnoCancelAnmSet();
-        field_0x3ef = SelectType7;
+        field_0x3ef = OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e);
         dMeter2Info_set2DVibrationM();
     } else if (rightTrigger != 0) {
         if (field_0x3f9 != 0) {
@@ -1152,7 +1179,7 @@ void dMenu_Option_c::confirm_move_move() {
             field_0x3fa = field_0x3f9;
             field_0x3f9 = 0;
             yesnoSelectAnmSet();
-            field_0x3ef = SelectType6;
+            field_0x3ef = OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e);
         }
     } else if (leftTrigger != 0) {
         if (field_0x3f9 != 1) {
@@ -1161,7 +1188,7 @@ void dMenu_Option_c::confirm_move_move() {
             field_0x3fa = field_0x3f9;
             field_0x3f9 = 1;
             yesnoSelectAnmSet();
-            field_0x3ef = SelectType6;
+            field_0x3ef = OPTION_SELECT(PROC_CONFIRM_SELECT_MOVE_e);
         }
     }
     mpWarning->_move();
@@ -1195,14 +1222,14 @@ void dMenu_Option_c::confirm_select_move() {
                 dusk::menu_pointer::Context::Options, option_yes_no_target(field_0x3f9)))
         {
             yesNoSelectStart();
-            field_0x3ef = SelectType7;
+            field_0x3ef = OPTION_SELECT(PROC_CONFIRM_CLOSE_MOVE_e);
             dMeter2Info_set2DVibrationM();
             mpWarning->_move();
             setAnimation();
             return;
         }
 #endif
-        field_0x3ef = SelectType5;
+        field_0x3ef = OPTION_SELECT(PROC_CONFIRM_MOVE_MOVE_e);
     }
     mpWarning->_move();
     setAnimation();
@@ -1231,8 +1258,8 @@ void dMenu_Option_c::confirm_close_move() {
             if (field_0x3f9 == 1) {
                 mQuitStatus = 3;
                 dComIfGs_setOptAttentionType(field_0x3e4);
-#if VERSION == VERSION_GCN_JPN
-                if (field_0x3e5_JPN == 0) {
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+                if (IF_DUSK(dusk::version::isRegionJpn() &&) field_0x3e5_JPN == 0) {
                     dComIfGs_setOptRuby(1);
                 } else {
                     dComIfGs_setOptRuby(0);
@@ -1346,7 +1373,7 @@ void dMenu_Option_c::calibration_close2_move() {
 
 void dMenu_Option_c::menuVisible() {
     for (int i = 0; i < 6; i++) {
-        if (i < SelectType3) {
+        if (i < OPTION_SELECT(DUSK_IF_ELSE(PROC_SOUND_e, PROC_CHANGE_MOVE_e))) {
             menuShow(i);
         } else {
             menuHide(i);
@@ -1396,7 +1423,16 @@ void dMenu_Option_c::screenSet() {
     static const u64 tag_frame[6] = {
         MULTI_CHAR('flame_00'), MULTI_CHAR('flame_01'), MULTI_CHAR('flame_02'), MULTI_CHAR('flame_03'), MULTI_CHAR('flame_04'), MULTI_CHAR('flame_05'),
     };
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    static const u64 tag_menu0_jpn[6] = {
+        MULTI_CHAR('menu_t0'), MULTI_CHAR('menu_t1'), MULTI_CHAR('menu_t2'), MULTI_CHAR('menu_t3'), MULTI_CHAR('menu_t4'), MULTI_CHAR('menu_t5'),
+    };
+
+    static const u64 tag_menu0[6] = {
+        MULTI_CHAR('fenu_t0'), MULTI_CHAR('fenu_t1'), MULTI_CHAR('fenu_t2'), MULTI_CHAR('fenu_t3'), MULTI_CHAR('fenu_t4'), MULTI_CHAR('fenu_t5'),
+    };
+#elif VERSION == VERSION_GCN_JPN
     static const u64 tag_menu0[6] = {
         MULTI_CHAR('menu_t0'), MULTI_CHAR('menu_t1'), MULTI_CHAR('menu_t2'), MULTI_CHAR('menu_t3'), MULTI_CHAR('menu_t4'), MULTI_CHAR('menu_t5'),
     };
@@ -1405,6 +1441,7 @@ void dMenu_Option_c::screenSet() {
         MULTI_CHAR('fenu_t0'), MULTI_CHAR('fenu_t1'), MULTI_CHAR('fenu_t2'), MULTI_CHAR('fenu_t3'), MULTI_CHAR('fenu_t4'), MULTI_CHAR('fenu_t5'),
     };
 #endif
+
     static const u64 let_n[6] = {
         MULTI_CHAR('let_00_n'), MULTI_CHAR('let_01_n'), MULTI_CHAR('let_02_n'), MULTI_CHAR('let_03_n'), MULTI_CHAR('let_04_n'), MULTI_CHAR('let_05_n'),
     };
@@ -1444,7 +1481,34 @@ void dMenu_Option_c::screenSet() {
     static const u64 ftv_btnA[5] = {
         MULTI_CHAR('font_a1'), MULTI_CHAR('font_at2'), MULTI_CHAR('font_at3'), MULTI_CHAR('font_at4'), MULTI_CHAR('font_at'),
     };
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    static const u64 fenu_t0_jpn[2] = {MULTI_CHAR('fenu_t0s'), MULTI_CHAR('fenu_t0')};
+    static const u64 menu_t0_jpn[2] = {MULTI_CHAR('menu_t0s'), MULTI_CHAR('menu_t0')};
+    static const u64 fenu_t1_jpn[2] = {MULTI_CHAR('fenu_t1s'), MULTI_CHAR('fenu_t1')};
+    static const u64 menu_t1_jpn[2] = {MULTI_CHAR('menu_t1s'), MULTI_CHAR('menu_t1')};
+    static const u64 fenu_t2_jpn[2] = {MULTI_CHAR('fenu_t2s'), MULTI_CHAR('fenu_t2')};
+    static const u64 menu_t2_jpn[2] = {MULTI_CHAR('menu_t2s'), MULTI_CHAR('menu_t2')};
+    static const u64 fenu_t3_jpn[2] = {MULTI_CHAR('fenu_t3s'), MULTI_CHAR('fenu_t3')};
+    static const u64 menu_t3_jpn[2] = {MULTI_CHAR('menu_t3s'), MULTI_CHAR('menu_t3')};
+    static const u64 fenu_t4_jpn[2] = {MULTI_CHAR('fenu_t4s'), MULTI_CHAR('fenu_t4')};
+    static const u64 menu_t4_jpn[2] = {MULTI_CHAR('menu_t4s'), MULTI_CHAR('menu_t4')};
+    static const u64 fenu_t5_jpn[2] = {MULTI_CHAR('fenu_t5s'), MULTI_CHAR('fenu_t5')};
+    static const u64 menu_t5_jpn[2] = {MULTI_CHAR('menu_t5s'), MULTI_CHAR('menu_t5')};
+
+    static const u64 fenu_t0[2] = {MULTI_CHAR('fenu_t0s'), MULTI_CHAR('fenu_t0')};
+    static const u64 menu_t0[2] = {MULTI_CHAR('menu_t0s'), MULTI_CHAR('menu_t0')};
+    static const u64 fenu_t2[2] = {MULTI_CHAR('fenu_t1s'), MULTI_CHAR('fenu_t1')};
+    static const u64 menu_t2[2] = {MULTI_CHAR('menu_t1s'), MULTI_CHAR('menu_t1')};
+    static const u64 fenu_t3[2] = {MULTI_CHAR('fenu_t2s'), MULTI_CHAR('fenu_t2')};
+    static const u64 menu_t3[2] = {MULTI_CHAR('menu_t2s'), MULTI_CHAR('menu_t2')};
+    static const u64 fenu_t4[2] = {MULTI_CHAR('fenu_t3s'), MULTI_CHAR('fenu_t3')};
+    static const u64 menu_t4[2] = {MULTI_CHAR('menu_t3s'), MULTI_CHAR('menu_t3')};
+    static const u64 fenu_t1[2] = {MULTI_CHAR('fenu_t4s'), MULTI_CHAR('fenu_t4')};
+    static const u64 menu_t1[2] = {MULTI_CHAR('menu_t4s'), MULTI_CHAR('menu_t4')};
+    static const u64 fenu_t5[2] = {MULTI_CHAR('fenu_t5s'), MULTI_CHAR('fenu_t5')};
+    static const u64 menu_t5[2] = {MULTI_CHAR('menu_t5s'), MULTI_CHAR('menu_t5')};
+#elif VERSION == VERSION_GCN_JPN
     static const u64 fenu_t0[2] = {MULTI_CHAR('fenu_t0s'), MULTI_CHAR('fenu_t0')};
     static const u64 menu_t0[2] = {MULTI_CHAR('menu_t0s'), MULTI_CHAR('menu_t0')};
     static const u64 fenu_t1[2] = {MULTI_CHAR('fenu_t1s'), MULTI_CHAR('fenu_t1')};
@@ -1501,7 +1565,15 @@ void dMenu_Option_c::screenSet() {
     static const u64 fenut_4[6] = {
         MULTI_CHAR('menut321'), MULTI_CHAR('menut320'), MULTI_CHAR('menut319'), MULTI_CHAR('menut318'), MULTI_CHAR('menut317'), MULTI_CHAR('menut316'),
     };
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    static const u64 tx_jpn[6] = {
+        MULTI_CHAR('wps_text'), MULTI_CHAR('w_p_text'), MULTI_CHAR('g_ps_tx3'), MULTI_CHAR('g_p_tex3'), MULTI_CHAR('wps_tex1'), MULTI_CHAR('w_p_tex1'),
+    };
+    static const u64 tx[6] = {
+        MULTI_CHAR('w_p_tex5'), MULTI_CHAR('w_p_tex6'), MULTI_CHAR('w_p_tex3'), MULTI_CHAR('w_p_tex4'), MULTI_CHAR('fps_tex1'), MULTI_CHAR('f_p_tex1'),
+    };
+#elif VERSION == VERSION_GCN_JPN
     static const u64 tx[6] = {
         MULTI_CHAR('wps_text'), MULTI_CHAR('w_p_text'), MULTI_CHAR('g_ps_tx3'), MULTI_CHAR('g_p_tex3'), MULTI_CHAR('wps_tex1'), MULTI_CHAR('w_p_tex1'),
     };
@@ -1510,13 +1582,24 @@ void dMenu_Option_c::screenSet() {
         MULTI_CHAR('w_p_tex5'), MULTI_CHAR('w_p_tex6'), MULTI_CHAR('w_p_tex3'), MULTI_CHAR('w_p_tex4'), MULTI_CHAR('fps_tex1'), MULTI_CHAR('f_p_tex1'),
     };
 #endif
+
     static const u64 op_tx[4] = {
         MULTI_CHAR('w_text_n'), MULTI_CHAR('w_btn_n'), MULTI_CHAR('w_k_t_n'), MULTI_CHAR('w_abtn_n'),
     };
     static const u64 z_tx[3] = {
         MULTI_CHAR('z_gc_n'), 0, 0,
     };
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    static const u64 txTV_jpn[10] = {
+        MULTI_CHAR('menu_t6s'), MULTI_CHAR('menu_t6'),  MULTI_CHAR('menu_t9s'), MULTI_CHAR('menu_t9'),  MULTI_CHAR('menut10s'),
+        MULTI_CHAR('menu_t10'), MULTI_CHAR('menu_t7s'), MULTI_CHAR('menu_t7'),  MULTI_CHAR('menu_t8s'), MULTI_CHAR('menu_t8'),
+    };
+    static const u64 txTV[10] = {
+        MULTI_CHAR('menu_t61'), MULTI_CHAR('menu_t2'),  MULTI_CHAR('menu_t91'), MULTI_CHAR('menu_t1'),  MULTI_CHAR('menut101'),
+        MULTI_CHAR('menu_t01'), MULTI_CHAR('menu_t71'), MULTI_CHAR('menu_t3'),  MULTI_CHAR('menu_t81'), MULTI_CHAR('menu_t4'),
+    };
+#elif VERSION == VERSION_GCN_JPN
     static const u64 txTV[10] = {
         MULTI_CHAR('menu_t6s'), MULTI_CHAR('menu_t6'),  MULTI_CHAR('menu_t9s'), MULTI_CHAR('menu_t9'),  MULTI_CHAR('menut10s'),
         MULTI_CHAR('menu_t10'), MULTI_CHAR('menu_t7s'), MULTI_CHAR('menu_t7'),  MULTI_CHAR('menu_t8s'), MULTI_CHAR('menu_t8'),
@@ -1533,7 +1616,7 @@ void dMenu_Option_c::screenSet() {
     mpWarning->mPosY = pos.y + g_drawHIO.mOptionScreen.mBackgroundPosY;
     for (int i = 0; i < 6; i++) {
         field_0x280[i] = (J2DPicture*)mpScreen->search(tag_frame[i]);
-        field_0x298[i] = (J2DTextBox*)mpScreen->search(tag_menu0[i]);
+        field_0x298[i] = (J2DTextBox*)mpScreen->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? tag_menu0_jpn[i] : tag_menu0[i], tag_menu0[i]));
     }
     field_0x2b0[0] = field_0x280[1]->getBlack();
     field_0x2c0[0] = field_0x280[1]->getWhite();
@@ -1600,7 +1683,23 @@ void dMenu_Option_c::screenSet() {
             mpMenuPane32[i] = NULL;
         }
     }
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        field_0x270[0] = (J2DTextBox*)mpBackScreen->search(MULTI_CHAR('t_t00'));
+        field_0x270[1] = (J2DTextBox*)mpBackScreen->search(MULTI_CHAR('t_t01'));
+        mpBackScreen->search(MULTI_CHAR('f_t00'))->hide();
+        mpBackScreen->search(MULTI_CHAR('t_t01'))->hide();
+        field_0x270[2] = (J2DTextBox*)mpTVScreen->search(MULTI_CHAR('t_t00'));
+        mpTVScreen->search(MULTI_CHAR('f_t00'))->hide();
+    } else {
+        field_0x270[0] = (J2DTextBox*)mpBackScreen->search(MULTI_CHAR('f_t00'));
+        field_0x270[1] = (J2DTextBox*)mpBackScreen->search(MULTI_CHAR('t_t01'));
+        mpBackScreen->search(MULTI_CHAR('t_t00'))->hide();
+        mpBackScreen->search(MULTI_CHAR('t_t01'))->hide();
+        field_0x270[2] = (J2DTextBox*)mpTVScreen->search(MULTI_CHAR('f_t00'));
+        mpTVScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     field_0x270[0] = (J2DTextBox*)mpBackScreen->search(MULTI_CHAR('t_t00'));
     field_0x270[1] = (J2DTextBox*)mpBackScreen->search(MULTI_CHAR('t_t01'));
     mpBackScreen->search(MULTI_CHAR('f_t00'))->hide();
@@ -1623,7 +1722,17 @@ void dMenu_Option_c::screenSet() {
     mpString->getString(0x547, field_0x270[1], NULL, NULL, NULL, 0);
     mpString->getString(0x55C, field_0x270[2], NULL, NULL, NULL, 0);
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            field_0x25c[i] = (J2DTextBox*)mpTVScreen->search(tv_btnA[i]);
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpTVScreen->search(ftv_btnA[i])->hide();
+            }
+        } else {
+            field_0x25c[i] = (J2DTextBox*)mpTVScreen->search(ftv_btnA[i]);
+            mpTVScreen->search(tv_btnA[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x25c[i] = (J2DTextBox*)mpTVScreen->search(tv_btnA[i]);
         mpTVScreen->search(ftv_btnA[i])->hide();
 #else
@@ -1634,8 +1743,17 @@ void dMenu_Option_c::screenSet() {
         field_0x25c[i]->setString(0x40, "");
         mpString->getString(0x564, field_0x25c[i], NULL, NULL, NULL, 0);
     }
+
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x21c[0][i] = (J2DTextBox*)mpScreen->search(menu_t0_jpn[i]);
+            mpScreen->search(fenu_t0_jpn[i])->hide();
+        } else {
+            field_0x21c[0][i] = (J2DTextBox*)mpScreen->search(fenu_t0[i]);
+            mpScreen->search(menu_t0[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x21c[0][i] = (J2DTextBox*)mpScreen->search(menu_t0[i]);
         mpScreen->search(fenu_t0[i])->hide();
 #else
@@ -1647,7 +1765,15 @@ void dMenu_Option_c::screenSet() {
         mpString->getString(0x548, field_0x21c[0][i], NULL, NULL, NULL, 0);
     }
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x21c[1][i] = (J2DTextBox*)mpScreen->search(menu_t1_jpn[i]);
+            mpScreen->search(fenu_t1_jpn[i])->hide();
+        } else {
+            field_0x21c[1][i] = (J2DTextBox*)mpScreen->search(fenu_t2[i]);
+            mpScreen->search(menu_t2[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x21c[1][i] = (J2DTextBox*)mpScreen->search(menu_t1[i]);
         mpScreen->search(fenu_t1[i])->hide();
 #else
@@ -1656,14 +1782,29 @@ void dMenu_Option_c::screenSet() {
 #endif
         field_0x21c[1][i]->setFont(mpFont);
         field_0x21c[1][i]->setString(0x40, "");
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpString->getString(0x54B, field_0x21c[1][i], NULL, NULL, NULL, 0);
+        } else {
+            mpString->getString(0x54E, field_0x21c[1][i], NULL, NULL, NULL, 0);
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpString->getString(0x54B, field_0x21c[1][i], NULL, NULL, NULL, 0);
 #else
         mpString->getString(0x54E, field_0x21c[1][i], NULL, NULL, NULL, 0);
 #endif
     }
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x21c[2][i] = (J2DTextBox*)mpScreen->search(menu_t2_jpn[i]);
+            mpScreen->search(fenu_t2_jpn[i])->hide();
+        } else {
+            field_0x21c[2][i] = (J2DTextBox*)mpScreen->search(fenu_t3[i]);
+            mpScreen->search(menu_t3[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x21c[2][i] = (J2DTextBox*)mpScreen->search(menu_t2[i]);
         mpScreen->search(fenu_t2[i])->hide();
 #else
@@ -1672,14 +1813,29 @@ void dMenu_Option_c::screenSet() {
 #endif
         field_0x21c[2][i]->setFont(mpFont);
         field_0x21c[2][i]->setString(0x40, "");
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpString->getString(0x54E, field_0x21c[2][i], NULL, NULL, NULL, 0);
+        } else {
+            mpString->getString(0x54F, field_0x21c[2][i], NULL, NULL, NULL, 0);
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpString->getString(0x54E, field_0x21c[2][i], NULL, NULL, NULL, 0);
 #else
         mpString->getString(0x54F, field_0x21c[2][i], NULL, NULL, NULL, 0);
 #endif
     }
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x21c[3][i] = (J2DTextBox*)mpScreen->search(menu_t3_jpn[i]);
+            mpScreen->search(fenu_t3_jpn[i])->hide();
+        } else {
+            field_0x21c[3][i] = (J2DTextBox*)mpScreen->search(fenu_t4[i]);
+            mpScreen->search(menu_t4[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x21c[3][i] = (J2DTextBox*)mpScreen->search(menu_t3[i]);
         mpScreen->search(fenu_t3[i])->hide();
 #else
@@ -1688,12 +1844,25 @@ void dMenu_Option_c::screenSet() {
 #endif
         field_0x21c[3][i]->setFont(mpFont);
         field_0x21c[3][i]->setString(0x40, "");
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpString->getString(0x54F, field_0x21c[3][i], NULL, NULL, NULL, 0);
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpString->getString(0x54F, field_0x21c[3][i], NULL, NULL, NULL, 0);
 #endif
     }
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x21c[4][i] = (J2DTextBox*)mpScreen->search(menu_t4_jpn[i]);
+            mpScreen->search(fenu_t4_jpn[i])->hide();
+        } else {
+            field_0x21c[4][i] = (J2DTextBox*)mpScreen->search(fenu_t1[i]);
+            mpScreen->search(menu_t1[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x21c[4][i] = (J2DTextBox*)mpScreen->search(menu_t4[i]);
         mpScreen->search(fenu_t4[i])->hide();
 #else
@@ -1704,7 +1873,15 @@ void dMenu_Option_c::screenSet() {
         field_0x21c[4][i]->setString(0x40, "");
     }
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x21c[5][i] = (J2DTextBox*)mpScreen->search(menu_t5_jpn[i]);
+            mpScreen->search(fenu_t5_jpn[i])->hide();
+        } else {
+            field_0x21c[5][i] = (J2DTextBox*)mpScreen->search(fenu_t5[i]);
+            mpScreen->search(menu_t5[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x21c[5][i] = (J2DTextBox*)mpScreen->search(menu_t5[i]);
         mpScreen->search(fenu_t5[i])->hide();
 #else
@@ -1716,7 +1893,17 @@ void dMenu_Option_c::screenSet() {
         mpString->getString(0x554, field_0x21c[5][i], NULL, NULL, NULL, 0);
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            paneResize(menut_0[i]);
+            mpMenuText[0][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_0[i], 0, NULL);
+            mpClipScreen->search(fenut_0[i])->hide();
+        } else {
+            paneResize(fenut_0[i]);
+            mpMenuText[0][i] = JKR_NEW CPaneMgr(mpClipScreen, fenut_0[i], 0, NULL);
+            mpClipScreen->search(menut_0[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         paneResize(menut_0[i]);
         mpMenuText[0][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_0[i], 0, NULL);
         mpClipScreen->search(fenut_0[i])->hide();
@@ -1730,7 +1917,17 @@ void dMenu_Option_c::screenSet() {
         mpMenuText[0][i]->getPanePtr()->setBasePosition(J2DBasePosition_4);
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            paneResize(menut_1[i]);
+            mpMenuText[1][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_1[i], 0, NULL);
+            mpClipScreen->search(fenut_1[i])->hide();
+        } else {
+            paneResize(fenut_1[i]);
+            mpMenuText[1][i] = JKR_NEW CPaneMgr(mpClipScreen, fenut_1[i], 0, NULL);
+            mpClipScreen->search(menut_1[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         paneResize(menut_1[i]);
         mpMenuText[1][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_1[i], 0, NULL);
         mpClipScreen->search(fenut_1[i])->hide();
@@ -1745,7 +1942,17 @@ void dMenu_Option_c::screenSet() {
         mpMenuText[1][i]->getPanePtr()->setBasePosition(J2DBasePosition_4);
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            paneResize(menut_2[i]);
+            mpMenuText[2][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_2[i], 0, NULL);
+            mpClipScreen->search(fenut_2[i])->hide();
+        } else {
+            paneResize(fenut_2[i]);
+            mpMenuText[2][i] = JKR_NEW CPaneMgr(mpClipScreen, fenut_2[i], 0, NULL);
+            mpClipScreen->search(menut_2[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         paneResize(menut_2[i]);
         mpMenuText[2][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_2[i], 0, NULL);
         mpClipScreen->search(fenut_2[i])->hide();
@@ -1760,7 +1967,17 @@ void dMenu_Option_c::screenSet() {
         mpMenuText[2][i]->getPanePtr()->setBasePosition(J2DBasePosition_4);
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            paneResize(menut_3[i]);
+            mpMenuText[3][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_3[i], 0, NULL);
+            mpClipScreen->search(fenut_3[i])->hide();
+        } else {
+            paneResize(fenut_3[i]);
+            mpMenuText[3][i] = JKR_NEW CPaneMgr(mpClipScreen, fenut_3[i], 0, NULL);
+            mpClipScreen->search(menut_3[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         paneResize(menut_3[i]);
         mpMenuText[3][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_3[i], 0, NULL);
         mpClipScreen->search(fenut_3[i])->hide();
@@ -1775,7 +1992,17 @@ void dMenu_Option_c::screenSet() {
         mpMenuText[3][i]->getPanePtr()->setBasePosition(J2DBasePosition_4);
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            paneResize(menut_4[i]);
+            mpMenuText[4][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_4[i], 0, NULL);
+            mpClipScreen->search(fenut_4[i])->hide();
+        } else {
+            paneResize(fenut_4[i]);
+            mpMenuText[4][i] = JKR_NEW CPaneMgr(mpClipScreen, fenut_4[i], 0, NULL);
+            mpClipScreen->search(menut_4[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         paneResize(menut_4[i]);
         mpMenuText[4][i] = JKR_NEW CPaneMgr(mpClipScreen, menut_4[i], 0, NULL);
         mpClipScreen->search(fenut_4[i])->hide();
@@ -1801,7 +2028,16 @@ void dMenu_Option_c::screenSet() {
     }
     field_0x3b4 = 0.0f;
     menuVisible();
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpBackScreen->search(MULTI_CHAR('jpn_n'))->show();
+        mpBackScreen->search(MULTI_CHAR('foregn_n'))->hide();
+    } else {
+        mpBackScreen->search(MULTI_CHAR('jpn_n'))->hide();
+        mpBackScreen->search(MULTI_CHAR('foregn_n'))->show();
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpBackScreen->search(MULTI_CHAR('jpn_n'))->show();
     mpBackScreen->search(MULTI_CHAR('foregn_n'))->hide();
 #else
@@ -1809,7 +2045,7 @@ void dMenu_Option_c::screenSet() {
     mpBackScreen->search(MULTI_CHAR('foregn_n'))->show();
 #endif
     for (int i = 0; i < 6; i++) {
-        J2DTextBox* backScreen = (J2DTextBox*)mpBackScreen->search(tx[i]);
+        J2DTextBox* backScreen = (J2DTextBox*)mpBackScreen->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? tx_jpn[i] : tx[i], tx[i]));
         backScreen->setFont(mpFont);
         backScreen->setString(0x80, "");
         if (i < 2) {
@@ -1832,10 +2068,12 @@ void dMenu_Option_c::screenSet() {
         }
     }
     for (int i = 0; i < 10; i++) {
-        J2DTextBox* tvScreen = (J2DTextBox*)mpTVScreen->search(txTV[i]);
+        J2DTextBox* tvScreen = (J2DTextBox*)mpTVScreen->search(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? txTV_jpn[i] : txTV[i], txTV[i]));
         tvScreen->setFont(mpFont);
-#if VERSION != VERSION_GCN_JPN
+#if TARGET_PC || VERSION != VERSION_GCN_JPN
+        IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
         tvScreen->setCharSpace(0.0f);
+        IF_DUSK_BLOCK_END
 #endif
 
         if (i < 2) {
@@ -1894,7 +2132,7 @@ void dMenu_Option_c::setAttenString() {
     }
 }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
 void dMenu_Option_c::setRubyString() {
     u16 stringId1;
     u16 stringId2;
@@ -1930,7 +2168,9 @@ void dMenu_Option_c::setVibString() {
         stringId2 = 0x54C;
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        const int IDX = dusk::version::isRegionJpn() ? 2 : 1;
+#elif VERSION == VERSION_GCN_JPN
         const int IDX = 2;
 #else
         const int IDX = 1;
@@ -1964,7 +2204,9 @@ void dMenu_Option_c::setSoundString() {
         stringId3 = 0x550;
     }
     for (int i = 0; i < 6; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        const int IDX = dusk::version::isRegionJpn() ? 3 : 2;
+#elif VERSION == VERSION_GCN_JPN
         const int IDX = 3;
 #else
         const int IDX = 2;
@@ -1983,10 +2225,12 @@ void dMenu_Option_c::setSoundString() {
 }
 
 void dMenu_Option_c::setCursorPos(u8 i_index) {
-#if VERSION != VERSION_GCN_JPN
+#if TARGET_PC || VERSION != VERSION_GCN_JPN
+    IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
     if (i_index == 4) {
         i_index = 5;
     }
+    IF_DUSK_BLOCK_END
 #endif
 
     Vec pos = mpMenuPane[i_index]->getGlobalVtxCenter(mpMenuPane[i_index]->mPane, false, 0);
@@ -2037,10 +2281,10 @@ void dMenu_Option_c::setSelectColor(u8 param_0, bool param_1) {
 }
 
 u8 dMenu_Option_c::getSelectType() {
-    if (field_0x3ef < SelectType3) {
+    if (field_0x3ef < OPTION_SELECT(PROC_CHANGE_MOVE_e)) {
         return field_0x3ef;
     }
-    if (field_0x3f5 < SelectType3) {
+    if (field_0x3f5 < OPTION_SELECT(PROC_CHANGE_MOVE_e)) {
         return field_0x3f5;
     }
     return 0;
@@ -2237,7 +2481,7 @@ bool dMenu_Option_c::isRumbleSupported() {
 #if TARGET_PC
 bool dMenu_Option_c::pointerConfirmSelect() {
     dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Options);
-    for (u8 i = 0; i < SelectType3; ++i) {
+    for (u8 i = 0; i < (dusk::version::isRegionJpn() ? 3 : 2); ++i) {
         if (dusk::menu_pointer::hit_pane(mpMenuPane[i], 8.0f)) {
             dusk::menu_pointer::set_hover_target(i);
             return false;
@@ -2251,9 +2495,9 @@ bool dMenu_Option_c::pointerConfirmSelect() {
 
     field_0x3f7 = 1;
     field_0x3f5 = field_0x3ef;
-    field_0x3ef = SelectType4;
+    field_0x3ef = OPTION_SELECT(PROC_CONFIRM_OPEN_MOVE_e);
     dMeter2Info_set2DVibration();
-    (this->*init[field_0x3ef])();
+    (this->*init[OPTION_PROC(field_0x3ef)])();
     return true;
 }
 #endif
@@ -2261,13 +2505,44 @@ bool dMenu_Option_c::pointerConfirmSelect() {
 bool dMenu_Option_c::dpdMenuMove() {
 #if TARGET_PC
     dusk::menu_pointer::begin_context(dusk::menu_pointer::Context::Options);
-    for (u8 i = 0; i < SelectType3; ++i) {
+    for (u8 i = 0; i < (dusk::version::isRegionJpn() ? 3 : 2); ++i) {
         if (!dusk::menu_pointer::hit_pane(mpMenuPane[i], 8.0f)) {
             continue;
         }
         dusk::menu_pointer::set_hover_target(i);
+
+        u8 selectProc = 0;
+        if (dusk::version::isRegionJpn()) {
+            switch (i) {
+            case 0:
+                selectProc = PROC_ATTEN_e;
+                break;
+            case 1:
+                selectProc = PROC_RUBY_e;
+                break;
+            case 2:
+                selectProc = PROC_VIB_e;
+                break;
+            case 3:
+                selectProc = PROC_SOUND_e;
+                break;
+            }
+        } else {
+            switch (i) {
+            case 0:
+                selectProc = PROC_ATTEN_e;
+                break;
+            case 1:
+                selectProc = PROC_VIB_e;
+                break;
+            case 2:
+                selectProc = PROC_SOUND_e;
+                break;
+            }
+        }
+
         if (getSelectType() != i) {
-            field_0x3ef = i;
+            field_0x3ef = OPTION_SELECT(selectProc);
             setCursorPos(i);
             Z2GetAudioMgr()->seStart(Z2SE_SY_CURSOR_OPTION, NULL, 0, 0, 1.0f, 1.0f, -1.0f,
                                      -1.0f, 0);
@@ -2276,42 +2551,40 @@ bool dMenu_Option_c::dpdMenuMove() {
             return true;
         }
 
-        switch (i) {
-        case SelectType0:
+        switch (selectProc) {
+        case PROC_ATTEN_e:
             field_0x3e4 ^= 1;
             field_0x3da = 5;
-            field_0x3ef = SelectType3;
-            field_0x3f5 = SelectType0;
+            field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+            field_0x3f5 = OPTION_SELECT(PROC_ATTEN_e);
             Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f,
                                      -1.0f, 0);
             return true;
-        case SelectType1:
+        case PROC_RUBY_e:
+            if (field_0x3e5_JPN == 0) {
+                field_0x3e5_JPN = 1;
+                field_0x3da = 5;
+            } else if (field_0x3e5_JPN == 1) {
+                field_0x3e5_JPN = 0;
+                field_0x3da = 5;
+            }
+            field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+            field_0x3f5 = OPTION_SELECT(PROC_RUBY_e);
+            Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f, -1.0f, 0);
+            return true;
+        case PROC_VIB_e:
             if (isRumbleSupported()) {
                 field_0x3ea ^= 1;
                 if (field_0x3ea != 0) {
                     mDoCPd_c::startMotorWave(0, &field_0x3e0, JUTGamePad::CRumble::VAL_0, 0x3c);
                 }
                 field_0x3da = 5;
-                field_0x3ef = SelectType3;
-                field_0x3f5 = SelectType1;
+                field_0x3ef = OPTION_SELECT(PROC_CHANGE_MOVE_e);
+                field_0x3f5 = OPTION_SELECT(PROC_VIB_e);
                 Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f,
                                          -1.0f, 0);
             }
             return true;
-        case SelectType2:
-            if (field_0x3e9 == 0) {
-                field_0x3e9 = 2;
-            } else {
-                field_0x3e9--;
-            }
-            field_0x3da = 5;
-            mDoAud_setOutputMode(dMo_soundMode[field_0x3e9]);
-            setSoundMode(dMo_soundMode[field_0x3e9]);
-            field_0x3ef = SelectType3;
-            field_0x3f5 = SelectType2;
-            Z2GetAudioMgr()->seStart(Z2SE_SY_OPTION_SWITCH, NULL, 0, 0, 1.0f, 1.0f, -1.0f,
-                                     -1.0f, 0);
-            return true;
         }
     }
 #endif
@@ -2333,8 +2606,8 @@ void dMenu_Option_c::paneResize(u64 i_tag) {
 
 void dMenu_Option_c::initialize() {
     field_0x3e4 = dComIfGs_getOptAttentionType();
-#if VERSION == VERSION_GCN_JPN
-    if (dComIfGs_getOptRuby() == 0) {
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+    if (IF_DUSK(dusk::version::isRegionJpn() &&) dComIfGs_getOptRuby() == 0) {
         field_0x3e5_JPN = 1;
     } else {
         field_0x3e5_JPN = 0;
@@ -2352,8 +2625,10 @@ void dMenu_Option_c::initialize() {
         field_0x3ea = 0;
     }
     setAttenString();
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+    IF_DUSK_BLOCK(dusk::version::isRegionJpn())
     setRubyString();
+    IF_DUSK_BLOCK_END
 #endif
     setVibString();
     setSoundString();
diff --git a/src/d/d_menu_ring.cpp b/src/d/d_menu_ring.cpp
index c3f1ed2a4a..73832f8918 100644
--- a/src/d/d_menu_ring.cpp
+++ b/src/d/d_menu_ring.cpp
@@ -31,9 +31,11 @@
 
 #if TARGET_PC
 #include "dusk/game_clock.h"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/menu_pointer.h"
 #include "dusk/settings.h"
 #include "dusk/ui/touch_controls.hpp"
+#include "dusk/version.hpp"
 #endif
 
 typedef void (dMenu_Ring_c::*initFunc)();
@@ -330,17 +332,30 @@ dMenu_Ring_c::dMenu_Ring_c(JKRExpHeap* i_heap, STControl* i_stick, CSTControl* i
         mpScreen->search(MULTI_CHAR('yx_te_s3'))->hide();
         mpScreen->search(MULTI_CHAR('yx_te_s4'))->hide();
         mpScreen->search(MULTI_CHAR('yx_text'))->hide();
+        IF_DUSK_BLOCK(dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn)
         mpScreen->search(MULTI_CHAR('fyx_te_1'))->hide();
         mpScreen->search(MULTI_CHAR('fyx_te_2'))->hide();
         mpScreen->search(MULTI_CHAR('fyx_te_3'))->hide();
         mpScreen->search(MULTI_CHAR('fyx_te_4'))->hide();
         mpScreen->search(MULTI_CHAR('fyx_tex'))->hide();
+        IF_DUSK_BLOCK_END
         mpScreen->search(MULTI_CHAR('x_btn_n'))->hide();
         mpScreen->search(MULTI_CHAR('y_btn_n'))->hide();
     }
     mpString = JKR_NEW dMsgString_c();
     for (i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        J2DTextBox* fxy_TextBox;
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            fxy_TextBox = (J2DTextBox*)mpScreen->search(xy_text[i]);
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpScreen->search(fxy_text[i])->hide();
+            }
+        } else {
+            fxy_TextBox = (J2DTextBox*)mpScreen->search(fxy_text[i]);
+            mpScreen->search(xy_text[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         J2DTextBox* fxy_TextBox = (J2DTextBox*)mpScreen->search(xy_text[i]);
         mpScreen->search(fxy_text[i])->hide();
 #else
@@ -352,75 +367,87 @@ dMenu_Ring_c::dMenu_Ring_c(JKRExpHeap* i_heap, STControl* i_stick, CSTControl* i
         field_0x580[0] = mpString->getString(0x380, fxy_TextBox, NULL, NULL, NULL, 0);
     }
     for (i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
-    #if TARGET_PC
+#if TARGET_PC
         J2DTextBox* fc_TextBox;
-        if (dusk::getSettings().game.swapDirectSelect) {
-            fc_TextBox = (J2DTextBox*)mpScreen->search(c_text1[i]);
-            mpScreen->search(fc_text1[i])->hide();
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            if (dusk::getSettings().game.swapDirectSelect) {
+                fc_TextBox = (J2DTextBox*)mpScreen->search(c_text1[i]);
+                if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                    mpScreen->search(fc_text1[i])->hide();
+                }
+            } else {
+                fc_TextBox = (J2DTextBox*)mpScreen->search(c_text[i]);
+                if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                    mpScreen->search(fc_text[i])->hide();
+                }
+            }
         } else {
-            fc_TextBox = (J2DTextBox*)mpScreen->search(c_text[i]);
-            mpScreen->search(fc_text[i])->hide();
+            if (dusk::getSettings().game.swapDirectSelect) {
+                fc_TextBox = (J2DTextBox*)mpScreen->search(fc_text1[i]);
+                mpScreen->search(c_text1[i])->hide();
+            } else {
+                fc_TextBox = (J2DTextBox*)mpScreen->search(fc_text[i]);
+                mpScreen->search(c_text[i])->hide();
+            }
         }
-    #else
+#elif VERSION == VERSION_GCN_JPN
         J2DTextBox* fc_TextBox = (J2DTextBox*)mpScreen->search(c_text[i]);
         mpScreen->search(fc_text[i])->hide();
-    #endif
 #else
-    #if TARGET_PC
-        J2DTextBox* fc_TextBox;
-        if (dusk::getSettings().game.swapDirectSelect) {
-            fc_TextBox = (J2DTextBox*)mpScreen->search(fc_text1[i]);
-            mpScreen->search(c_text1[i])->hide();
-        } else {
-            fc_TextBox = (J2DTextBox*)mpScreen->search(fc_text[i]);
-            mpScreen->search(c_text[i])->hide();
-        }
-    #else
         J2DTextBox* fc_TextBox = (J2DTextBox*)mpScreen->search(fc_text[i]);
         mpScreen->search(c_text[i])->hide();
-    #endif
 #endif
         fc_TextBox->setFont(mDoExt_getMesgFont());
         fc_TextBox->setString(0x40, "");
         field_0x580[1] = mpString->getString(0x37F, fc_TextBox, NULL, NULL, NULL, 0);
     }
     for (i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
-    #if TARGET_PC
+#if TARGET_PC
         J2DTextBox* fc1_TextBox;
-        if (dusk::getSettings().game.swapDirectSelect) {
-            fc1_TextBox = (J2DTextBox*)mpScreen->search(c_text[i]);
-            mpScreen->search(fc_text[i])->hide();
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            if (dusk::getSettings().game.swapDirectSelect) {
+                fc1_TextBox = (J2DTextBox*)mpScreen->search(c_text[i]);
+                if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                    mpScreen->search(fc_text[i])->hide();
+                }
+            } else {
+                fc1_TextBox = (J2DTextBox*)mpScreen->search(c_text1[i]);
+                if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                    mpScreen->search(fc_text1[i])->hide();
+                }
+            }
         } else {
-            fc1_TextBox = (J2DTextBox*)mpScreen->search(c_text1[i]);
-            mpScreen->search(fc_text1[i])->hide();
+            if (dusk::getSettings().game.swapDirectSelect) {
+                fc1_TextBox = (J2DTextBox*)mpScreen->search(fc_text[i]);
+                mpScreen->search(c_text[i])->hide();
+            } else {
+                fc1_TextBox = (J2DTextBox*)mpScreen->search(fc_text1[i]);
+                mpScreen->search(c_text1[i])->hide();
+            }
         }
-    #else
+#elif VERSION == VERSION_GCN_JPN
         J2DTextBox* fc1_TextBox = (J2DTextBox*)mpScreen->search(c_text1[i]);
         mpScreen->search(fc_text1[i])->hide();
-    #endif
 #else
-    #if TARGET_PC
-        J2DTextBox* fc1_TextBox;
-        if (dusk::getSettings().game.swapDirectSelect) {
-            fc1_TextBox = (J2DTextBox*)mpScreen->search(fc_text[i]);
-            mpScreen->search(c_text[i])->hide();
-        } else {
-            fc1_TextBox = (J2DTextBox*)mpScreen->search(fc_text1[i]);
-            mpScreen->search(c_text1[i])->hide();
-        }
-    #else
         J2DTextBox* fc1_TextBox = (J2DTextBox*)mpScreen->search(fc_text1[i]);
         mpScreen->search(c_text1[i])->hide();
-    #endif
 #endif
         fc1_TextBox->setFont(mDoExt_getMesgFont());
         fc1_TextBox->setString(0x40, "");
         field_0x580[2] = mpString->getString(0x4CD, fc1_TextBox, NULL, NULL, NULL, 0);
     }
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            mpComboOffString[i] = (J2DTextBox*)mpScreen->search(t_on[i]);
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpScreen->search(ft_on[i])->hide();
+            }
+        } else {
+            mpComboOffString[i] = (J2DTextBox*)mpScreen->search(ft_on[i]);
+            mpScreen->search(t_on[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpComboOffString[i] = (J2DTextBox*)mpScreen->search(t_on[i]);
         mpScreen->search(ft_on[i])->hide();
 #else
@@ -432,7 +459,17 @@ dMenu_Ring_c::dMenu_Ring_c(JKRExpHeap* i_heap, STControl* i_stick, CSTControl* i
         mpString->getString(0x4D2, mpComboOffString[i], NULL, NULL, NULL, 0);
     }
     for (int i = 0; i < 5; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            mpBowArrowComboString[i] = (J2DTextBox*)mpScreen->search(t_off[i]);
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpScreen->search(ft_off[i])->hide();
+            }
+        } else {
+            mpBowArrowComboString[i] = (J2DTextBox*)mpScreen->search(ft_off[i]);
+            mpScreen->search(t_off[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpBowArrowComboString[i] = (J2DTextBox*)mpScreen->search(t_off[i]);
         mpScreen->search(ft_off[i])->hide();
 #else
@@ -463,7 +500,33 @@ dMenu_Ring_c::dMenu_Ring_c(JKRExpHeap* i_heap, STControl* i_stick, CSTControl* i
     mpNameParent = JKR_NEW CPaneMgr(mpCenterScreen, MULTI_CHAR('label_n'), 1, NULL);
     mpCircle = JKR_NEW CPaneMgr(mpCenterScreen, MULTI_CHAR('circle_n'), 2, NULL);
     J2DTextBox* textBox[4];
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isJpnOrLessThanWiiJpn()) {
+        textBox[0] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n04'));
+        textBox[1] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n05'));
+        textBox[2] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n06'));
+        textBox[3] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n07'));
+        if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+            J2DPane* pane = mpCenterScreen->search(MULTI_CHAR('fitem_n1'));
+            pane->mVisible = false;
+            pane = mpCenterScreen->search(MULTI_CHAR('fitem_n2'));
+            pane->mVisible = false;
+            pane = mpCenterScreen->search(MULTI_CHAR('fitem_n3'));
+            pane->mVisible = false;
+            pane = mpCenterScreen->search(MULTI_CHAR('fitem_n4'));
+            pane->mVisible = false;
+        }
+    } else {
+        textBox[0] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('fitem_n1'));
+        textBox[1] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('fitem_n2'));
+        textBox[2] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('fitem_n3'));
+        textBox[3] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('fitem_n4'));
+        mpCenterScreen->search(MULTI_CHAR('item_n04'));
+        mpCenterScreen->search(MULTI_CHAR('item_n05'));
+        mpCenterScreen->search(MULTI_CHAR('item_n06'));
+        mpCenterScreen->search(MULTI_CHAR('item_n07'));
+    }
+#elif VERSION == VERSION_GCN_JPN
     textBox[0] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n04'));
     textBox[1] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n05'));
     textBox[2] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n06'));
@@ -697,13 +760,13 @@ void dMenu_Ring_c::_draw() {
         f32 simX = 0.0f;
         f32 simY = 0.0f;
         bool restoreSimPos = false;
-        if (dusk::frame_interp::is_enabled() && mAlphaRate >= 1.0f) {
+        if (dusk::interp::is_enabled() && mAlphaRate >= 1.0f) {
             simX = mpDrawCursor->getPositionX();
             simY = mpDrawCursor->getPositionY();
 
             const bool isAngular = (mStatus == STATUS_MOVE) && !mDirectSelectActive;
 
-            if (dusk::frame_interp::get_ui_tick_pending()) {
+            if (dusk::interp::get_ui_tick_pending()) {
                 mCursorInterpPrevX = mCursorInterpCurrX;
                 mCursorInterpPrevY = mCursorInterpCurrY;
                 mCursorInterpPrevAngle = mCursorInterpCurrAngle;
@@ -727,7 +790,7 @@ void dMenu_Ring_c::_draw() {
                 }
             }
             if (mCursorInterpInit) {
-                const f32 step = dusk::frame_interp::get_interpolation_step();
+                const f32 step = dusk::interp::get_interpolation_step();
                 if (mCursorInterpPrevAngular && mCursorInterpCurrAngular) {
                     const s16 delta = mCursorInterpCurrAngle - mCursorInterpPrevAngle;
                     const s16 lerpedAngle = mCursorInterpPrevAngle + (s16)(delta * step);
@@ -1245,7 +1308,13 @@ void dMenu_Ring_c::setScale() {
 
 void dMenu_Ring_c::setNameString(u32 i_stringID) {
     J2DTextBox* textBox[4];
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    const bool useDomestic = dusk::version::isJpnOrLessThanWiiJpn();
+    textBox[0] = (J2DTextBox*)mpCenterScreen->search(useDomestic ? MULTI_CHAR('item_n04') : MULTI_CHAR('fitem_n1'));
+    textBox[1] = (J2DTextBox*)mpCenterScreen->search(useDomestic ? MULTI_CHAR('item_n05') : MULTI_CHAR('fitem_n2'));
+    textBox[2] = (J2DTextBox*)mpCenterScreen->search(useDomestic ? MULTI_CHAR('item_n06') : MULTI_CHAR('fitem_n3'));
+    textBox[3] = (J2DTextBox*)mpCenterScreen->search(useDomestic ? MULTI_CHAR('item_n07') : MULTI_CHAR('fitem_n4'));
+#elif VERSION == VERSION_GCN_JPN
     textBox[0] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n04'));
     textBox[1] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n05'));
     textBox[2] = (J2DTextBox*)mpCenterScreen->search(MULTI_CHAR('item_n06'));
@@ -1740,7 +1809,7 @@ void dMenu_Ring_c::drawSelectItem() {
         if (field_0x674[i] != 0) {
 #if TARGET_PC
             mSelectItemSlideElapsed[i] += dusk::game_clock::consume_interval(this);
-            const f32 u = std::min(mSelectItemSlideElapsed[i] / dusk::game_clock::period_for_original_frames(10.0f), 1.0f);
+            const f32 u = std::min(mSelectItemSlideElapsed[i] / (dusk::game_clock::kSimPeriod * 10.0f), 1.0f);
             if (u >= 1.0f) {
                 setSelectItemForce(i);
             } else {
diff --git a/src/d/d_menu_save.cpp b/src/d/d_menu_save.cpp
index f97e50d331..a2b1a5dd2c 100644
--- a/src/d/d_menu_save.cpp
+++ b/src/d/d_menu_save.cpp
@@ -1,30 +1,32 @@
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_menu_save.h"
-#include "JSystem/JKernel/JKRExpHeap.h"
-#include "JSystem/JKernel/JKRMemArchive.h"
 #include <cstdio>
 #include <cstring>
+#include "JSystem/J2DGraph/J2DAnmLoader.h"
+#include "JSystem/JKernel/JKRExpHeap.h"
+#include "JSystem/JKernel/JKRMemArchive.h"
 #include "d/d_com_inf_game.h"
-#include "d/d_lib.h"
-#include "d/d_select_cursor.h"
 #include "d/d_file_sel_info.h"
 #include "d/d_file_sel_warning.h"
+#include "d/d_lib.h"
+#include "d/d_menu_save.h"
 #include "d/d_meter2_info.h"
+#include "d/d_msg_scrn_explain.h"
 #include "d/d_msg_string.h"
+#include "d/d_select_cursor.h"
+#include "f_op/f_op_msg_mng.h"
 #include "m_Do/m_Do_MemCard.h"
 #include "m_Do/m_Do_MemCardRWmng.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_graphic.h"
-#include "d/d_msg_scrn_explain.h"
-#include "JSystem/J2DGraph/J2DAnmLoader.h"
-#include "f_op/f_op_msg_mng.h"
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/menu_pointer.h"
+#include "dusk/mods/svc/save.hpp"
 #include "dusk/settings.h"
+#include "dusk/version.hpp"
 #endif
 
 static int SelStartFrameTbl[3] = {
@@ -179,7 +181,15 @@ void dMenu_save_c::screenSet() {
     static u64 l_tagName10[2] = {MULTI_CHAR('w_no_g'), MULTI_CHAR('w_yes_g')};
     static u64 l_tagName11[2] = {MULTI_CHAR('w_no_gr'), MULTI_CHAR('w_yes_gr')};
     static u64 l_tagName12[3] = {MULTI_CHAR('w_bk_l00'), MULTI_CHAR('w_bk_l01'), MULTI_CHAR('w_bk_l02')};
-#if VERSION == VERSION_GCN_JPN
+
+#if TARGET_PC
+    static u64 l_tagName21_jpn[2] = {MULTI_CHAR('w_tabi_s'), MULTI_CHAR('w_tabi_x')};
+    static u64 l_tagName20_jpn[2] = {MULTI_CHAR('w_er_msg'), MULTI_CHAR('w_er_msR')};
+    static u64 l_tagName21[2] = {MULTI_CHAR('t_for'), MULTI_CHAR('t_for1')};
+    static u64 l_tagName211[10] = {MULTI_CHAR('tmoyou00'), MULTI_CHAR('tmoyou01'), MULTI_CHAR('tmoyou02'), MULTI_CHAR('tmoyou03'), MULTI_CHAR('tmoyou04'),
+                                MULTI_CHAR('tmoyou05'), MULTI_CHAR('tmoyou06'), MULTI_CHAR('tmoyou07'), MULTI_CHAR('tmoyou08'), MULTI_CHAR('tmoyou09')};
+    static u64 l_tagName20[2] = {MULTI_CHAR('er_for0'), MULTI_CHAR('er_for1')};
+#elif VERSION == VERSION_GCN_JPN
     static u64 l_tagName21[2] = {MULTI_CHAR('w_tabi_s'), MULTI_CHAR('w_tabi_x')};
     static u64 l_tagName20[2] = {MULTI_CHAR('w_er_msg'), MULTI_CHAR('w_er_msR')};
 #else
@@ -188,6 +198,7 @@ void dMenu_save_c::screenSet() {
                                 MULTI_CHAR('tmoyou05'), MULTI_CHAR('tmoyou06'), MULTI_CHAR('tmoyou07'), MULTI_CHAR('tmoyou08'), MULTI_CHAR('tmoyou09')};
     static u64 l_tagName20[2] = {MULTI_CHAR('er_for0'), MULTI_CHAR('er_for1')};
 #endif
+
     static u64 l_tagName13[3] = {MULTI_CHAR('w_dat_i0'), MULTI_CHAR('w_dat_i1'), MULTI_CHAR('w_dat_i2')};
     static u8 l_msgNum0[2] = {0x08, 0x07};
     static u8 l_msgNum[2] = {0x54, 0x55};
@@ -221,7 +232,15 @@ void dMenu_save_c::screenSet() {
     mpNoYes[1] = JKR_NEW CPaneMgr(mSaveSel.Scr, MULTI_CHAR('w_yes_n'), 0, NULL);
 
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpNoYesTxt[i] = JKR_NEW CPaneMgr(mSaveSel.Scr, l_tagName000[i], 0, NULL);
+            mSaveSel.Scr->search(l_tagName000U[i])->hide();
+        } else {
+            mpNoYesTxt[i] = JKR_NEW CPaneMgr(mSaveSel.Scr, l_tagName000U[i], 0, NULL);
+            mSaveSel.Scr->search(l_tagName000[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpNoYesTxt[i] = JKR_NEW CPaneMgr(mSaveSel.Scr, l_tagName000[i], 0, NULL);
         mSaveSel.Scr->search(l_tagName000U[i])->hide();
 #else
@@ -240,7 +259,15 @@ void dMenu_save_c::screenSet() {
 
     mpBBtnIcon = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('w_nbbtn'), 2, NULL);
     mpABtnIcon = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('w_nabtn'), 2, NULL);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpBackTxt = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('w_modo'), 2, NULL);
+        mpConfirmTxt = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('w_kete'), 2, NULL);
+    } else {
+        mpBackTxt = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('f_modo'), 2, NULL);
+        mpConfirmTxt = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('f_kete'), 2, NULL);
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpBackTxt = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('w_modo'), 2, NULL);
     mpConfirmTxt = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, MULTI_CHAR('w_kete'), 2, NULL);
 #else
@@ -255,7 +282,15 @@ void dMenu_save_c::screenSet() {
 
     for (int i = 0; i < 2; i++) {
         J2DTextBox* tbox[2];
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            tbox[i] = (J2DTextBox*)mSaveSel.Scr->search(l_tagName00[i]);
+            mSaveSel.Scr->search(l_tagName00U[i])->hide();
+        } else {
+            tbox[i] = (J2DTextBox*)mSaveSel.Scr->search(l_tagName00U[i]);
+            mSaveSel.Scr->search(l_tagName00[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         tbox[i] = (J2DTextBox*)mSaveSel.Scr->search(l_tagName00[i]);
         mSaveSel.Scr->search(l_tagName00U[i])->hide();
 #else
@@ -330,7 +365,19 @@ void dMenu_save_c::screenSet() {
         mpBookWaku[i]->setAlpha(0);
     }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mSaveSel.Scr->search(MULTI_CHAR('t_for'))->hide();
+        mSaveSel.Scr->search(MULTI_CHAR('t_for1'))->hide();
+    } else {
+        mSaveSel.Scr->search(MULTI_CHAR('w_tabi_s'))->hide();
+        mSaveSel.Scr->search(MULTI_CHAR('w_tabi_x'))->hide();
+
+        for (int i = 0; i < 10; i++) {
+            mSaveSel.Scr->search(l_tagName211[i])->hide();
+        }
+    }
+#elif VERSION == VERSION_GCN_JPN
     mSaveSel.Scr->search(MULTI_CHAR('t_for'))->hide();
     mSaveSel.Scr->search(MULTI_CHAR('t_for1'))->hide();
 #else
@@ -343,11 +390,21 @@ void dMenu_save_c::screenSet() {
 #endif
 
     for (int i = 0; i < 2; i++) {
-        mpHeaderTxtPane[i] = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, l_tagName21[i], 0, NULL);
+        mpHeaderTxtPane[i] = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, DUSK_IF_ELSE(dusk::version::isRegionJpn() ? l_tagName21_jpn[i] : l_tagName21[i], l_tagName21[i]), 0, NULL);
 
         ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setFont(mSaveSel.font[0]);
         ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setString(0x100, "");
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
+            ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
+            ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
+        } else {
+            ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setFontSize(19.0f, 19.0f);
+            ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setLineSpace(20.0f);
+            ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setCharSpace(0.0f);
+        }
+#elif VERSION == VERSION_GCN_JPN
         ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
         ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
         ((J2DTextBox*)mpHeaderTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
@@ -364,7 +421,15 @@ void dMenu_save_c::screenSet() {
     mHeaderTxtType = 0;
 
     field_0xb4 = mSaveSel.Scr->search(MULTI_CHAR('w_er_n'));
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mSaveSel.Scr->search(MULTI_CHAR('er_for0'))->hide();
+        mSaveSel.Scr->search(MULTI_CHAR('er_for1'))->hide();
+    } else {
+        mSaveSel.Scr->search(MULTI_CHAR('w_er_msg'))->hide();
+        mSaveSel.Scr->search(MULTI_CHAR('w_er_msR'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     mSaveSel.Scr->search(MULTI_CHAR('er_for0'))->hide();
     mSaveSel.Scr->search(MULTI_CHAR('er_for1'))->hide();
 #else
@@ -373,7 +438,9 @@ void dMenu_save_c::screenSet() {
 #endif
 
     for (int i = 0; i < 2; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        mpErrTxtPane[i] = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, DUSK_IF_ELSE(dusk::version::isRegionJpn() ? l_tagName20_jpn[i] : l_tagName20[i], l_tagName20[i]), 0, NULL);
+#elif VERSION == VERSION_GCN_JPN
         mpErrTxtPane[i] = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, l_tagName20[i], 0, NULL);
 #else
         mpErrTxtPane[i] = JKR_NEW CPaneMgrAlpha(mSaveSel.Scr, l_tagName20[i], 0, NULL);
@@ -381,7 +448,18 @@ void dMenu_save_c::screenSet() {
 
         ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setFont(mSaveSel.font[0]);
         ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setString(0x200, "");
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
+        } else {
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->resize(440.0f, 198.0f);
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setLineSpace(21.0f);
+            ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setCharSpace(1.0f);
+        }
+#elif VERSION == VERSION_GCN_JPN
         ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setFontSize(21.0f, 21.0f);
         ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setLineSpace(22.0f);
         ((J2DTextBox*)mpErrTxtPane[i]->getPanePtr())->setCharSpace(2.0f);
@@ -656,7 +734,7 @@ void dMenu_save_c::_delete() {
 }
 
 typedef void (dMenu_save_c::*menuProcFunc)();
-menuProcFunc MenuSaveProc[62] = {
+DUSK_GAME_DATA menuProcFunc MenuSaveProc[62] = {
     &dMenu_save_c::saveQuestion,
     &dMenu_save_c::saveQuestion2,
     &dMenu_save_c::saveQuestion21,
@@ -750,44 +828,38 @@ void dMenu_save_c::saveSelAnm() {
 }
 
 void dMenu_save_c::selFileWakuAnm() {
-#if TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        mFileWakuAnmFrame += 2;
-        if (mFileWakuAnmFrame >= mpFileWakuAnm->getFrameMax()) {
-            mFileWakuAnmFrame -= mpFileWakuAnm->getFrameMax();
-        }
-
-        mFileWakuRotAnmFrame += 2;
-        if (mFileWakuRotAnmFrame >= mpFileWakuRotAnm->getFrameMax()) {
-            mFileWakuRotAnmFrame -= mpFileWakuRotAnm->getFrameMax();
-        }
+    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+    mFileWakuAnmFrame += 2;
+    if (mFileWakuAnmFrame >= mpFileWakuAnm->getFrameMax()) {
+        mFileWakuAnmFrame -= mpFileWakuAnm->getFrameMax();
     }
+
+    mFileWakuRotAnmFrame += 2;
+    if (mFileWakuRotAnmFrame >= mpFileWakuRotAnm->getFrameMax()) {
+        mFileWakuRotAnmFrame -= mpFileWakuRotAnm->getFrameMax();
+    }
+    IF_DUSK_BLOCK_END
     mpFileWakuAnm->setFrame(mFileWakuAnmFrame);
     mpFileWakuRotAnm->setFrame(mFileWakuRotAnmFrame);
 }
 
 void dMenu_save_c::bookIconAnm() {
-#if TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        field_0x154 += 2;
-        if (field_0x154 >= field_0x150->getFrameMax()) {
-            field_0x154 -= field_0x150->getFrameMax();
-        }
-
-        field_0x15c += 2;
-        if (field_0x15c >= field_0x158->getFrameMax()) {
-            field_0x15c -= field_0x158->getFrameMax();
-        }
-
-        field_0x164 += 2;
-        if (field_0x164 >= field_0x160->getFrameMax()) {
-            field_0x164 -= field_0x160->getFrameMax();
-        }
+    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+    field_0x154 += 2;
+    if (field_0x154 >= field_0x150->getFrameMax()) {
+        field_0x154 -= field_0x150->getFrameMax();
     }
+
+    field_0x15c += 2;
+    if (field_0x15c >= field_0x158->getFrameMax()) {
+        field_0x15c -= field_0x158->getFrameMax();
+    }
+
+    field_0x164 += 2;
+    if (field_0x164 >= field_0x160->getFrameMax()) {
+        field_0x164 -= field_0x160->getFrameMax();
+    }
+    IF_DUSK_BLOCK_END
     field_0x150->setFrame(field_0x154);
     field_0x158->setFrame(field_0x15c);
     field_0x160->setFrame(field_0x164);
@@ -1374,6 +1446,12 @@ void dMenu_save_c::memCardDataSaveWait() {
 
     mCmdState = g_mDoMemCd_control.SaveSync();
     if (mCmdState != 0) {
+#if TARGET_PC
+        if (mCmdState == 1) {
+                dusk::mods::svc::save_slot_written(
+                    mSelectedFile, mSaveBuffer + mSelectedFile * QUEST_LOG_SIZE);
+            }
+#endif
         printf("save cmdState %d\n", mCmdState);
         mMenuProc = PROC_MEMCARD_DATA_SAVE_WAIT2;
     }
@@ -2468,7 +2546,23 @@ bool dMenu_save_c::selectDataBaseMoveAnm() {
         mpSelectMoveBase->getPanePtr()->animationTransform();
         return false;
     } else {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            if (mDataBaseMoveAnmFrame == 33) {
+                field_0x64 = 1;
+            } else {
+                field_0x64 = 0;
+            }
+            field_0x65 = 0;
+        } else {
+            if (mDataBaseMoveAnmFrame == 33) {
+                field_0x64 = 1;
+                field_0x65 = 0;
+            } else {
+                field_0x64 = 0;
+            }
+        }
+#elif VERSION == VERSION_GCN_JPN
         if (mDataBaseMoveAnmFrame == 33) {
             field_0x64 = 1;
         } else {
diff --git a/src/d/d_menu_skill.cpp b/src/d/d_menu_skill.cpp
index 0c970e76c3..90d4a3f92b 100644
--- a/src/d/d_menu_skill.cpp
+++ b/src/d/d_menu_skill.cpp
@@ -18,6 +18,8 @@
 #include "m_Do/m_Do_graphic.h"
 #include <cstring>
 
+#include "dusk/version.hpp"
+
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
 #endif
@@ -467,7 +469,27 @@ void dMenu_Skill_c::screenSetMenu() {
     mpParent = JKR_NEW CPaneMgr(mpMenuScreen, MULTI_CHAR('n_all'), 2, NULL);
     mpParent->setAlphaRate(0.0f);
     for (int i = 0; i < 7; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpFTagPicture[i][0] = (J2DTextBox*)mpMenuScreen->search(tag_sub0[i]);
+            mpFTagPicture[i][1] = (J2DTextBox*)mpMenuScreen->search(tag_sub1[i]);
+            mpFTagPicture[i][2] = (J2DTextBox*)mpMenuScreen->search(tag_name0[i]);
+            mpFTagPicture[i][3] = (J2DTextBox*)mpMenuScreen->search(tag_name1[i]);
+            mpMenuScreen->search(ftag_sub0[i])->hide();
+            mpMenuScreen->search(ftag_sub1[i])->hide();
+            mpMenuScreen->search(ftag_name0[i])->hide();
+            mpMenuScreen->search(ftag_name1[i])->hide();
+        } else {
+            mpFTagPicture[i][0] = (J2DTextBox*)mpMenuScreen->search(ftag_sub0[i]);
+            mpFTagPicture[i][1] = (J2DTextBox*)mpMenuScreen->search(ftag_sub1[i]);
+            mpFTagPicture[i][2] = (J2DTextBox*)mpMenuScreen->search(ftag_name0[i]);
+            mpFTagPicture[i][3] = (J2DTextBox*)mpMenuScreen->search(ftag_name1[i]);
+            mpMenuScreen->search(tag_sub0[i])->hide();
+            mpMenuScreen->search(tag_sub1[i])->hide();
+            mpMenuScreen->search(tag_name0[i])->hide();
+            mpMenuScreen->search(tag_name1[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpFTagPicture[i][0] = (J2DTextBox*)mpMenuScreen->search(tag_sub0[i]);
         mpFTagPicture[i][1] = (J2DTextBox*)mpMenuScreen->search(tag_sub1[i]);
         mpFTagPicture[i][2] = (J2DTextBox*)mpMenuScreen->search(tag_name0[i]);
@@ -522,7 +544,16 @@ void dMenu_Skill_c::screenSetMenu() {
             mSelectWhite[i] = mpFTagPicture[1][i]->getWhite();
         }
     }
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    J2DTextBox* textBox;
+    if (dusk::version::isRegionJpn()) {
+        textBox = (J2DTextBox*)mpMenuScreen->search(MULTI_CHAR('t_t00'));
+        mpMenuScreen->search(MULTI_CHAR('f_t00'))->hide();
+    } else {
+        textBox = (J2DTextBox*)mpMenuScreen->search(MULTI_CHAR('f_t00'));
+        mpMenuScreen->search(MULTI_CHAR('t_t00'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     J2DTextBox* textBox = (J2DTextBox*)mpMenuScreen->search(MULTI_CHAR('t_t00'));
     mpMenuScreen->search(MULTI_CHAR('f_t00'))->hide();
 #else
@@ -551,7 +582,15 @@ void dMenu_Skill_c::screenSetLetter() {
     mpLetterScreen = JKR_NEW J2DScreen();
     mpLetterScreen->setPriority("zelda_ougi_info.blo", 0x20000, mpArchive);
     dPaneClass_showNullPane(mpLetterScreen);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpTextPane = JKR_NEW CPaneMgr(mpLetterScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+        mpLetterScreen->search(MULTI_CHAR('n_e4line'))->hide();
+    } else {
+        mpTextPane = JKR_NEW CPaneMgr(mpLetterScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+        mpLetterScreen->search(MULTI_CHAR('n_3line'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpTextPane = JKR_NEW CPaneMgr(mpLetterScreen, MULTI_CHAR('mg_3line'), 0, NULL);
     mpLetterScreen->search(MULTI_CHAR('n_e4line'))->hide();
 #else
@@ -564,7 +603,15 @@ void dMenu_Skill_c::screenSetLetter() {
     J2DTextBox* paneString = (J2DTextBox*)mpTextPane->getPanePtr();
     paneString->setString(0x200, "");
     for (int i = 0; i < 4; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpNameString[i] = (J2DTextBox*)mpLetterScreen->search(name_tag[i]);
+            mpLetterScreen->search(fame_tag[i])->hide();
+        } else {
+            mpNameString[i] = (J2DTextBox*)mpLetterScreen->search(fame_tag[i]);
+            mpLetterScreen->search(name_tag[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpNameString[i] = (J2DTextBox*)mpLetterScreen->search(name_tag[i]);
         mpLetterScreen->search(fame_tag[i])->hide();
 #else
diff --git a/src/d/d_menu_window.cpp b/src/d/d_menu_window.cpp
index 2be79d053e..80f374cf46 100644
--- a/src/d/d_menu_window.cpp
+++ b/src/d/d_menu_window.cpp
@@ -26,8 +26,8 @@
 #include "f_op/f_op_overlap_mng.h"
 #include "m_Do/m_Do_controller_pad.h"
 
-#ifdef TARGET_PC
-#include "dusk/frame_interpolation.h"
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
 #endif
 
 class dDlst_MENU_CAPTURE_c : public dDlst_base_c {
@@ -123,7 +123,13 @@ public:
 #endif
     }
 
-    void setCaptureFlag() { mFlag = 1; }
+    void setCaptureFlag() {
+        mFlag = 1;
+    #ifdef TARGET_PC
+        dusk::interp::request_presentation_sync();
+    #endif
+    }
+
     bool checkDraw() { return mFlag; }
     u8 getAlpha() { return mAlpha; }
     u8 getTopFlag() { return mTopFlag; }
@@ -219,7 +225,7 @@ static BOOL dMw_isMenuRing() {
 }
 
 typedef void (dMw_c::*initFunc)(u8);
-initFunc init_proc[] = {
+DUSK_GAME_DATA initFunc init_proc[] = {
     &dMw_c::key_wait_init,
     &dMw_c::ring_open_init,
     &dMw_c::ring_move_init,
@@ -258,7 +264,7 @@ initFunc init_proc[] = {
 };
 
 typedef void (dMw_c::*procFunc)();
-procFunc move_proc[] = {
+DUSK_GAME_DATA procFunc move_proc[] = {
     &dMw_c::key_wait_proc,
     &dMw_c::ring_open_proc,
     &dMw_c::ring_move_proc,
@@ -1092,10 +1098,6 @@ void dMw_c::dMw_ring_create(u8 i_origin) {
     }
 
     mpCapture->setCaptureFlag();
-
-#ifdef TARGET_PC
-    dusk::frame_interp::request_presentation_sync();
-#endif
 }
 
 bool dMw_c::dMw_ring_delete() {
diff --git a/src/d/d_menu_window_HIO.cpp b/src/d/d_menu_window_HIO.cpp
index 053aeaf837..6302b7b897 100644
--- a/src/d/d_menu_window_HIO.cpp
+++ b/src/d/d_menu_window_HIO.cpp
@@ -1321,6 +1321,6 @@ void dMw_DHIO_c::bitCheck() {
 }
 #endif
 
-dMw_HIO_c g_mwHIO;
+DUSK_GAME_DATA dMw_HIO_c g_mwHIO;
 
-dMw_DHIO_c g_mwDHIO;
+DUSK_GAME_DATA dMw_DHIO_c g_mwDHIO;
diff --git a/src/d/d_meter2.cpp b/src/d/d_meter2.cpp
index e0855461d4..a90124ebb6 100644
--- a/src/d/d_meter2.cpp
+++ b/src/d/d_meter2.cpp
@@ -27,6 +27,15 @@
 #if TARGET_PC
 #include "dusk/memory.h"
 #include "dusk/settings.h"
+
+namespace {
+
+// Reads the user HUD scale setting, clamped to a safe range.
+f32 dGetUserHudScale() {
+    return std::clamp(dusk::getSettings().game.hudScale.getValue(), 0.5f, 2.0f);
+}
+
+}  // namespace
 #endif
 
 int dMeter2_c::_create() {
@@ -597,7 +606,8 @@ void dMeter2_c::moveLife() {
             life_count = (dComIfGs_getMaxLife() / 5) * 4;
         }
 
-        s16 new_life = dComIfGs_getLife() + dComIfGp_getItemLifeCount();
+        DUSK_IF_ELSE(int, s16) new_life = dComIfGs_getLife() + dComIfGp_getItemLifeCount(); // prevent an overflow with really large damage values
+
         if (new_life > life_count) {
             new_life = life_count;
         } else if (new_life < 0) {
@@ -669,9 +679,7 @@ void dMeter2_c::moveLife() {
     }
 
 #if TARGET_PC
-    const f32 lifeGaugeScale =
-        g_drawHIO.mLifeParentScale *
-        std::clamp(dusk::getSettings().game.hudScale.getValue(), 0.5f, 2.0f);
+    const f32 lifeGaugeScale = g_drawHIO.mLifeParentScale * dGetUserHudScale();
 #else
     const f32 lifeGaugeScale = g_drawHIO.mLifeParentScale;
 #endif
@@ -1108,8 +1116,13 @@ void dMeter2_c::moveRupee() {
         }
     }
 
-    if (mRupeeKeyScale != g_drawHIO.mRupeeKeyScale) {
-        mRupeeKeyScale = g_drawHIO.mRupeeKeyScale;
+#if TARGET_PC
+    const f32 rupeeKeyScale = g_drawHIO.mRupeeKeyScale * dGetUserHudScale();
+#else
+    const f32 rupeeKeyScale = g_drawHIO.mRupeeKeyScale;
+#endif
+    if (mRupeeKeyScale != rupeeKeyScale) {
+        mRupeeKeyScale = rupeeKeyScale;
         draw_rupee = true;
     }
 
@@ -1207,8 +1220,13 @@ void dMeter2_c::moveKey() {
         }
     }
 
-    if (mKeyScale != g_drawHIO.mKeyScale) {
-        mKeyScale = g_drawHIO.mKeyScale;
+#if TARGET_PC
+    const f32 keyScale = g_drawHIO.mKeyScale * dGetUserHudScale();
+#else
+    const f32 keyScale = g_drawHIO.mKeyScale;
+#endif
+    if (mKeyScale != keyScale) {
+        mKeyScale = keyScale;
         draw_key = true;
     }
 
@@ -2139,8 +2157,13 @@ void dMeter2_c::moveButtonCross() {
         draw_cross = true;
     }
 
-    if (mButtonCrossScale != g_drawHIO.mButtonCrossScale) {
-        mButtonCrossScale = g_drawHIO.mButtonCrossScale;
+#if TARGET_PC
+    const f32 buttonCrossScale = g_drawHIO.mButtonCrossScale * dGetUserHudScale();
+#else
+    const f32 buttonCrossScale = g_drawHIO.mButtonCrossScale;
+#endif
+    if (mButtonCrossScale != buttonCrossScale) {
+        mButtonCrossScale = buttonCrossScale;
         draw_cross = true;
     }
 
diff --git a/src/d/d_meter2_draw.cpp b/src/d/d_meter2_draw.cpp
index eeebe65924..742fe6762d 100644
--- a/src/d/d_meter2_draw.cpp
+++ b/src/d/d_meter2_draw.cpp
@@ -20,12 +20,14 @@
 #include "d/d_msg_class.h"
 #include "d/d_msg_object.h"
 #include "d/d_pane_class.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
 
 #if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/settings.h"
 #include "dusk/ui/icon_provider.hpp"
+#include "dusk/version.hpp"
+
 #include <algorithm>
 
 namespace {
@@ -57,7 +59,29 @@ void dAnchorHudScale(CPaneMgr* i_pane, HudCorner i_corner, f32* io_x, f32* io_y,
 
 }  // namespace
 #endif
+
 dMeter2Draw_c::dMeter2Draw_c(JKRExpHeap* mp_heap) {
+#if TARGET_PC
+    // correct hio data here because we can't do runtime disc checks in sinit data constructors
+    if (dusk::version::isRegionJpn()) {
+        g_drawHIO.mButtonATextSpacing = -2.0f;
+        for (int i = 0; i < 6; i++) {
+            static f32 const finfoPosX_jpn[6] = {-27.0f, 0.0f, -12.0f, 0.0f, -12.0f, -32.8f};
+            static f32 const fishnPosX_jpn[6] = {-27.0f, 0.0f, -12.0f, 0.0f, -12.0f, -32.8f};
+            g_drawHIO.mFishListScreen.mFishCountSizePosX[i] = finfoPosX_jpn[i];
+            g_drawHIO.mFishListScreen.mFishInfoPosX[i] = fishnPosX_jpn[i];
+        }
+    } else {
+        g_drawHIO.mButtonATextSpacing = 1.0f;
+        for (int i = 0; i < 6; i++) {
+            static f32 const finfoPosX[6] = {-17.0f, 0.0f, -14.0f, 0.0f, -12.0f, -32.8f};
+            static f32 const fishnPosX[6] = {-17.0f, 0.0f, -14.0f, 0.0f, -12.0f, -32.8f};
+            g_drawHIO.mFishListScreen.mFishCountSizePosX[i] = finfoPosX[i];
+            g_drawHIO.mFishListScreen.mFishInfoPosX[i] = fishnPosX[i];
+        }
+    }
+#endif
+
     OS_REPORT("enter dMeter2Draw_c::dMeter2Draw_c(JKRExpHeap *mp_heap)\n");
 
     heap = mp_heap;
@@ -160,7 +184,8 @@ dMeter2Draw_c::dMeter2Draw_c(JKRExpHeap* mp_heap) {
     }
 
     J2DTextBox::TFontSize font_size;
-#if VERSION != VERSION_GCN_JPN
+#if TARGET_PC || VERSION != VERSION_GCN_JPN
+    IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
     font_size.mSizeX = 17.0f;
     font_size.mSizeY = 20.0f;
     for (int i = 0; i < 5; i++) {
@@ -170,6 +195,21 @@ dMeter2Draw_c::dMeter2Draw_c(JKRExpHeap* mp_heap) {
         static_cast<J2DTextBox*>(mpXYText[i][1]->getPanePtr())->setFontSize(font_size);
         static_cast<J2DTextBox*>(mpXYText[i][2]->getPanePtr())->setFontSize(font_size);
     }
+    IF_DUSK_BLOCK_END
+#endif
+
+#if TARGET_PC
+    if (dusk::version::isLessThanWiiJpn()) {
+        if (J2DPicture* b_btn = static_cast<J2DPicture*>(mpScreen->search(MULTI_CHAR('b_btn')))) {
+            b_btn->setAlpha(255);
+            b_btn->setWhite(JUtility::TColor(195, 63, 63, 255));
+        }
+
+        for (int i = 0; i < 5; i++) {
+            static_cast<J2DTextBox*>(mpXYText[i][0]->getPanePtr())->setCharSpace(0.0f);
+            static_cast<J2DTextBox*>(mpXYText[i][1]->getPanePtr())->setCharSpace(0.0f);
+        }
+    }
 #endif
 
     init();
@@ -729,42 +769,38 @@ void dMeter2Draw_c::draw() {
         if (field_0x756 >= 0) {
             var_f29 = g_drawHIO.mLightDrop.mDropPikariAnimSpeed_Completed;
             int temp_r5_2 = g_drawHIO.mLightDrop.mPikariInterval * 15;
-#ifdef TARGET_PC
-            // FRAME INTERP NOTE: Set even if not advancing
-            var_f28 = g_drawHIO.mLightDrop.mPikariScaleComplete;
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                if (field_0x756 <= temp_r5_2) {
-                    int temp_r4 = (field_0x756 % g_drawHIO.mLightDrop.mPikariInterval);
-                    int temp_r3_5 = field_0x756 / g_drawHIO.mLightDrop.mPikariInterval;
+            IF_DUSK(var_f28 = g_drawHIO.mLightDrop.mPikariScaleComplete);  // FRAME INTERP NOTE: Set even if not advancing
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            if (field_0x756 <= temp_r5_2) {
+                int temp_r4 = (field_0x756 % g_drawHIO.mLightDrop.mPikariInterval);
+                int temp_r3_5 = field_0x756 / g_drawHIO.mLightDrop.mPikariInterval;
 
-                    if (temp_r4 == 0 && field_0x62c[temp_r3_5] == 0.0f) {
-                        field_0x62c[temp_r3_5] = 18.0f;
-                    }
+                if (temp_r4 == 0 && field_0x62c[temp_r3_5] == 0.0f) {
+                    field_0x62c[temp_r3_5] = 18.0f;
+                }
 
-                    var_f28 = g_drawHIO.mLightDrop.mPikariScaleComplete;
-                    field_0x756++;
-                } else {
-                    int temp_r5_3 = temp_r5_2 + 1;
+                var_f28 = g_drawHIO.mLightDrop.mPikariScaleComplete;
+                field_0x756++;
+            } else {
+                int temp_r5_3 = temp_r5_2 + 1;
 
-                    if (field_0x756 == temp_r5_3) {
-                        if (field_0x62c[15] == 0.0f) {
-                            field_0x756++;
-                        }
-                        var_f28 = g_drawHIO.mLightDrop.mPikariScaleComplete;
-                    } else if (field_0x756 >= g_drawHIO.mLightDrop.field_0x54 + temp_r5_3) {
-                        for (int i = 0; i < 16; i++) {
-                            field_0x62c[i] = 18.0f - var_f29;
-                            field_0x66c[i] = 18.0f - g_drawHIO.mLightDrop.mPikariLoopAnimSpeed;
-                        }
-
-                        field_0x756 = -1;
-                    } else {
+                if (field_0x756 == temp_r5_3) {
+                    if (field_0x62c[15] == 0.0f) {
                         field_0x756++;
                     }
+                    var_f28 = g_drawHIO.mLightDrop.mPikariScaleComplete;
+                } else if (field_0x756 >= g_drawHIO.mLightDrop.field_0x54 + temp_r5_3) {
+                    for (int i = 0; i < 16; i++) {
+                        field_0x62c[i] = 18.0f - var_f29;
+                        field_0x66c[i] = 18.0f - g_drawHIO.mLightDrop.mPikariLoopAnimSpeed;
+                    }
+
+                    field_0x756 = -1;
+                } else {
+                    field_0x756++;
                 }
             }
+            IF_DUSK_BLOCK_END
         }
 
         for (int i = 0; i < 16; i++) {
@@ -1360,6 +1396,22 @@ void dMeter2Draw_c::initButtonCross() {
     dMeter2Info_getString(
         0x62, static_cast<J2DTextBox*>(mpScreen->search(MULTI_CHAR('cont_ju9')))->getStringPtr(), NULL);
 
+#if TARGET_PC
+    // These panes are not wide enough for French text (and possibly other languages)
+    // on Wii PAL. Resize them to always match their counterparts in later releases.
+    static u64 const juTags[] = {
+        MULTI_CHAR('cont_ju0'), MULTI_CHAR('cont_ju1'), MULTI_CHAR('cont_ju2'),
+        MULTI_CHAR('cont_ju3'), MULTI_CHAR('cont_ju4'), MULTI_CHAR('cont_ju5'),
+        MULTI_CHAR('cont_ju6'), MULTI_CHAR('cont_ju7'), MULTI_CHAR('cont_ju8'),
+        MULTI_CHAR('cont_ju9'),
+    };
+
+    for (u64 tag : juTags) {
+        J2DPane* pane = mpScreen->search(tag);
+        pane->resize(120.0f, pane->getHeight());
+    }
+#endif
+
     mpButtonCrossParent->setAlphaRate(0.0f);
     drawButtonCross(g_drawHIO.mButtonCrossOFFPosX, g_drawHIO.mButtonCrossOFFPosY);
 }
@@ -1438,26 +1490,23 @@ void dMeter2Draw_c::drawPikari(f32 i_posX, f32 i_posY, f32* i_framep, f32 i_scal
     if (param_9 != 3 && param_9 != 4 && param_9 != 5 && dMsgObject_isTalkNowCheck()) {
         *i_framep = 0.0f;
     } else {
-#ifdef TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            *i_framep += param_8;
-            if (*i_framep > var_f31) {
-                if (param_9 == 1 || param_9 == 2 || param_9 == 3) {
-                    *i_framep = 18.0f;
-                } else {
-                    *i_framep = 0.0f;
-                }
-            }
-
-            if (*i_framep == 18.0f && param_9 == 1) {
-                mDoAud_seStart(Z2SE_NAVI_BLINK, NULL, 0, 0);
-            } else if (*i_framep == 18.0f && param_9 == 2) {
-                mDoAud_seStart(Z2SE_SY_ITEM_COMBINE_ICON, NULL, 0, 0);
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        *i_framep += param_8;
+        if (*i_framep > var_f31) {
+            if (param_9 == 1 || param_9 == 2 || param_9 == 3) {
+                *i_framep = 18.0f;
+            } else {
+                *i_framep = 0.0f;
             }
         }
 
+        if (*i_framep == 18.0f && param_9 == 1) {
+            mDoAud_seStart(Z2SE_NAVI_BLINK, NULL, 0, 0);
+        } else if (*i_framep == 18.0f && param_9 == 2) {
+            mDoAud_seStart(Z2SE_SY_ITEM_COMBINE_ICON, NULL, 0, 0);
+        }
+        IF_DUSK_BLOCK_END
+
         playPikariBckAnimation(*i_framep);
         playPikariBpkAnimation(*i_framep);
 
@@ -2418,7 +2467,7 @@ void dMeter2Draw_c::drawButtonA(u8 i_action, f32 i_posX, f32 i_posY, f32 i_textP
     mpButtonA->paneTrans(i_posX, i_posY);
     mpTextA->scale(var_f30 * i_scale, var_f30 * i_scale);
     mpTextA->paneTrans(g_drawHIO.mButtonATextPosX + i_textPosX,
-                       g_drawHIO.mButtonATextPosY + i_textPosY);
+                       g_drawHIO.mButtonATextPosY + i_textPosY IF_DUSK(+ (dusk::version::isLessThanWiiJpn() ? 6.0f : 0.0f)));
 }
 
 void dMeter2Draw_c::drawButtonB(u8 i_action, bool param_1, f32 i_posX, f32 i_posY, f32 i_textPosX,
@@ -2616,6 +2665,11 @@ void dMeter2Draw_c::drawButtonXY(int i_no, u8 i_itemNo, u8 i_action, bool param_
 
     static u64 const tag[] = {MULTI_CHAR('item_x_n'), MULTI_CHAR('item_y_n')};
 
+#if TARGET_PC
+    const float btnXOffsetX = dusk::version::isLessThanWiiJpn() ? 2.0f : 0.0f;
+    const float btnXOffsetY = dusk::version::isLessThanWiiJpn() ? 38.0f : 0.0f;
+#endif
+
     if (!param_3) {
         mpScreen->search(tag[i_no])->hide();
 
@@ -2662,7 +2716,8 @@ void dMeter2Draw_c::drawButtonXY(int i_no, u8 i_itemNo, u8 i_action, bool param_
 
         if (i_no == SELECT_X_e) {
             mpTextXY[i_no]->scale(g_drawHIO.mButtonXYTextScale, g_drawHIO.mButtonXYTextScale);
-            mpTextXY[i_no]->paneTrans(g_drawHIO.mButtonXYTextPosX, g_drawHIO.mButtonXYTextPosY);
+            mpTextXY[i_no]->paneTrans(g_drawHIO.mButtonXYTextPosX IF_DUSK(- btnXOffsetX),
+                                      g_drawHIO.mButtonXYTextPosY IF_DUSK(+ btnXOffsetY));
         } else if (i_no == SELECT_Y_e) {
             mpTextXY[i_no]->scale(g_drawHIO.mButtonXYTextScale, g_drawHIO.mButtonXYTextScale);
             mpTextXY[i_no]->paneTrans(g_drawHIO.mButtonXYTextPosX, g_drawHIO.mButtonXYTextPosY);
@@ -2724,7 +2779,8 @@ void dMeter2Draw_c::drawButtonXY(int i_no, u8 i_itemNo, u8 i_action, bool param_
             mpLightXY[0]->setAlphaRate(mButtonXItemBaseAlpha[var_r29] * field_0x7f0);
 
             mpTextXY[i_no]->scale(g_drawHIO.mButtonXYTextScale, g_drawHIO.mButtonXYTextScale);
-            mpTextXY[i_no]->paneTrans(g_drawHIO.mButtonXYTextPosX, g_drawHIO.mButtonXYTextPosY);
+            mpTextXY[i_no]->paneTrans(g_drawHIO.mButtonXYTextPosX IF_DUSK(- btnXOffsetX),
+                                      g_drawHIO.mButtonXYTextPosY IF_DUSK(+ btnXOffsetY));
         } else if (i_no == SELECT_Y_e) {
             mpButtonXY[1]->scale(g_drawHIO.mButtonYScale, g_drawHIO.mButtonYScale);
             mpButtonXY[1]->paneTrans(g_drawHIO.mButtonYPosX, g_drawHIO.mButtonYPosY);
@@ -2781,7 +2837,7 @@ void dMeter2Draw_c::drawButtonCross(f32 i_posX, f32 i_posY) {
 #if TARGET_PC
     f32 buttonCrossPosX = i_posX;
     f32 buttonCrossPosY = i_posY;
-    dAnchorHudScale(mpButtonCrossParent, HudCorner::TopLeft, &buttonCrossPosX, &buttonCrossPosY);
+    dAnchorHudScale(mpButtonCrossParent, HudCorner::BottomLeft, &buttonCrossPosX, &buttonCrossPosY);
     mpButtonCrossParent->paneTrans(buttonCrossPosX, buttonCrossPosY);
 #else
     mpButtonCrossParent->paneTrans(i_posX, i_posY);
@@ -3449,7 +3505,7 @@ char* dMeter2Draw_c::getActionString(u8 i_action, u8 i_type, u8* param_2) {
             }
 
             if (param_2 != NULL) {
-                *param_2 = mesg_entry.output_type;
+                *param_2 = mesg_entry.draw_type;
 
                 if (g_drawHIO.mButtonATextActionID == 0x3E6) {
                     *param_2 = 7;
@@ -3466,7 +3522,7 @@ char* dMeter2Draw_c::getActionString(u8 i_action, u8 i_type, u8* param_2) {
         }
 
         if (param_2 != NULL) {
-            *param_2 = mesg_entry.output_type;
+            *param_2 = mesg_entry.draw_type;
 
             if (i_action_num[i_action] == 0x3E6) {
                 *param_2 = 7;
diff --git a/src/d/d_meter2_info.cpp b/src/d/d_meter2_info.cpp
index 63e22056f5..3bb9ffdcd3 100644
--- a/src/d/d_meter2_info.cpp
+++ b/src/d/d_meter2_info.cpp
@@ -15,7 +15,10 @@
 
 #include <cstring>
 
-#include "dusk/string.hpp"
+#if TARGET_PC
+#include "dusk/version.hpp"
+#include "helpers/string.hpp"
+#endif
 
 enum ITEMICON_RES_FILE_ID {
     ITEMICON_BTI_ARI_MESU_00=0x3,
@@ -534,13 +537,18 @@ f32 dMeter2Info_c::getStringLength(J2DTextBox* i_textbox, char* i_string) {
             str_width = 0.0f;
         } else {
             int c = (u8)*string;
-#if VERSION == VERSION_GCN_JPN
-            bool unkFlag1 = false;
-            if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
-                unkFlag1 = true;
-            }
-            if (unkFlag1) {
-                c = (c << 8) | (u8)*++string;
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+            #if TARGET_PC
+            if (dusk::version::isRegionJpn())
+            #endif
+            {
+                bool unkFlag1 = false;
+                if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
+                    unkFlag1 = true;
+                }
+                if (unkFlag1) {
+                    c = (c << 8) | (u8)*++string;
+                }
             }
 #endif
             str_width += charSpace + (fontSize.mSizeX * ((f32)font->getWidth(c) / (f32)font->getCellWidth()));
@@ -566,13 +574,18 @@ f32 dMeter2Info_c::getStringLength(JUTFont* i_font, f32 param_2, f32 param_3, ch
             str_width = 0.0f;
         } else {
             int c = (u8)*string;
-#if VERSION == VERSION_GCN_JPN
-            bool unkFlag1 = false;
-            if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
-                unkFlag1 = true;
-            }
-            if (unkFlag1) {
-                c = (c << 8) | (u8)*++string;
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+            #if TARGET_PC
+            if (dusk::version::isRegionJpn())
+            #endif
+            {
+                bool unkFlag1 = false;
+                if ((c >= 0x81 && c <= 0x9f) || (c >= 0xe0 && c <= 0xfc)) {
+                    unkFlag1 = true;
+                }
+                if (unkFlag1) {
+                    c = (c << 8) | (u8)*++string;
+                }
             }
 #endif
             str_width += param_3 + param_2 * ((f32)i_font->getWidth(c) / (f32)i_font->getCellWidth());
@@ -594,7 +607,7 @@ BOOL dMeter2Info_c::isDirectUseItem(int param_0) {
     return (mDirectUseItem & (u8)(1 << param_0)) ? TRUE : FALSE;
 }
 
-dMeter2Info_c g_meter2_info;
+DUSK_GAME_DATA dMeter2Info_c g_meter2_info;
 
 int dMeter2Info_c::setMeterString(s32 i_string) {
     if (mMeterString != 0) {
@@ -1742,7 +1755,7 @@ bool dMeter2Info_isItemOpenCheck() {
     return true;
 }
 
-dMenu_LetterData dMenu_Letter::letter_data[64] = {
+DUSK_GAME_DATA dMenu_LetterData dMenu_Letter::letter_data[64] = {
     {0x09C5, 0x0A29, 0x0A8D, 0x010B}, {0x09C6, 0x0A2A, 0x0A8E, 0x0237},
     {0x09C7, 0x0A2B, 0x0A8F, 0x0236}, {0x09C8, 0x0A2C, 0x0A90, 0x0037},
     {0x09C9, 0x0A2D, 0x0A91, 0x0039}, {0x09CA, 0x0A2E, 0x0A92, 0x0067},
@@ -1889,3 +1902,542 @@ void dMeter2Info_set2DVibrationT() {}
 void dMeter2Info_set2DVibration() {}
 
 void dMeter2Info_set2DVibrationM() {}
+
+#if TARGET_PC
+void dMeter2Info_Initialize() {
+    g_meter2_info.init();
+}
+
+dMeterMap_c* dMeter2Info_getMeterMapClass() {
+    return g_meter2_info.getMeterMapClass();
+}
+
+dMw_c* dMeter2Info_getMenuWindowClass() {
+    return g_meter2_info.getMenuWindowClass();
+}
+
+void dMeter2Info_setWindowStatus(u8 i_status) {
+    g_meter2_info.setWindowStatus(i_status);
+}
+
+CPaneMgr* dMeter2Info_getMeterItemPanePtr(s32 i_idx) {
+    return g_meter2_info.getMeterItemPanePtr(i_idx);
+}
+
+void dMeter2Info_getString(u32 i_stringID, TEXT_SPAN o_string, JMSMesgEntry_c* i_msgEntry) {
+    g_meter2_info.getString(i_stringID, o_string, i_msgEntry);
+}
+
+void dMeter2Info_getStringKanji(u32 i_stringID, TEXT_SPAN o_string, JMSMesgEntry_c* i_msgEntry) {
+    g_meter2_info.getStringKanji(i_stringID, o_string, i_msgEntry);
+}
+
+void dMeter2Info_getStringKana(u32 i_stringID, TEXT_SPAN o_string, JMSMesgEntry_c* i_msgEntry) {
+    g_meter2_info.getStringKana(i_stringID, o_string, i_msgEntry);
+}
+
+f32 dMeter2Info_getStringLength(JUTFont* i_font, f32 param_2, f32 param_3, char* i_string) {
+    return g_meter2_info.getStringLength(i_font, param_2, param_3, i_string);
+}
+
+f32 dMeter2Info_getStringLength(J2DTextBox* i_textbox, char* i_string) {
+    return g_meter2_info.getStringLength(i_textbox, i_string);
+}
+
+void dMeter2Info_setHotSpringTimer(u8 i_slotNo) {
+    g_meter2_info.setHotSpringTimer(i_slotNo);
+}
+
+u16 dMeter2Info_getOilGaugeBackUp() {
+    return g_meter2_info.getOilGaugeBackUp();
+}
+
+void dMeter2Info_setOilGaugeBackUp(u16 param_1) {
+    g_meter2_info.setOilGaugeBackUp(param_1);
+}
+
+void dMeter2Info_setSaveStageName(const char* i_stageName) {
+    g_meter2_info.setSaveStageName(i_stageName);
+}
+
+u8 dMeter2Info_getInsectSelectType() {
+    return g_meter2_info.getInsectSelectType();
+}
+
+void dMeter2Info_setInsectSelectType(u8 i_type) {
+    g_meter2_info.setInsectSelectType(i_type);
+}
+
+u8 dMeter2Info_getWarpStatus() {
+    return g_meter2_info.getWarpStatus();
+}
+
+void dMeter2Info_setWarpStatus(u8 i_status) {
+    return g_meter2_info.setWarpStatus(i_status);
+}
+
+int dMeter2Info_readItemTexture(u8 i_itemNo, void* i_texBuf1, J2DPicture* i_pic1, void* i_texBuf2,
+    J2DPicture* i_pic2, void* i_texBuf3, J2DPicture* i_pic3, void* i_texBuf4, J2DPicture* i_pic4,
+    int param_9) {
+    return g_meter2_info.readItemTexture(i_itemNo, i_texBuf1, i_pic1, i_texBuf2, i_pic2, i_texBuf3,
+        i_pic3, i_texBuf4, i_pic4, param_9);
+}
+
+void dMeter2Info_setItemColor(
+    u8 i_itemNo, J2DPicture* i_pic1, J2DPicture* i_pic2, J2DPicture* i_pic3, J2DPicture* i_pic4) {
+    g_meter2_info.setItemColor(i_itemNo, i_pic1, i_pic2, i_pic3, i_pic4);
+}
+
+u8 dMeter2Info_getWarpRoomNo() {
+    return g_meter2_info.getWarpRoomNo();
+}
+
+u8 dMeter2Info_getWarpPlayerNo() {
+    return g_meter2_info.getWarpPlayerNo();
+}
+
+cXyz& dMeter2Info_getWarpPos() {
+    return g_meter2_info.getWarpPos();
+}
+
+const char* dMeter2Info_getWarpStageName() {
+    return g_meter2_info.getWarpStageName();
+}
+
+void dMeter2Info_setNowCount(u8 i_count) {
+    g_meter2_info.setNowCount(i_count);
+}
+
+void dMeter2Info_setMaxCount(u8 i_count) {
+    g_meter2_info.setMaxCount(i_count);
+}
+
+BOOL dMeter2Info_isDirectUseItem(int param_0) {
+    return g_meter2_info.isDirectUseItem(param_0);
+}
+
+bool dMeter2Info_isUseButton(int i_buttonBit) {
+    return g_meter2_info.isUseButton(i_buttonBit);
+}
+
+void dMeter2Info_setMeterMapClass(dMeterMap_c* i_map) {
+    g_meter2_info.setMeterMapClass(i_map);
+}
+
+void dMeter2Info_decHotSpringTimer() {
+    g_meter2_info.decHotSpringTimer();
+}
+
+void dMeter2Info_allUseButton() {
+    g_meter2_info.allUseButton();
+}
+
+void dMeter2Info_offUseButton(int i_buttonBit) {
+    g_meter2_info.offUseButton(i_buttonBit);
+}
+
+void dMeter2Info_resetGameStatus() {
+    g_meter2_info.resetGameStatus();
+}
+
+void dMeter2Info_onGameStatus(int i_status) {
+    g_meter2_info.onGameStatus(i_status);
+}
+
+void dMeter2Info_setMapStatus(u8 i_status) {
+    g_meter2_info.setMapStatus(i_status);
+}
+
+u8 dMeter2Info_getMapStatus() {
+    return g_meter2_info.getMapStatus();
+}
+
+void dMeter2Info_setPauseStatus(u8 i_status) {
+    g_meter2_info.setPauseStatus(i_status);
+}
+
+void dMeter2Info_resetPauseStatus() {
+    g_meter2_info.resetPauseStatus();
+}
+
+u8 dMeter2Info_getPauseStatus() {
+    return g_meter2_info.getPauseStatus();
+}
+
+bool dMeter2Info_isGameStatus(int i_status) {
+    return g_meter2_info.isGameStatus(i_status);
+}
+
+bool dMeter2Info_isTouchKeyCheck(int i_status) {
+    return g_meter2_info.isTouchKeyCheck(i_status);
+}
+
+void dMeter2Info_setMapKeyDirection(u16 i_direction) {
+    g_meter2_info.setMapKeyDirection(i_direction);
+}
+
+bool dMeter2Info_isSub2DStatus(int i_flag) {
+    return g_meter2_info.isSub2DStatus(i_flag);
+}
+
+void dMeter2Info_offMenuInForce(int i_flag) {
+    g_meter2_info.offMenuInForce(i_flag);
+}
+
+bool dMeter2Info_isMenuInForce(int i_flag) {
+    return g_meter2_info.isMenuInForce(i_flag);
+}
+
+void dMeter2Info_setMenuWindowClass(dMw_c* i_menu) {
+    g_meter2_info.setMenuWindowClass(i_menu);
+}
+
+void dMeter2Info_resetWarpStatus() {
+    g_meter2_info.resetWarpStatus();
+}
+
+u16 dMeter2Info_getMapKeyDirection() {
+    return g_meter2_info.getMapKeyDirection();
+}
+
+u8 dMeter2Info_getWindowStatus() {
+    return g_meter2_info.getWindowStatus();
+}
+
+void dMeter2Info_setMsgResource(void* i_res) {
+    g_meter2_info.setMsgResource(i_res);
+}
+
+void dMeter2Info_setStageMsgResource(void* i_res) {
+    g_meter2_info.setStageMsgResource(i_res);
+}
+
+void dMeter2Info_setMsgUnitResource(void* i_res) {
+    g_meter2_info.setMsgUnitResource(i_res);
+}
+
+void* dMeter2Info_getMsgResource() {
+    return g_meter2_info.getMsgResource();
+}
+
+void* dMeter2Info_getStageMsgResource() {
+    return g_meter2_info.getStageMsgResource();
+}
+
+void* dMeter2Info_getMsgUnitResource() {
+    return g_meter2_info.getMsgUnitResource();
+}
+
+u8 dMeter2Info_getLightDropGetFlag(int i_no) {
+    return g_meter2_info.getLightDropGetFlag(i_no);
+}
+
+s32 dMeter2Info_getMeterStringType() {
+    return g_meter2_info.getMeterStringType();
+}
+
+void dMeter2Info_setMeterClass(dMeter2_c* i_meter) {
+    g_meter2_info.setMeterClass(i_meter);
+}
+
+void dMeter2Info_onLifeGaugeSE() {
+    g_meter2_info.onLifeGaugeSE();
+}
+
+void dMeter2Info_offLifeGaugeSE() {
+    g_meter2_info.offLifeGaugeSE();
+}
+
+u8 dMeter2Info_getLifeGaugeSE() {
+    return g_meter2_info.getLifeGaugeSE();
+}
+
+const char* dMeter2Info_getSaveStageName() {
+    return g_meter2_info.getSaveStageName();
+}
+
+void dMeter2Info_onShopTalkFlag() {
+    g_meter2_info.onShopTalkFlag();
+}
+
+void dMeter2Info_setLightDropGetFlag(int i_no, u8 i_flag) {
+    g_meter2_info.setLightDropGetFlag(i_no, i_flag);
+}
+
+u8 dMeter2Info_getRentalBombBag() {
+    return g_meter2_info.getRentalBombBag();
+}
+
+u8 dMeter2Info_getMiniGameItemSetFlag() {
+    return g_meter2_info.getMiniGameItemSetFlag();
+}
+
+void dMeter2Info_setMiniGameItem(u8 i_minigameFlag) {
+    g_meter2_info.setMiniGameItem(i_minigameFlag);
+}
+
+void dMeter2Info_resetMiniGameItem(bool i_saveItem) {
+    g_meter2_info.resetMiniGameItem(i_saveItem);
+}
+
+void dMeter2Info_setTableMapRegionNo(u8 i_regionNo) {
+    g_meter2_info.setTableMapRegionNo(i_regionNo);
+}
+
+void dMeter2Info_setGoldWolfMapType(u8 i_mapType) {
+    g_meter2_info.setGoldWolfMapType(i_mapType);
+}
+
+void dMeter2Info_changeWater(u8 i_slotNo) {
+    g_meter2_info.changeWater(i_slotNo);
+}
+
+void dMeter2Info_warpInProc() {
+    g_meter2_info.warpInProc();
+}
+
+void dMeter2Info_warpOutProc() {
+    g_meter2_info.warpOutProc();
+}
+
+dMeter2_c* dMeter2Info_getMeterClass() {
+    return g_meter2_info.getMeterClass();
+}
+
+s16 dMeter2Info_getMsgKeyWaitTimer() {
+    return g_meter2_info.getMsgKeyWaitTimer();
+}
+
+void dMeter2Info_onDirectUseItem(int param_0) {
+    g_meter2_info.onDirectUseItem(param_0);
+}
+
+void dMeter2Info_setFloatingFlow(u16 i_flowID, s16 i_msgTimer, bool i_wakuVisible) {
+    g_meter2_info.setFloatingFlow(i_flowID, i_msgTimer, i_wakuVisible);
+}
+
+u8 dMeter2Info_getGameOverType() {
+    return g_meter2_info.getGameOverType();
+}
+
+void dMeter2Info_setGameOverType(u8 i_gameoverType) {
+    g_meter2_info.setGameOverType(i_gameoverType);
+}
+
+void dMeter2Info_setMsgKeyWaitTimer(s16 i_waitTimer) {
+    g_meter2_info.setMsgKeyWaitTimer(i_waitTimer);
+}
+
+s32 dMeter2Info_getMsgTimeMs() {
+    return g_meter2_info.getMsgTimeMs();
+}
+
+s32 dMeter2Info_getTimeMs() {
+    return g_meter2_info.getTimeMs();
+}
+
+void dMeter2Info_setMsgTimeMs(s32 i_msgTime) {
+    g_meter2_info.setMsgTimeMs(i_msgTime);
+}
+
+void dMeter2Info_setTimeMs(s32 i_time) {
+    g_meter2_info.setTimeMs(i_time);
+}
+
+u8 dMeter2Info_getNowCount() {
+    return g_meter2_info.getNowCount();
+}
+
+u8 dMeter2Info_getMaxCount() {
+    return g_meter2_info.getMaxCount();
+}
+
+void dMeter2Info_setScopeZoomPointer(u8 param_0) {
+    g_meter2_info.setScopeZoomPointer(param_0);
+}
+
+void dMeter2Info_decMsgKeyWaitTimer() {
+    g_meter2_info.decMsgKeyWaitTimer();
+}
+
+bool dMeter2Info_isFloatingMessageVisible() {
+    return g_meter2_info.isFloatingMessageVisible();
+}
+
+u8 dMeter2Info_getItemExplainWindowStatus() {
+    return g_meter2_info.getItemExplainWindowStatus();
+}
+
+void dMeter2Info_setItemExplainWindowStatus(u8 i_value) {
+    g_meter2_info.setItemExplainWindowStatus(i_value);
+}
+
+void dMeter2Info_resetDirectUseItem() {
+    g_meter2_info.resetDirectUseItem();
+}
+
+u16 dMeter2Info_getFloatingFlowID() {
+    return g_meter2_info.getFloatingFlowID();
+}
+
+u8 dMeter2Info_getCollectCursorPosX() {
+    return g_meter2_info.getCollectCursorPosX();
+}
+
+u8 dMeter2Info_getCollectCursorPosY() {
+    return g_meter2_info.getCollectCursorPosY();
+}
+
+void dMeter2Info_setCollectCursorPosXY(u8 x, u8 y) {
+    g_meter2_info.setCollectCursorPosXY(x, y);
+}
+
+void dMeter2Info_onBlinkButton(int i_flag) {
+    g_meter2_info.onBlinkButton(i_flag);
+}
+
+bool dMeter2Info_isFloatingMessageWakuVisible() {
+    return g_meter2_info.isFloatingMessageWakuVisible();
+}
+
+bool dMeter2Info_isBlinkButton(int i_flag) {
+    return g_meter2_info.isBlinkButton(i_flag);
+}
+
+void dMeter2Info_resetBlinkButton() {
+    g_meter2_info.resetBlinkButton();
+}
+
+void dMeter2Info_resetFloatingMessage() {
+    g_meter2_info.resetFloatingMessage();
+}
+
+s16 dMeter2Info_decFloatingMessageTimer() {
+    return g_meter2_info.decFloatingMessageTimer();
+}
+
+s16 dMeter2Info_getFloatingMessageTimer() {
+    return g_meter2_info.getFloatingMessageTimer();
+}
+
+u16 dMeter2Info_getFloatingMessageID() {
+    return g_meter2_info.getFloatingMessageID();
+}
+
+s16 dMeter2Info_getHorseLifeCount() {
+    return g_meter2_info.getHorseLifeCount();
+}
+
+void dMeter2Info_setMeterString(s32 i_string) {
+    g_meter2_info.setMeterString(i_string);
+}
+
+void dMeter2Info_resetMeterString() {
+    g_meter2_info.resetMeterString();
+}
+
+void dMeter2Info_setMeterItemPanePtr(int i_no, CPaneMgr* i_pane) {
+    g_meter2_info.setMeterItemPanePtr(i_no, i_pane);
+}
+
+bool dMeter2Info_isShopTalkFlag() {
+    return g_meter2_info.isShopTalkFlag();
+}
+
+void dMeter2Info_setMapDrugFlag(bool i_flag) {
+    g_meter2_info.setMapDrugFlag(i_flag);
+}
+
+bool dMeter2Info_isTempBit(int i_bit) {
+    return g_meter2_info.isTempBit(i_bit);
+}
+
+void dMeter2Info_offSub2DStatus(int i_bit) {
+    g_meter2_info.offSub2DStatus(i_bit);
+}
+
+void dMeter2Info_onSub2DStatus(int i_bit) {
+    g_meter2_info.onSub2DStatus(i_bit);
+}
+
+void dMeter2Info_set2DWidth(f32 i_width) {
+    g_meter2_info.set2DWidth(i_width);
+}
+
+void dMeter2Info_set2DHeight(f32 i_height) {
+    g_meter2_info.set2DHeight(i_height);
+}
+
+void dMeter2Info_set2DPosH(f32 i_posH) {
+    g_meter2_info.set2DPosH(i_posH);
+}
+
+void dMeter2Info_set2DPosV(f32 i_posV) {
+    g_meter2_info.set2DPosV(i_posV);
+}
+
+void dMeter2Info_offShopTalkFlag() {
+    g_meter2_info.offShopTalkFlag();
+}
+
+void dMeter2Info_onUseButton(int i_button) {
+    g_meter2_info.onUseButton(i_button);
+}
+
+f32 dMeter2Info_get2DWidth() {
+    return g_meter2_info.get2DWidth();
+}
+
+f32 dMeter2Info_get2DHeight() {
+    return g_meter2_info.get2DHeight();
+}
+
+void dMeter2Info_setWarpInfo(const char* i_stageName, const cXyz& i_position, s16 i_angle,
+    u8 i_roomNo, u8 param_4, u8 i_warpPlayerNo) {
+    g_meter2_info.setWarpInfo(i_stageName, i_position, i_angle, i_roomNo, param_4, i_warpPlayerNo);
+}
+
+u8 dMeter2Info_getTableMapRegionNo() {
+    return g_meter2_info.getTableMapRegionNo();
+}
+
+u8 dMeter2Info_getGoldWolfMapType() {
+    return g_meter2_info.getGoldWolfMapType();
+}
+
+bool dMeter2Info_isWindowAccept(int param_0) {
+    return g_meter2_info.isWindowAccept(param_0);
+}
+
+void dMeter2Info_setHorseLifeCount(s16 i_count) {
+    g_meter2_info.setHorseLifeCount(i_count);
+}
+
+void dMeter2Info_offTempBit(int i_bit) {
+    g_meter2_info.offTempBit(i_bit);
+}
+
+void dMeter2Info_onTempBit(int i_bit) {
+    g_meter2_info.onTempBit(i_bit);
+}
+
+void dMeter2Info_setFloatingMessage(u16 i_msgID, s16 i_msgTimer, bool i_wakuVisible) {
+    g_meter2_info.setFloatingMessage(i_msgID, i_msgTimer, i_wakuVisible);
+}
+
+void dMeter2Info_setMiniGameCount(s8 i_count) {
+    g_meter2_info.setMiniGameCount(i_count);
+}
+
+void dMeter2Info_onWindowAccept(int param_0) {
+    g_meter2_info.onWindowAccept(param_0);
+}
+
+void dMeter2Info_offWindowAccept(int param_0) {
+    g_meter2_info.offWindowAccept(param_0);
+}
+
+void dMeter2Info_onMenuInForce(int param_0) {
+    g_meter2_info.onMenuInForce(param_0);
+}
+#endif
diff --git a/src/d/d_meter_HIO.cpp b/src/d/d_meter_HIO.cpp
index 584a2852f6..39b5b3b7ea 100644
--- a/src/d/d_meter_HIO.cpp
+++ b/src/d/d_meter_HIO.cpp
@@ -4310,12 +4310,12 @@ void dMeter_cursorHIO_c::genMessage(JORMContext* mctx) {
 }
 #endif
 
-dMeter_menuHIO_c g_menuHIO;
+DUSK_GAME_DATA dMeter_menuHIO_c g_menuHIO;
 
-dMeter_drawHIO_c g_drawHIO;
+DUSK_GAME_DATA dMeter_drawHIO_c g_drawHIO;
 
-dMeter_ringHIO_c g_ringHIO;
+DUSK_GAME_DATA dMeter_ringHIO_c g_ringHIO;
 
-dMeter_fmapHIO_c g_fmapHIO;
+DUSK_GAME_DATA dMeter_fmapHIO_c g_fmapHIO;
 
-dMeter_cursorHIO_c g_cursorHIO;
+DUSK_GAME_DATA dMeter_cursorHIO_c g_cursorHIO;
diff --git a/src/d/d_meter_button.cpp b/src/d/d_meter_button.cpp
index 1f47969f47..5c4207b2c8 100644
--- a/src/d/d_meter_button.cpp
+++ b/src/d/d_meter_button.cpp
@@ -16,15 +16,15 @@
 #include "d/d_msg_out_font.h"
 #include "d/d_msg_string.h"
 #include "d/d_pane_class.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
+
 #if TARGET_PC
-#include "dusk/string.hpp"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/version.hpp"
+#include "helpers/string.hpp"
 #endif
 
-#include "dusk/string.hpp"
-
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
 #define STR_BUF_LEN 528
 #else
 #define STR_BUF_LEN 512
@@ -262,7 +262,15 @@ void dMeterButton_c::draw() {
         SAFE_STRCPY(tmp_buf, static_cast<J2DTextBox*>(mpTm_c[0]->getPanePtr())->getStringPtr());
         mpTextScreen->draw(0.0f, 0.0f, graf_ctx);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            mpString_c->getString(mMsgID, static_cast<J2DTextBox*>(mpTm_c[0]->getPanePtr()), NULL, NULL,
+                                  NULL, 12);
+        } else {
+            mpString_c->getString(mMsgID, static_cast<J2DTextBox*>(mpTm_c[0]->getPanePtr()), NULL, NULL,
+                                  NULL, 8);
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpString_c->getString(mMsgID, static_cast<J2DTextBox*>(mpTm_c[0]->getPanePtr()), NULL, NULL,
                               NULL, 12);
 #else
@@ -286,22 +294,19 @@ void dMeterButton_c::draw() {
 
             s16 temp_r6 = g_drawHIO.mEmpButton.mRepeatHitFrameNum;
             s16 temp_r6_2 = g_drawHIO.mEmpButton.mRepeatHitFrameNum / 2;
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                field_0x4b8[i]++;
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            field_0x4b8[i]++;
 
-                if (field_0x4b8[i] >= temp_r6) {
-                    field_0x4b8[i] = 0;
+            if (field_0x4b8[i] >= temp_r6) {
+                field_0x4b8[i] = 0;
 
-                    if (field_0x4bc[i] == 0) {
-                        field_0x4bc[i] = 1;
-                    } else {
-                        field_0x4bc[i] = 0;
-                    }
+                if (field_0x4bc[i] == 0) {
+                    field_0x4bc[i] = 1;
+                } else {
+                    field_0x4bc[i] = 0;
                 }
             }
+            IF_DUSK_BLOCK_END
 
             f32 var_f2;
             if (temp_r6_2 < field_0x4b8[i]) {
@@ -373,8 +378,8 @@ void dMeterButton_c::draw() {
             }
 
             if (var_r3) {
-#ifdef TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending()) {
+#if TARGET_PC
+                if (dusk::interp::get_ui_tick_pending()) {
                     mWasListen[i] = var_r22;
                     mWasRepeat[i] = var_r23;
                 } else {
@@ -383,11 +388,7 @@ void dMeterButton_c::draw() {
                 }
 #endif
                 if (var_r22) {
-#ifdef TARGET_PC
-                    if (field_0x2e8[i] == 18.0f && dusk::frame_interp::get_ui_tick_pending())
-#else
-                    if (field_0x2e8[i] == 18.0f)
-#endif
+                    if (field_0x2e8[i] == 18.0f IF_DUSK(&& dusk::interp::get_ui_tick_pending()))
                     {
                         mDoAud_seStart(Z2SE_SY_HINT_BUTTON_BLINK, NULL, 0, 0);
                     }
@@ -1196,7 +1197,17 @@ void dMeterButton_c::screenInitButton() {
     field_0x4d9 = 0xFF;
 
     for (int i = 0; i < 10; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isJpnOrLessThanWiiJpn()) {
+            mpTextBox[i] = (J2DTextBox*)mpButtonScreen->search(text_tag[i]);
+            if (dusk::version::getGameVersion() >= dusk::version::GameVersion::WiiJpn) {
+                mpButtonScreen->search(ftext_tag[i])->hide();
+            }
+        } else {
+            mpTextBox[i] = (J2DTextBox*)mpButtonScreen->search(ftext_tag[i]);
+            mpButtonScreen->search(text_tag[i])->hide();
+        }
+#elif VERSION == VERSION_GCN_JPN
         mpTextBox[i] = (J2DTextBox*)mpButtonScreen->search(text_tag[i]);
         mpButtonScreen->search(ftext_tag[i])->hide();
 #else
@@ -1469,7 +1480,50 @@ void dMeterButton_c::screenInitText() {
     mpTmRoot_c = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_null'), 0, NULL);
     JUT_ASSERT(2499, mpTmRoot_c != NULL);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() == 0) {
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
+
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('t3f_s'), 0, NULL);
+
+            field_0x0ec[0] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_3f'), 0, NULL);
+
+            field_0x0ec[1] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_3f_s'), 0, NULL);
+
+            mpTextScreen->search(MULTI_CHAR('n_3line'))->hide();
+            mpTextScreen->search(MULTI_CHAR('n_3fline'))->show();
+            mpTextScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        } else {
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpTextScreen, 't3_s', 0, NULL);
+
+            field_0x0ec[0] = NULL;
+            field_0x0ec[1] = NULL;
+            OS_REPORT("[%s] %d\n", __FILE__, __LINE__);
+
+            mpTextScreen->search(MULTI_CHAR('n_3line'))->show();
+            mpTextScreen->search(MULTI_CHAR('n_3fline'))->hide();
+            mpTextScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        }
+    } else {
+        mpTm_c[0] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+        JUT_ASSERT(2504, mpTm_c[0] != NULL);
+
+        mpTm_c[1] = JKR_NEW CPaneMgr(mpTextScreen, 't4_s', 0, NULL);
+        JUT_ASSERT(2507, mpTm_c[1] != NULL);
+
+        field_0x0ec[0] = NULL;
+        field_0x0ec[1] = NULL;
+
+        OS_REPORT("[%s] %d\n", __FILE__, 2512);
+
+        mpTextScreen->search(MULTI_CHAR('n_3line'))->hide();
+        mpTextScreen->search(MULTI_CHAR('n_3fline'))->hide();
+        mpTextScreen->search(MULTI_CHAR('n_e4line'))->show();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() == 0) {
         mpTm_c[0] = JKR_NEW CPaneMgr(mpTextScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
 
@@ -1517,19 +1571,11 @@ void dMeterButton_c::screenInitText() {
     f32 line_space = static_cast<J2DTextBox*>(mpTm_c[0]->getPanePtr())->getLineSpace();
     for (int i = 0; i < 2; i++) {
         static_cast<J2DTextBox*>(mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-        static_cast<J2DTextBox*>(mpTm_c[i]->getPanePtr())->setString(0x210, "");
-#else
-        static_cast<J2DTextBox*>(mpTm_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+        static_cast<J2DTextBox*>(mpTm_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
 
         if (field_0x0ec[i] != NULL) {
             static_cast<J2DTextBox*>(field_0x0ec[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-            static_cast<J2DTextBox*>(field_0x0ec[i]->getPanePtr())->setString(0x210, "");
-#else
-            static_cast<J2DTextBox*>(field_0x0ec[i]->getPanePtr())->setString(0x200, "");
-#endif
+            static_cast<J2DTextBox*>(field_0x0ec[i]->getPanePtr())->setString(STR_BUF_LEN, "");
             static_cast<J2DTextBox*>(field_0x0ec[i]->getPanePtr())->setLineSpace(line_space);
         }
     }
diff --git a/src/d/d_meter_haihai.cpp b/src/d/d_meter_haihai.cpp
index 5ea5dad5b7..59a69ed61e 100644
--- a/src/d/d_meter_haihai.cpp
+++ b/src/d/d_meter_haihai.cpp
@@ -11,7 +11,10 @@
 #include "d/d_com_inf_game.h"
 #include "d/d_meter_HIO.h"
 #include "d/d_pane_class.h"
-#include "dusk/frame_interpolation.h"
+
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 dMeterHaihai_c::dMeterHaihai_c(u8 i_type) {
     mType = i_type;
@@ -287,20 +290,17 @@ void dMeterHaihai_c::updateHaihai() {
 void dMeterHaihai_c::playBckAnime(J2DAnmTransformKey* i_bck) {
     if (checkPlayAnime(1)) {
         if (i_bck != NULL) {
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                if (mType == 4) {
-                    mBckFrame += g_drawHIO.mWiiLockArrowBCKAnimSpeed;
-                } else {
-                    mBckFrame += g_drawHIO.mScrollArrowBCKAnimSpeed;
-                }
-
-                if (mBckFrame >= i_bck->getFrameMax()) {
-                    mBckFrame -= i_bck->getFrameMax();
-                }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            if (mType == 4) {
+                mBckFrame += g_drawHIO.mWiiLockArrowBCKAnimSpeed;
+            } else {
+                mBckFrame += g_drawHIO.mScrollArrowBCKAnimSpeed;
             }
+
+            if (mBckFrame >= i_bck->getFrameMax()) {
+                mBckFrame -= i_bck->getFrameMax();
+            }
+            IF_DUSK_BLOCK_END
         } else {
             mBtkFrame = 1.0f;
         }
@@ -315,20 +315,17 @@ void dMeterHaihai_c::playBckAnime(J2DAnmTransformKey* i_bck) {
 void dMeterHaihai_c::playBtkAnime(J2DAnmTextureSRTKey* i_btk) {
     if (checkPlayAnime(2)) {
         if (i_btk != NULL) {
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                if (mType == 4) {
-                    mBtkFrame += g_drawHIO.mWiiLockArrowBTKAnimSpeed;
-                } else {
-                    mBtkFrame += g_drawHIO.mScrollArrowBTKAnimSpeed;
-                }
-
-                if (mBtkFrame >= i_btk->getFrameMax()) {
-                    mBtkFrame -= i_btk->getFrameMax();
-                }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            if (mType == 4) {
+                mBtkFrame += g_drawHIO.mWiiLockArrowBTKAnimSpeed;
+            } else {
+                mBtkFrame += g_drawHIO.mScrollArrowBTKAnimSpeed;
             }
+
+            if (mBtkFrame >= i_btk->getFrameMax()) {
+                mBtkFrame -= i_btk->getFrameMax();
+            }
+            IF_DUSK_BLOCK_END
         } else {
             mBtkFrame = 1.0f;
         }
@@ -342,20 +339,17 @@ void dMeterHaihai_c::playBtkAnime(J2DAnmTextureSRTKey* i_btk) {
 void dMeterHaihai_c::playBpkAnime(J2DAnmColor* i_bpk) {
     if (checkPlayAnime(0)) {
         if (i_bpk != NULL) {
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                if (mType == 4) {
-                    mBpkFrame += g_drawHIO.mWiiLockArrowBPKAnimSpeed;
-                } else {
-                    mBpkFrame += g_drawHIO.mScrollArrowBPKAnimSpeed;
-                }
-
-                if (mBpkFrame >= i_bpk->getFrameMax()) {
-                    mBpkFrame -= i_bpk->getFrameMax();
-                }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            if (mType == 4) {
+                mBpkFrame += g_drawHIO.mWiiLockArrowBPKAnimSpeed;
+            } else {
+                mBpkFrame += g_drawHIO.mScrollArrowBPKAnimSpeed;
             }
+
+            if (mBpkFrame >= i_bpk->getFrameMax()) {
+                mBpkFrame -= i_bpk->getFrameMax();
+            }
+            IF_DUSK_BLOCK_END
         } else {
             mBpkFrame = 1.0f;
         }
diff --git a/src/d/d_meter_map.cpp b/src/d/d_meter_map.cpp
index bffdbb8931..6349648862 100644
--- a/src/d/d_meter_map.cpp
+++ b/src/d/d_meter_map.cpp
@@ -17,6 +17,7 @@
 #include "m_Do/m_Do_controller_pad.h"
 #include "d/d_camera.h"
 #if TARGET_PC
+#include "JSystem/JUtility/JUTPalette.h"
 #include "dusk/settings.h"
 #include <algorithm>
 #endif
@@ -24,6 +25,15 @@
 
 #if TARGET_PC
 #include "dusk/action_bindings.h"
+
+namespace {
+
+// Reads the user HUD scale setting, clamped to a safe range.
+f32 dGetUserHudScale() {
+    return std::clamp(dusk::getSettings().game.hudScale.getValue(), 0.5f, 2.0f);
+}
+
+}  // namespace
 #endif
 
 #if (PLATFORM_WII || PLATFORM_SHIELD)
@@ -326,7 +336,7 @@ f32 dMeterMap_c::getMapDispEdgeTop() {
               mMap->getTexelPerCm() * (mMap->getPackZ() + -mMap->getPackPlusZ()) -
               mMap->getTopEdgePlus();
     }
-    f32 rv = getMapDispEdgeBottomY_Layout() - tmp;
+    f32 rv = getMapDispEdgeBottomY_Layout() - tmp IF_DUSK(* dGetUserHudScale());
     return rv;
 }
 
@@ -635,10 +645,14 @@ void dMeterMap_c::draw() {
         mMapJ2DPicture->setAlpha(alpha);
 
         #if TARGET_PC
+        // Ensure minimap palette gets reuploaded since it is modified for the pulsating border
+        // effect.
+        JUTPalette* pPalette = mMapJ2DPicture->getTexture(0)->getPalette();
+        pPalette->dataUploaded();
+
         // Scale the minimap with the user HUD scale and shift down so its bottom-left
         // corner stays anchored to the same screen position as at scale 1.0.
-        const f32 userHudScale =
-            std::clamp(dusk::getSettings().game.hudScale.getValue(), 0.5f, 2.0f);
+        const f32 userHudScale = dGetUserHudScale();
         const f32 scaledSizeX = sizeX * userHudScale;
         const f32 scaledSizeY = sizeY * userHudScale;
         const f32 mapBottomShift = sizeY - scaledSizeY;
diff --git a/src/d/d_meter_string.cpp b/src/d/d_meter_string.cpp
index c99e7c564e..3bc5795dc0 100644
--- a/src/d/d_meter_string.cpp
+++ b/src/d/d_meter_string.cpp
@@ -16,9 +16,12 @@
 #include "d/d_meter2_info.h"
 #include "d/d_meter_HIO.h"
 #include "d/d_pane_class.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 dMeterString_c::dMeterString_c(int i_stringID) {
     mpMapArchive = dComIfGp_getAllMapArchive();
     field_0x28 = 0;
@@ -106,27 +109,22 @@ void dMeterString_c::draw() {
             f32 var_f30 = 1.0f;
 
             if (mAnimFrame < 60.0f) {
-#if TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                {
-                    mAnimFrame += g_drawHIO.mMiniGame.mReadyFightTextAnimSpeed;
-                    if (mAnimFrame > 60.0f) {
-                        mAnimFrame = 60.0f;
-                    }
+                IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                mAnimFrame += g_drawHIO.mMiniGame.mReadyFightTextAnimSpeed;
+                if (mAnimFrame > 60.0f) {
+                    mAnimFrame = 60.0f;
                 }
+                IF_DUSK_BLOCK_END
 
                 playBckAnimation(mAnimFrame);
             } else if (mAnimFrame < (f32)g_drawHIO.mMiniGame.mReadyFightTextWaitFrames + 60.0f) {
-#if TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                    mAnimFrame += var_f30;
+                IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                mAnimFrame += var_f30;
+                IF_DUSK_BLOCK_END
             } else if (mAnimFrame < var_f31) {
-#if TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                    mAnimFrame += var_f30;
+                IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                mAnimFrame += var_f30;
+                IF_DUSK_BLOCK_END
                 var_f30 = acc(g_drawHIO.mMiniGame.field_0x172, var_f31 - mAnimFrame, 0);
             }
 
@@ -139,23 +137,17 @@ void dMeterString_c::draw() {
 
             if (mPikariAnimFrame > 0.0f) {
                 drawPikari();
-            } else if (mPikariAnimFrame == -1.0f &&
-#if TARGET_PC
-                       dusk::frame_interp::get_ui_tick_pending() &&
-#endif
+            } else if (mPikariAnimFrame == -1.0f IF_DUSK(&& dusk::interp::get_ui_tick_pending()) &&
                        mAnimFrame > g_drawHIO.mMiniGame.mReadyFightPikariAppearFrames)
             {
                 mPikariAnimFrame = 18.0f - g_drawHIO.mMiniGame.mReadyFightPikariAnimSpeed;
             }
 
-#if TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                if (mAnimFrame >= var_f31) {
-                    dMeter2Info_resetMeterString();
-                }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            if (mAnimFrame >= var_f31) {
+                dMeter2Info_resetMeterString();
             }
+            IF_DUSK_BLOCK_END
         }
     }
 }
diff --git a/src/d/d_model.cpp b/src/d/d_model.cpp
index 36e77e55fa..c236b5f2db 100644
--- a/src/d/d_model.cpp
+++ b/src/d/d_model.cpp
@@ -5,6 +5,10 @@
 #include "JSystem/J3DGraphBase/J3DMaterial.h"
 #include "d/d_com_inf_game.h"
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 void dMdl_c::draw() {
     j3dSys.setVtxPos(mpModelData->getVtxPosArray(), mpModelData->getVtxNum());
     j3dSys.setVtxNrm(mpModelData->getVtxNrmArray(), mpModelData->getNrmNum());
@@ -48,7 +52,7 @@ void dMdl_c::entryObj(dMdl_obj_c* i_obj) {
 #ifdef TARGET_PC
     // if field_0x1a is false, this dMdl_c is not in the drawlist
     // if true, we need to make sure with interp enabled
-    if (dusk::frame_interp::is_enabled() && field_0x1a) {
+    if (dusk::interp::is_enabled() && field_0x1a) {
         auto pkt = dComIfGd_getListPacket()->mpBuffer[0];
         while (pkt && pkt != this) {
             pkt = pkt->getNextPacket();
@@ -97,7 +101,7 @@ dMdl_c* dMdl_mng_c::entry(J3DModelData* i_modelData, u16 i_materialId, dKy_tevst
     return model;
 }
 
-dMdl_mng_c* dMdl_mng_c::m_myObj;
+DUSK_GAME_DATA dMdl_mng_c* dMdl_mng_c::m_myObj;
 
 void dMdl_mng_c::create() {
     m_myObj = JKR_NEW dMdl_mng_c();
diff --git a/src/d/d_msg_class.cpp b/src/d/d_msg_class.cpp
index 8dc2a82c01..0c2c3cf358 100644
--- a/src/d/d_msg_class.cpp
+++ b/src/d/d_msg_class.cpp
@@ -15,9 +15,32 @@
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
 #include "dusk/scope_guard.hpp"
-#endif
+#include "dusk/version.hpp"
+#include "helpers/bits.hpp"
 
-#if REGION_JPN
+static bool read_full_color(const void* data, u32 size, u32& ccColor, u32& gcColor) {
+    if (size == 4) {
+        ccColor = dusk::read_bits<u32>(data);
+        gcColor = ccColor;
+        return true;
+    }
+    if (size == 8) {
+        ccColor = dusk::read_bits<u32>(data);
+        gcColor = dusk::read_bits<u32>(static_cast<const u8*>(data) + sizeof(ccColor));
+        return true;
+    }
+    return false;
+}
+
+#define CHAR_CODE_MALE_ICON        (dusk::version::isRegionJpn() ? 0x8189 : 0xB2)
+#define CHAR_CODE_FEMALE_ICON      (dusk::version::isRegionJpn() ? 0x818A : 0xB3)
+#define CHAR_CODE_STAR_ICON        (dusk::version::isRegionJpn() ? 0x819A : 0xB1)
+#define CHAR_CODE_REFMARK          (dusk::version::isRegionJpn() ? 0x81A6 : 0x89)
+#define CHAR_CODE_THIN_LEFT_ARROW  (dusk::version::isRegionJpn() ? 0x81A9 : 0xB9)
+#define CHAR_CODE_THIN_RIGHT_ARROW (dusk::version::isRegionJpn() ? 0x81A8 : 0xBC)
+#define CHAR_CODE_THIN_UP_ARROW    (dusk::version::isRegionJpn() ? 0x81AA : 0xBD)
+#define CHAR_CODE_THIN_DOWN_ARROW  (dusk::version::isRegionJpn() ? 0x81AB : 0xBE)
+#elif REGION_JPN
 #define CHAR_CODE_MALE_ICON 0x8189
 #define CHAR_CODE_FEMALE_ICON 0x818A
 #define CHAR_CODE_STAR_ICON 0x819A
@@ -390,6 +413,9 @@ jmessage_tReference::jmessage_tReference() {
     resetCharCountBuffer();
     mNowColorType = 0;
     mTopColorType = 0;
+#if TARGET_PC
+    resetColors();
+#endif
     mButtonTagStopFlag = 0;
     mPageEndCount = 0;
     mSelectNum = 0;
@@ -431,8 +457,33 @@ void jmessage_tReference::calcDistance() {
 
 u8 jmessage_tReference::getLineMax() {
     int line_max;
-
-#if REGION_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (isKanban()) {
+            line_max = 6;
+        } else if (isBook()) {
+            line_max = 7;
+        } else if (isStaffRoll()) {
+            line_max = 10;
+        } else if (isSaveSeq()) {
+            line_max = 5;
+        } else {
+            line_max = 3;
+        }
+    } else {
+        if (isKanban()) {
+            line_max = 7;
+        } else if (isBook()) {
+            line_max = 9;
+        } else if (isStaffRoll()) {
+            line_max = 10;
+        } else if (isSaveSeq()) {
+            line_max = 6;
+        } else {
+            line_max = 4;
+        }
+    }
+#elif REGION_JPN
     if (isKanban()) {
         line_max = 6;
     } else if (isBook()) {
@@ -559,6 +610,13 @@ void jmessage_tReference::pageSend() {
     if (mNowColorType != mTopColorType) {
         mTopColorType = mNowColorType;
     }
+#if TARGET_PC
+    mTopFullColor = mNowFullColor;
+    if (mNowFullColor) {
+        mTopCCColor = mNowCCColor;
+        mTopGCColor = mNowGCColor;
+    }
+#endif
 
     mTopWordCount = mNowWordCount;
     mCharAlpha = 0.0f;
@@ -892,15 +950,15 @@ void jmessage_tMeasureProcessor::do_begin(void const* pEntry, char const* pszTex
     pReference->setRevoMessageID(0);
     field_0x38 = 1.0f;
 
-    mSeSpeaker = ((JMSMesgEntry_c*)pEntry)->se_speaker;
-    mSeMood = ((JMSMesgEntry_c*)pEntry)->se_mood;
+    mSeSpeaker = ((JMSMesgEntry_c*)pEntry)->speaker;
+    mSeMood = ((JMSMesgEntry_c*)pEntry)->speaker_mood;
 
-    for (int i = 0; i < D_MSG_CLASS_PAGE_CNT_MAX; i++) {
+    for (int i = 0; i < DUSK_IF_ELSE((dusk::version::isRegionJpn() ? 30 : D_MSG_CLASS_PAGE_CNT_MAX), D_MSG_CLASS_PAGE_CNT_MAX); i++) {
         pReference->setLineLength(i, 0.0f, 0.0f);
         pReference->setPageLine(i, 0);
         pReference->setPageLineMax(i, 0);
         pReference->setPageType(i, 0);
-        pReference->setLineArrange(i, ((JMSMesgEntry_c*)pEntry)->unk_0xd);
+        pReference->setLineArrange(i, ((JMSMesgEntry_c*)pEntry)->line_alignment);
         pReference->setLineScale(i, 100);
 
         if (pReference->isPlaceName() || pReference->isStaffRoll() || pReference->isBossName() ||
@@ -912,8 +970,12 @@ void jmessage_tMeasureProcessor::do_begin(void const* pEntry, char const* pszTex
                 pReference->setLineArrange(i, 1);
             }
 
-#if !REGION_JPN
-            if (((JMSMesgEntry_c*)pEntry)->unk_0xd == 0) {
+#if TARGET_PC
+            if (!dusk::version::isRegionJpn() && ((JMSMesgEntry_c*)pEntry)->line_alignment == 0) {
+                pReference->setLineArrange(i, 1);
+            }
+#elif !REGION_JPN
+            if (((JMSMesgEntry_c*)pEntry)->line_alignment == 0) {
                 pReference->setLineArrange(i, 1);
             }
 #endif
@@ -1591,6 +1653,33 @@ void jmessage_tMeasureProcessor::do_scale(f32 i_scale) {
         mPageLineMax--;
         JUT_ASSERT(0x930, mPageLineMax > 0);
 
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            if (field_0x3e == 0) {
+                pReference->setPageType(field_0x40, 2);
+            } else {
+                pReference->setPageType(field_0x40, 3);
+                if (field_0x3e == 1 && pReference->getPageType(field_0x40) == 2) {
+                    pReference->setPageType(field_0x40, 4);
+                }
+            }
+        } else {
+            if (field_0x3e == 0) {
+                pReference->setPageType(field_0x40, 2);
+            } else if (field_0x3e == 2 && mPageLineMax == 3) {
+                if (pReference->getPageType(field_0x40) == 4) {
+                    pReference->setPageType(field_0x40, 5);
+                } else {
+                    pReference->setPageType(field_0x40, 8);
+                }
+            } else {
+                pReference->setPageType(field_0x40, 3);
+                if (field_0x3e == 1 && pReference->getPageType(field_0x40) == 2) {
+                    pReference->setPageType(field_0x40, 4);
+                }
+            }
+        }
+#else
 #if REGION_JPN
         if (field_0x3e == 0) {
             pReference->setPageType(field_0x40, 2);
@@ -1612,6 +1701,7 @@ void jmessage_tMeasureProcessor::do_scale(f32 i_scale) {
                 pReference->setPageType(field_0x40, 4);
             }
         }
+#endif
     }
 }
 
@@ -1762,7 +1852,10 @@ void jmessage_tMeasureProcessor::do_pageType(int param_0) {
 
 void jmessage_tMeasureProcessor::do_name1() {
     const char* name = dComIfGs_getPlayerName();
-#if REGION_JPN
+#if TARGET_PC || REGION_JPN
+    if (!dusk::version::isRegionJpn())
+        return;
+
     int c = (((char)name[0] & 0xFF) << 8) | ((char)name[1] & 0xFF);
     // if first character is hiragana or katakana
     if ((c >= 0x829F && c <= 0x82F1) || (c >= 0x8340 && c <= 0x8396)) {
@@ -1826,7 +1919,7 @@ void jmessage_tSequenceProcessor::do_begin(void const* pEntry, char const* pszTe
     mpEntry = pEntry;
     mpText = pszText;
 
-    if (((JMSMesgEntry_c*)pEntry)->fuki_kind == 8) {
+    if (((JMSMesgEntry_c*)pEntry)->box_kind == 8) {
         field_0xa8 = g_MsgObject_HIO_c.mDisplaySpeedSpirit;
     } else {
         field_0xa8 = g_MsgObject_HIO_c.mDisplaySpeed;
@@ -1840,13 +1933,16 @@ void jmessage_tSequenceProcessor::do_begin(void const* pEntry, char const* pszTe
     field_0xb2 = 0;
     field_0xaa = 0;
     field_0xac = 0;
-    field_0xb4 = ((JMSMesgEntry_c*)pEntry)->se_speaker;
-    field_0xb3 = ((JMSMesgEntry_c*)pEntry)->se_mood;
+    field_0xb4 = ((JMSMesgEntry_c*)pEntry)->speaker;
+    field_0xb3 = ((JMSMesgEntry_c*)pEntry)->speaker_mood;
 
     jmessage_tReference* pReference = (jmessage_tReference*)getReference();
     pReference->resetCharCnt();
     pReference->setNowColorType(0);
     pReference->setTopColorType(0);
+#if TARGET_PC
+    pReference->resetColors();
+#endif
     pReference->setNowWordCount(0);
     pReference->setTopWordCount(0);
     pReference->setBatchColorFlag(0);
@@ -1854,8 +1950,8 @@ void jmessage_tSequenceProcessor::do_begin(void const* pEntry, char const* pszTe
     pReference->setNowTagScale(0);
     pReference->calcDistance();
 
-    dComIfGp_setMesgAnimeAttrInfo(((JMSMesgEntry_c*)pEntry)->base_anm_id);
-    dComIfGp_setMesgFaceAnimeAttrInfo(((JMSMesgEntry_c*)pEntry)->face_anm_id);
+    dComIfGp_setMesgAnimeAttrInfo(((JMSMesgEntry_c*)pEntry)->talk_anim);
+    dComIfGp_setMesgFaceAnimeAttrInfo(((JMSMesgEntry_c*)pEntry)->face_anim);
 
     if (dComIfGp_isHeapLockFlag() == 2) {
         pReference->setFukiPosType(1);
@@ -1863,20 +1959,20 @@ void jmessage_tSequenceProcessor::do_begin(void const* pEntry, char const* pszTe
         if (dComIfGp_isHeapLockFlag() == 3) {
             pReference->setFukiPosType(0);
         } else {
-            pReference->setFukiPosType(((JMSMesgEntry_c*)pEntry)->fuki_pos_type);
+            pReference->setFukiPosType(((JMSMesgEntry_c*)pEntry)->box_position);
         }
     }
 
-    pReference->setFukiKind(((JMSMesgEntry_c*)pEntry)->fuki_kind);
+    pReference->setFukiKind(((JMSMesgEntry_c*)pEntry)->box_kind);
 
     if (dMsgObject_getMsgOutputType() != 0xFF) {
         pReference->setForm(dMsgObject_getMsgOutputType());
     } else {
-        pReference->setForm(((JMSMesgEntry_c*)pEntry)->output_type);
+        pReference->setForm(((JMSMesgEntry_c*)pEntry)->draw_type);
     }
 
-    pReference->setArrange(((JMSMesgEntry_c*)pEntry)->unk_0xd);
-    pReference->setForm(((JMSMesgEntry_c*)pEntry)->unk_0xd);
+    pReference->setArrange(((JMSMesgEntry_c*)pEntry)->line_alignment);
+    pReference->setForm(((JMSMesgEntry_c*)pEntry)->line_alignment);
     pReference->setMsgID(((JMSMesgEntry_c*)pEntry)->message_id);
 
     if (((JMSMesgEntry_c*)pEntry)->event_label_id != 0) {
@@ -1910,7 +2006,7 @@ void jmessage_tSequenceProcessor::do_begin(void const* pEntry, char const* pszTe
     if (dMsgObject_getMsgOutputType() != 0xFF) {
         field_0xae = dMsgObject_getMsgOutputType();
     } else {
-        field_0xae = ((JMSMesgEntry_c*)pEntry)->output_type;
+        field_0xae = ((JMSMesgEntry_c*)pEntry)->draw_type;
     }
 
     if (mForceForm != 0xFF) {
@@ -2041,7 +2137,7 @@ bool jmessage_tSequenceProcessor::do_isReady() {
                 field_0xae = 1;
                 field_0xa4 = 0;
                 pReference->onBatchFlag();
-                pReference->setCharCnt(D_MSG_CLASS_CHAR_CNT_MAX);
+                pReference->setCharCnt(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? D_MSG_CLASS_CHAR_CNT_MAX : 0x200, D_MSG_CLASS_CHAR_CNT_MAX));
                 field_0xa4 = field_0xa8;
                 return true;
             }
@@ -2061,7 +2157,7 @@ bool jmessage_tSequenceProcessor::do_isReady() {
                 field_0xae = 1;
                 field_0xa4 = 0;
                 pReference->onBatchFlag();
-                pReference->setCharCnt(D_MSG_CLASS_CHAR_CNT_MAX);
+                pReference->setCharCnt(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? D_MSG_CLASS_CHAR_CNT_MAX : 0x200, D_MSG_CLASS_CHAR_CNT_MAX));
                 return true;
             }
             
@@ -2084,7 +2180,7 @@ bool jmessage_tSequenceProcessor::do_isReady() {
                 if (mDoCPd_c::getTrigA(PAD_1) || field_0xb2 != 0 IF_DUSK(|| (dusk::getSettings().game.instantText && mDoCPd_c::getHoldB(0)))) {
                     field_0xa4 = 0;
                     pReference->onBatchFlag();
-                    pReference->setCharCnt(D_MSG_CLASS_CHAR_CNT_MAX);
+                    pReference->setCharCnt(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? D_MSG_CLASS_CHAR_CNT_MAX : 0x200, D_MSG_CLASS_CHAR_CNT_MAX));
                 }
                 break;
             case 1:
@@ -2093,7 +2189,7 @@ bool jmessage_tSequenceProcessor::do_isReady() {
             case 9:
                 field_0xa4 = 0;
                 pReference->onBatchFlag();
-                pReference->setCharCnt(D_MSG_CLASS_CHAR_CNT_MAX);
+                pReference->setCharCnt(DUSK_IF_ELSE(dusk::version::isRegionJpn() ? D_MSG_CLASS_CHAR_CNT_MAX : 0x200, D_MSG_CLASS_CHAR_CNT_MAX));
                 break;
             case 2:
                 if (field_0xb2 != 0) {
@@ -2108,7 +2204,9 @@ bool jmessage_tSequenceProcessor::do_isReady() {
             }
 
             field_0xa6++;
-#if REGION_JPN
+#if TARGET_PC
+            if ((dusk::version::isRegionJpn() && field_0xa6 >= 1) || (!dusk::version::isRegionJpn() && field_0xa6 >= 2)) {
+#elif REGION_JPN
             if (field_0xa6 >= 1) {
 #else
             if (field_0xa6 >= 2) {
@@ -2208,9 +2306,21 @@ bool jmessage_tSequenceProcessor::do_tag(u32 i_tag, void const* i_data, u32 i_si
         return true;
     case MSGTAG_GROUP(255):
         switch (i_tag) {
-        case MSGTAG_COLOR:
+        case MSGTAG_COLOR: {
+#if TARGET_PC
+            u32 ccColor;
+            u32 gcColor;
+            if (read_full_color(i_data, i_size, ccColor, gcColor)) {
+                pReference->setFullColor(ccColor, gcColor);
+            } else if (i_size == 1) {
+                pReference->clearNowFullColor();
+                pReference->setNowColorType(*(u8*)i_data & 0xFF);
+            }
+#else
             pReference->setNowColorType(*(u8*)i_data & 0xFF);
+#endif
             return true;
+        }
         case MSGTAG_SCALE:
             pReference->setNowTagScale(*(BE(u16)*)i_data & 0xFFFF);
             return true;
@@ -2533,7 +2643,10 @@ bool jmessage_tSequenceProcessor::do_jump_isReady() {
 
 void jmessage_tSequenceProcessor::do_name1() {
     const char* name = dComIfGs_getPlayerName();
-#if REGION_JPN
+#if TARGET_PC || REGION_JPN
+    if (!dusk::version::isRegionJpn())
+        return;
+
     int c = (((char)name[0] & 0xFF) << 8) | ((char)name[1] & 0xFF);
     // if first character is hiragana or katakana
     if ((c >= 0x829F && c <= 0x82F1) || (c >= 0x8340 && c <= 0x8396)) {
@@ -2788,7 +2901,15 @@ void jmessage_tRenderingProcessor::do_begin(void const* pEntry, char const* pszT
         do_scale(field_0x44);
     }
 
+#if TARGET_PC
+    if (pReference->hasTopFullColor()) {
+        do_fullcolor(pReference->getTopCCColor(), pReference->getTopGCColor());
+    } else {
+        do_color(pReference->getTopColorType());
+    }
+#else
     do_color(pReference->getTopColorType());
+#endif
     pReference->resetDrawLightCount();
 
     do_widthcenter();
@@ -2942,9 +3063,20 @@ bool jmessage_tRenderingProcessor::do_tag(u32 i_tag, void const* i_data, u32 i_s
         return 1;
     case MSGTAG_GROUP(255):
         switch (i_tag) {
-        case MSGTAG_COLOR:
+        case MSGTAG_COLOR: {
+#if TARGET_PC
+            u32 ccColor;
+            u32 gcColor;
+            if (read_full_color(i_data, i_size, ccColor, gcColor)) {
+                do_fullcolor(ccColor, gcColor);
+            } else if (i_size == 1) {
+                do_color(*(u8*)i_data & 0xFF);
+            }
+#else
             do_color(*(u8*)i_data & 0xFF);
+#endif
             return 1;
+        }
         case MSGTAG_SCALE:
             field_0x13c = *(BE(u16)*)i_data & 0xFFFF;
             do_scale(field_0x13c / 100.0f);
@@ -3357,9 +3489,9 @@ void jmessage_tRenderingProcessor::do_heightcenter() {
         }
         break;
     }
-#if REGION_JPN
+#if TARGET_PC || REGION_JPN
     case 2:
-        if ((s8)pReference->getLineMax() == 3) {
+        if (IF_DUSK(dusk::version::isRegionJpn() &&) (s8)pReference->getLineMax() == 3) {
             int nowPageLine = pReference->getNowPageLine();
             field_0x138 = pReference->getLineSpace() * (0.5f * (pReference->getLineMax() - (s16)nowPageLine));
             var_f31 += field_0x138;
@@ -3368,12 +3500,25 @@ void jmessage_tRenderingProcessor::do_heightcenter() {
         if (field_0x142 == 0) {
             field_0x138 = pReference->getLineSpace();
             var_f31 += field_0x138;
-        } else if (field_0x142 == 1) {
+        }
+#if TARGET_PC
+        else if (!dusk::version::isRegionJpn() || (dusk::version::isRegionJpn() && field_0x142 == 1))
+#else
+        else if (field_0x142 == 1)
+#endif
+        {
             field_0x138 = 0.5f * pReference->getLineSpace();
             var_f31 += field_0x138;
         }
         break;
     case 3: {
+#if TARGET_PC
+        if (!dusk::version::isRegionJpn()) {
+            field_0x138 = 0.5f * pReference->getLineSpace();
+            var_f31 += field_0x138;
+            break;
+        }
+#endif
         if (field_0x142 == 1) {
             int nowPageLine = pReference->getNowPageLine();
             field_0x138 = pReference->getLineSpace() * (0.5f * (pReference->getLineMax() - (s16)nowPageLine));
@@ -3383,8 +3528,25 @@ void jmessage_tRenderingProcessor::do_heightcenter() {
         break;
     }
     case 4: {
+        #if TARGET_PC
+        if (!dusk::version::isRegionJpn() && field_0x142 == 0) {
+            int nowPageLine = pReference->getNowPageLine();
+            field_0x138 = pReference->getLineSpace() * (0.5f * (pReference->getLineMax() - (s16)nowPageLine));
+            var_f31 += field_0x138;
+        }
+        #endif
+
         if (field_0x142 == 1) {
+            #if TARGET_PC
+            if (!dusk::version::isRegionJpn()) {
+                field_0x138 = 0.5f * pReference->getLineSpace();
+                var_f31 += field_0x138;
+            } else {
+                var_f31 += 0.5f * pReference->getLineSpace();
+            }
+            #else
             var_f31 += 0.5f * pReference->getLineSpace();
+            #endif
         }
 
         f32 sp8 = pReference->getLineScale(field_0x142) / 100.0f;
@@ -3525,6 +3687,18 @@ void jmessage_tRenderingProcessor::do_color(u8 i_colorNo) {
     do_strcat(buffer, false, false, false);
 }
 
+#if TARGET_PC
+void jmessage_tRenderingProcessor::do_fullcolor(u32 ccColor, u32 gcColor) {
+    mColorNo = 0xFF;
+    mCCColor = ccColor;
+    mGCColor = gcColor;
+
+    char buffer[40];
+    SAFE_SPRINTF(buffer, "\x1B" "CC[%08x]" "\x1B" "GC[%08x]", mCCColor, mGCColor);
+    do_strcat(buffer, false, false, false);
+}
+#endif
+
 void jmessage_tRenderingProcessor::do_scale(f32 param_1) {
     jmessage_tReference* pReference = (jmessage_tReference*)getReference();
 
@@ -3662,7 +3836,7 @@ void jmessage_tRenderingProcessor::do_strcat(char* i_str, bool param_2, bool par
             } else {
                 JUT_WARN(5316, "%s", "TextBox Alloc Byte Over!!");
             }
-        } else if (field_0x11c < D_MSG_CLASS_CHAR_CNT_MAX) {
+        } else if (field_0x11c < DUSK_IF_ELSE((dusk::version::isRegionJpn() ? D_MSG_CLASS_CHAR_CNT_MAX : 0x200), D_MSG_CLASS_CHAR_CNT_MAX)) {
             if (param_2) {
                 field_0x146++;
                 if (pReference->getBatchColorFlag() != 0) {
@@ -3697,7 +3871,7 @@ void jmessage_tRenderingProcessor::do_strcat(char* i_str, bool param_2, bool par
                         int length = 0;
                         length = strlen(buffer);
 
-                        if (field_0x11c + length < D_MSG_CLASS_CHAR_CNT_MAX) {
+                        if (field_0x11c + length < DUSK_IF_ELSE((dusk::version::isRegionJpn() ? D_MSG_CLASS_CHAR_CNT_MAX : 0x200), D_MSG_CLASS_CHAR_CNT_MAX)) {
                             field_0x148 = strlen(pReference->getTextPtr());
                             field_0x14a = strlen(pReference->getTextSPtr());
 
@@ -3792,7 +3966,10 @@ void jmessage_tRenderingProcessor::do_rubystrcat(char* i_src, TEXT_SPAN i_dst, f
 
 void jmessage_tRenderingProcessor::do_name1() {
     const char* name = dComIfGs_getPlayerName();
-#if REGION_JPN
+#if TARGET_PC || REGION_JPN
+    if (!dusk::version::isRegionJpn())
+        return;
+
     int c = (((char)name[0] & 0xFF) << 8) | ((char)name[1] & 0xFF);
     // if first character is hiragana or katakana
     if ((c >= 0x829F && c <= 0x82F1) || (c >= 0x8340 && c <= 0x8396)) {
@@ -3889,7 +4066,7 @@ void jmessage_string_tReference::init(J2DTextBox* panePtr, J2DTextBox* runyPaneP
     mRubyPanePtr = runyPanePtr;
     mOutFontPtr = outFontPtr;
     mLineCount = 0;
-    mLineMax = D_MSG_CLASS_LINE_MAX;
+    mLineMax = DUSK_IF_ELSE(dusk::version::isRegionJpn() ? 9 : D_MSG_CLASS_LINE_MAX, D_MSG_CLASS_LINE_MAX);
     mNowPage = 0;
     mFlags = flags;
     if (font != NULL) {
@@ -4576,9 +4753,20 @@ bool jmessage_string_tRenderingProcessor::do_tag(u32 i_tag, void const* i_data,
     switch(i_tag & 0xFF0000) {
     case MSGTAG_GROUP(255):
         switch(i_tag) {
-        case MSGTAG_COLOR:
+        case MSGTAG_COLOR: {
+#if TARGET_PC
+            u32 ccColor;
+            u32 gcColor;
+            if (read_full_color(i_data, i_size, ccColor, gcColor)) {
+                do_fullcolor(ccColor, gcColor);
+            } else if (i_size == 1) {
+                do_color(*(u8*)i_data & 0xFF);
+            }
+#else
             do_color(*(u8*)i_data & 0xFF);
+#endif
             break;
+        }
         case MSGTAG_SCALE:
             do_scale(*(BE(u16)*)i_data / 100.0f);
             break;
@@ -5228,6 +5416,14 @@ void jmessage_string_tRenderingProcessor::do_color(u8 i_colorNo) {
     do_strcat(buffer);
 }
 
+#if TARGET_PC
+void jmessage_string_tRenderingProcessor::do_fullcolor(u32 ccColor, u32 gcColor) {
+    char buffer[32];
+    SAFE_SPRINTF(buffer, "\x1b" "CC[%08x]" "\x1b" "GC[%08x]", ccColor, gcColor);
+    do_strcat(buffer);
+}
+#endif
+
 void jmessage_string_tRenderingProcessor::do_scale(f32 i_scale) {
     J2DTextBox::TFontSize fontSize;
     mpReference->getPanePtr()->getFontSize(fontSize);
diff --git a/src/d/d_msg_flow.cpp b/src/d/d_msg_flow.cpp
index c461b179e1..222e323e78 100644
--- a/src/d/d_msg_flow.cpp
+++ b/src/d/d_msg_flow.cpp
@@ -15,6 +15,42 @@
 #include "SSystem/SComponent/c_math.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/mods/svc/flow.hpp"
+
+namespace {
+
+template <typename Node>
+bool resolve_flow_node(u16 index, Node& outNode) {
+    FlowNodeData data{};
+    if (!dusk::flow::resolve_node(dMsgObject_getMsgDtPtr(), index, data)) {
+        return false;
+    }
+    static_assert(sizeof(Node) == sizeof(data.bytes));
+    std::memcpy(&outNode, data.bytes, sizeof(outNode));
+    return true;
+}
+
+bool resolve_flow_edge(u16 index, u16& outTarget) {
+    return dusk::flow::resolve_edge(dMsgObject_getMsgDtPtr(), index, outTarget);
+}
+
+bool resolve_flow_message(u16 index, MessageEntryData& outEntry) {
+    return dusk::flow::resolve_message_entry(dMsgObject_getMsgDtPtr(), index, outEntry);
+}
+
+u16 message_id(const MessageEntryData& entry) {
+    return static_cast<u16>(static_cast<u16>(entry.bytes[4]) << 8 | entry.bytes[5]);
+}
+
+u16 flow_group(int flowId) {
+    const bool isCommonFlow = flowId >= 3000 && flowId < dusk::flow::kCustomNodeMin;
+    return isCommonFlow ? 0 : static_cast<u16>(dMsgObject_getGroupID());
+}
+
+}  // namespace
+#endif
+
 dMsgFlow_c::dMsgFlow_c() {
     mNonStopJunpFlowFlag = 0;
     setInitValue(1);
@@ -38,6 +74,10 @@ void dMsgFlow_c::init(fopAc_ac_c* i_partner, int i_flowID, int param_2, fopAc_ac
 
         dMsgObject_changeFlowGroup(i_flowID);
 
+#if TARGET_PC
+        dusk::flow::bind_resource(dMsgObject_getMsgDtPtr(), flow_group(i_flowID));
+#endif
+
         if (param_2 == 0) {
             setInitValue(1);
             
@@ -107,17 +147,37 @@ int dMsgFlow_c::checkOpenDoor(fopAc_ac_c* i_speaker_p, int* param_2) {
     mesg_flow_node_event* event_node = NULL;
 
     while ((nodeIdx != 0xFFFF && !var_r27) && !var_r25) {
+#if TARGET_PC
+        FlowNodeData resolvedData{};
+        if (!dusk::flow::resolve_node(dMsgObject_getMsgDtPtr(), nodeIdx, resolvedData)) {
+            break;
+        }
+        u8 type = resolvedData.bytes[0];
+#else
         u8 type = mFlowNodeTBL[nodeIdx].message.type;
+#endif
 
         switch(type) {
         case NODETYPE_MESSAGE_e: {
+#if TARGET_PC
+            mesg_flow_node resolved{};
+            std::memcpy(&resolved, resolvedData.bytes, sizeof(resolved));
+            msg_node = &resolved;
+#else
             msg_node = &mFlowNodeTBL[nodeIdx].message;
+#endif
             nodeIdx = msg_node->next_node_idx;
             var_r26++;
             break;
         }
         case NODETYPE_BRANCH_e: {
+#if TARGET_PC
+            mesg_flow_node_branch resolved{};
+            std::memcpy(&resolved, resolvedData.bytes, sizeof(resolved));
+            branch_node = &resolved;
+#else
             branch_node = (mesg_flow_node_branch*)&mFlowNodeTBL[nodeIdx].branch;
+#endif
 
             switch(branch_node->query_idx) {
             case 0:
@@ -130,13 +190,38 @@ int dMsgFlow_c::checkOpenDoor(fopAc_ac_c* i_speaker_p, int* param_2) {
                 break;
             }
 
+#if TARGET_PC
+            u16 query_ret;
+            if (branch_node->query_idx >= dusk::flow::kCustomQueryMin) {
+                query_ret = dusk::flow::dispatch_query(branch_node->query_idx, i_speaker_p,
+                    branch_node->param, branch_node->result_count, FLOW_QUERY_PHASE_PROBE, nodeIdx);
+            } else if (branch_node->query_idx < FLOW_QUERY_BUILTIN_COUNT) {
+                query_ret =
+                    (this->*mQueryList[branch_node->query_idx])(branch_node, i_speaker_p, 0);
+            } else {
+                break;
+            }
+#else
             u16 query_ret = (this->*mQueryList[branch_node->query_idx])(branch_node, i_speaker_p, 0);
+#endif
             u16 spE = branch_node->next_node_idx + query_ret;
+#if TARGET_PC
+            if (!resolve_flow_edge(spE, nodeIdx)) {
+                nodeIdx = 0xffff;
+            }
+#else
             nodeIdx = mFlowIdxTBL[spE];
+#endif
             break;
         }
         case NODETYPE_EVENT_e: {
+#if TARGET_PC
+            mesg_flow_node_event resolved{};
+            std::memcpy(&resolved, resolvedData.bytes, sizeof(resolved));
+            event_node = &resolved;
+#else
             event_node = &mFlowNodeTBL[nodeIdx].event;
+#endif
 
             switch(event_node->event_idx) {
             case 12:
@@ -151,7 +236,13 @@ int dMsgFlow_c::checkOpenDoor(fopAc_ac_c* i_speaker_p, int* param_2) {
                 var_r25 = TRUE;
                 break;
             default:
+#if TARGET_PC
+                if (!resolve_flow_edge(event_node->next_node_idx, nodeIdx)) {
+                    nodeIdx = 0xffff;
+                }
+#else
                 nodeIdx = mFlowIdxTBL[event_node->next_node_idx];
+#endif
                 break;
             }
             break;
@@ -311,6 +402,9 @@ void dMsgFlow_c::setInitValueGroupChange(int i_msgNo, fopAc_ac_c** i_talkPartner
     u16 var_r28 = i_msgNo;
 
     dMsgObject_changeFlowGroup(i_msgNo);
+#if TARGET_PC
+    dusk::flow::bind_resource(dMsgObject_getMsgDtPtr(), flow_group(i_msgNo));
+#endif
     setInitValue(0);
 
     mFlow_p = getMsgDataBlock("FLW1");
@@ -355,6 +449,12 @@ u8* dMsgFlow_c::getMsgDataBlock(char const* block_tag) {
 }
 
 u16 dMsgFlow_c::getInitNodeIndex(u16 param_1) {
+#if TARGET_PC
+    if (param_1 >= dusk::flow::kCustomNodeMin) {
+        return param_1;
+    }
+#endif
+
     u8* var_r30 = NULL;
     u16 var_r27 = -1;
 
@@ -387,7 +487,16 @@ void dMsgFlow_c::setNodeIndex(u16 i_nodeIdx, fopAc_ac_c** i_talkPartners) {
         dMsgObject_endFlowGroup();
         field_0x26 = 1;
     } else {
+#if TARGET_PC
+        FlowNodeData resolvedData{};
+        if (!dusk::flow::resolve_node(dMsgObject_getMsgDtPtr(), i_nodeIdx, resolvedData)) {
+            setNodeIndex(0xffff, i_talkPartners);
+            return;
+        }
+        switch (resolvedData.bytes[0]) {
+#else
         switch (mFlowNodeTBL[i_nodeIdx].message.type) {
+#endif
         case 0:
             break;
         case NODETYPE_MESSAGE_e:
@@ -397,7 +506,13 @@ void dMsgFlow_c::setNodeIndex(u16 i_nodeIdx, fopAc_ac_c** i_talkPartners) {
             break;
         case NODETYPE_EVENT_e:
             mesg_flow_node_event* node = NULL;
+#if TARGET_PC
+            mesg_flow_node_event resolved{};
+            std::memcpy(&resolved, resolvedData.bytes, sizeof(resolved));
+            node = &resolved;
+#else
             node = &mFlowNodeTBL[i_nodeIdx].event;
+#endif
 
             if (node->event_idx == 21 || node->event_idx == 32 || node->event_idx == 33) {
                 if (node->event_idx == 21) {
@@ -447,13 +562,24 @@ int dMsgFlow_c::setSelectMsg(mesg_flow_node* i_flowNode_p, mesg_flow_node* param
 
     mesg_flow_node* var_r29 = NULL;
 
+#if TARGET_PC
+    MessageEntryData selectionEntry{};
+    MessageEntryData messageEntry{};
+    if (!resolve_flow_message(param_2->msg_index, selectionEntry) ||
+        !resolve_flow_message(i_flowNode_p->msg_index, messageEntry))
+    {
+        return 0;
+    }
+    temp_r25 = message_id(selectionEntry);
+    msg_no = message_id(messageEntry);
+#else
     inf_p = (BE(u16)*)getMsgDataBlock("INF1");
-
     var_r29 = param_2;
     temp_r25 = ((inf_p + (var_r29->msg_index) * 10))[10];
 
     var_r29 = i_flowNode_p;
     msg_no = ((inf_p + (var_r29->msg_index) * 10))[10];
+#endif
 
     // "Message Set (Select)"
     OS_REPORT("\x1B[44;37mメッセ−ジセット（選択）　　　　　　\x1B[m|:");
@@ -495,9 +621,17 @@ int dMsgFlow_c::setNormalMsg(mesg_flow_node* i_flowNode_p, fopAc_ac_c* i_speaker
     mesg_flow_node* var_r29 = NULL;
     u16 msg_no;
 
+#if TARGET_PC
+    MessageEntryData messageEntry{};
+    if (!resolve_flow_message(i_flowNode_p->msg_index, messageEntry)) {
+        return 0;
+    }
+    msg_no = message_id(messageEntry);
+#else
     var_r29 = i_flowNode_p;
     inf_p = (BE(u16)*)getMsgDataBlock("INF1");
     msg_no = (inf_p + (var_r29->msg_index) * 10)[10];
+#endif
 
     // "Message Set"
     OS_REPORT("\x1B[44;37mメッセ−ジセット　　　　　　　　　　\x1B[m|:");
@@ -536,13 +670,45 @@ int dMsgFlow_c::setNormalMsg(mesg_flow_node* i_flowNode_p, fopAc_ac_c* i_speaker
 
 int dMsgFlow_c::messageNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPartners) {
     mesg_flow_node* flowNode_p = NULL;
+#if TARGET_PC
+    mesg_flow_node resolvedFlowNode{};
+    if (!resolve_flow_node(mNodeIdx, resolvedFlowNode)) {
+        setNodeIndex(0xffff, i_talkPartners);
+        return 1;
+    }
+    flowNode_p = &resolvedFlowNode;
+#else
     flowNode_p = &mFlowNodeTBL[mNodeIdx].message;
+#endif
 
     if (field_0x25 != 0) {
         if (mSelType != SELTYPE_NONE_e) {
             u16 aNextNodeIndex = flowNode_p->next_node_idx;
             JUT_ASSERT(1051, 0xFFFF != aNextNodeIndex);
 
+#if TARGET_PC
+            mesg_flow_node nextNode{};
+            if (!resolve_flow_node(aNextNodeIndex, nextNode)) {
+                setNodeIndex(0xffff, i_talkPartners);
+                return 1;
+            }
+            if (mSelType == SELTYPE_VERTICAL_e && nextNode.type == NODETYPE_MESSAGE_e) {
+                if (setSelectMsg(flowNode_p, &nextNode, i_speaker_p)) {
+                    mNodeIdx = aNextNodeIndex;
+                    mSelType = SELTYPE_NONE_e;
+                    field_0x25 = 0;
+                }
+            } else if (mSelType == SELTYPE_HORIZONTAL_e && nextNode.type == NODETYPE_BRANCH_e) {
+                if (setNormalMsg(flowNode_p, i_speaker_p)) {
+                    mSelType = SELTYPE_NONE_e;
+                    field_0x25 = 0;
+                }
+            } else {
+                OS_REPORT("★sel select mesg ===> %d, %d, %d\n", mSelType, aNextNodeIndex, nextNode.type);
+                setNodeIndex(0xffff, i_talkPartners);
+                return 1;
+            }
+#else
             if (mSelType == SELTYPE_VERTICAL_e && mFlowNodeTBL[aNextNodeIndex].message.type == NODETYPE_MESSAGE_e) {
                 JUT_ASSERT(1056, NODETYPE_MESSAGE_e == mFlowNodeTBL[aNextNodeIndex].message.type);
                 if (setSelectMsg(&mFlowNodeTBL[mNodeIdx].message, &mFlowNodeTBL[aNextNodeIndex].message, i_speaker_p)) {
@@ -559,8 +725,13 @@ int dMsgFlow_c::messageNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPart
                 OS_REPORT("★sel select mesg ===> %d, %d, %d\n", mSelType, aNextNodeIndex, mFlowNodeTBL[aNextNodeIndex].message.type);
                 JUT_ASSERT(1077, FALSE);
             }
+#endif
         } else {
+#if TARGET_PC
+            if (setNormalMsg(flowNode_p, i_speaker_p)) {
+#else
             if (setNormalMsg(&mFlowNodeTBL[mNodeIdx].message, i_speaker_p)) {
+#endif
                 field_0x25 = 0;
             }
         }
@@ -609,8 +780,20 @@ int dMsgFlow_c::messageNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPart
         case 18:
             setNodeIndex(flowNode_p->next_node_idx, i_talkPartners);
 
+#if TARGET_PC
+            if (flowNode_p->next_node_idx == 0xffff) {
+                return 1;
+            }
+            mesg_flow_node resolvedNext{};
+            if (!resolve_flow_node(flowNode_p->next_node_idx, resolvedNext)) {
+                setNodeIndex(0xffff, i_talkPartners);
+                return 1;
+            }
+            mesg_flow_node* var_r26 = &resolvedNext;
+#else
             mesg_flow_node* var_r26 = &mFlowNodeTBL[flowNode_p->next_node_idx].message;
-            if (var_r26->field_0x1 == 0x15 || var_r26->field_0x1 == 0x20 || var_r26->field_0x1 == 0x21) {
+#endif
+            if (var_r26->subtype == 0x15 || var_r26->subtype == 0x20 || var_r26->subtype == 0x21) {
                 return 0;
             }
 
@@ -623,23 +806,81 @@ int dMsgFlow_c::messageNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPart
 
 int dMsgFlow_c::branchNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPartners) {
     mesg_flow_node_branch* node = NULL;
+#if TARGET_PC
+    mesg_flow_node_branch resolvedNode{};
+    if (!resolve_flow_node(mNodeIdx, resolvedNode)) {
+        setNodeIndex(0xffff, i_talkPartners);
+        return 1;
+    }
+    node = &resolvedNode;
+    u16 proc_status;
+    if (node->query_idx >= dusk::flow::kCustomQueryMin) {
+        proc_status = dusk::flow::dispatch_query(node->query_idx, i_speaker_p, node->param,
+            node->result_count, FLOW_QUERY_PHASE_EXECUTE, mNodeIdx);
+    } else if (node->query_idx < FLOW_QUERY_BUILTIN_COUNT) {
+        proc_status = (this->*mQueryList[node->query_idx])(node, i_speaker_p, 1);
+    } else {
+        setNodeIndex(0xffff, i_talkPartners);
+        return 1;
+    }
+#else
     node = &mFlowNodeTBL[mNodeIdx].branch;
     u16 proc_status = (this->*mQueryList[node->query_idx])(node, i_speaker_p, 1);
+#endif
 
     u16 var_r28 = node->next_node_idx + proc_status;
+#if TARGET_PC
+    u16 target = 0xffff;
+    resolve_flow_edge(var_r28, target);
+    setNodeIndex(target, i_talkPartners);
+#else
     setNodeIndex(mFlowIdxTBL[var_r28], i_talkPartners);
+#endif
     return 1;
 }
 
 int dMsgFlow_c::eventNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPartners) {
     mesg_flow_node_event* node = NULL;
+#if TARGET_PC
+    mesg_flow_node_event resolvedNode{};
+    if (!resolve_flow_node(mNodeIdx, resolvedNode)) {
+        setNodeIndex(0xffff, i_talkPartners);
+        return 1;
+    }
+    node = &resolvedNode;
+    int proc_status = 1;
+    if (node->event_idx >= dusk::flow::kCustomEventMin) {
+        dusk::flow::dispatch_event(node->event_idx, i_speaker_p, node->params);
+    } else if (node->event_idx < FLOW_EVENT_BUILTIN_COUNT) {
+        proc_status = (this->*mEventList[node->event_idx])(node, i_speaker_p);
+    } else {
+        setNodeIndex(0xffff, i_talkPartners);
+        return 1;
+    }
+#else
     node = &mFlowNodeTBL[mNodeIdx].event;
     int proc_status = (this->*mEventList[node->event_idx])(node, i_speaker_p);
+#endif
+
+#if TARGET_PC
+    if (node->event_idx >= dusk::flow::kCustomEventMin) {
+        u16 target = 0xffff;
+        resolve_flow_edge(node->next_node_idx, target);
+        setNodeIndex(target, i_talkPartners);
+        return 1;
+    }
+#endif
 
     switch (node->event_idx) {
     case 8: {
         getParam(&mEventId, &field_0x30, node->params);
+#if TARGET_PC
+        u16 target = 0xffff;
+        resolve_flow_edge(node->next_node_idx, target);
+        setNodeIndex(target, i_talkPartners);
+#else
         setNodeIndex(mFlowIdxTBL[node->next_node_idx], i_talkPartners);
+#endif
 
         if (field_0x26 != 0) {
             break;
@@ -684,7 +925,13 @@ int dMsgFlow_c::eventNodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPartne
             return 0;
         }
     default:
+#if TARGET_PC
+        u16 target = 0xffff;
+        resolve_flow_edge(node->next_node_idx, target);
+        setNodeIndex(target, i_talkPartners);
+#else
         setNodeIndex(mFlowIdxTBL[node->next_node_idx], i_talkPartners);
+#endif
     }
 
     return 1;
@@ -705,7 +952,16 @@ int dMsgFlow_c::nodeProc(fopAc_ac_c* i_speaker_p, fopAc_ac_c** i_talkPartners) {
             aSpeaker_p = i_talkPartners[field_0x38];
         }
 
+#if TARGET_PC
+        FlowNodeData resolvedNode{};
+        if (!dusk::flow::resolve_node(dMsgObject_getMsgDtPtr(), mNodeIdx, resolvedNode)) {
+            setNodeIndex(0xffff, i_talkPartners);
+            break;
+        }
+        u8 type = resolvedNode.bytes[0];
+#else
         u8 type = mFlowNodeTBL[mNodeIdx].message.type;
+#endif
         switch (type) {
         case NODETYPE_MESSAGE_e:
             proc_status = messageNodeProc(aSpeaker_p, i_talkPartners);
@@ -745,7 +1001,7 @@ int dMsgFlow_c::getParam(u8* params) {
     return *(BE(int)*)params;
 }
 
-queryFunc dMsgFlow_c::mQueryList[53] = {
+DUSK_GAME_DATA queryFunc dMsgFlow_c::mQueryList[53] = {
     &dMsgFlow_c::query005, &dMsgFlow_c::query001, &dMsgFlow_c::query002, &dMsgFlow_c::query003,
     &dMsgFlow_c::query006, &dMsgFlow_c::query007, &dMsgFlow_c::query004, &dMsgFlow_c::query008,
     &dMsgFlow_c::query009, &dMsgFlow_c::query010, &dMsgFlow_c::query011, &dMsgFlow_c::query012,
@@ -1506,7 +1762,7 @@ u16 dMsgFlow_c::query042(mesg_flow_node_branch* i_flowNode_p, fopAc_ac_c* i_spea
     daMidna_c* midna_p = daPy_py_c::getMidnaActor();
 
     u8 ret = 0;
-    if (strcmp("F_SP116", dComIfGp_getStartStageName()) == 0 && dComIfGs_isSaveDunSwitch(60)) {
+    if (strcmp("F_SP116", dComIfGp_getStartStageName()) == 0 && dComIfGs_isSaveDunSwitch(60) IF_DUSK(&& !dusk::getSettings().game.canTransformAnywhere)) {
         ret = 4;
     } else if (midna_p->checkNpcNear()) {
         ret = 1;
@@ -1730,7 +1986,7 @@ u16 dMsgFlow_c::query053(mesg_flow_node_branch* i_flowNode_p, fopAc_ac_c* i_spea
     return ret;
 }
 
-eventFunc dMsgFlow_c::mEventList[43] = {
+DUSK_GAME_DATA eventFunc dMsgFlow_c::mEventList[43] = {
     &dMsgFlow_c::event000, &dMsgFlow_c::event001, &dMsgFlow_c::event002, &dMsgFlow_c::event003,
     &dMsgFlow_c::event004, &dMsgFlow_c::event005, &dMsgFlow_c::event006, &dMsgFlow_c::event007,
     &dMsgFlow_c::event008, &dMsgFlow_c::event009, &dMsgFlow_c::event010, &dMsgFlow_c::event011,
diff --git a/src/d/d_msg_object.cpp b/src/d/d_msg_object.cpp
index 6177ddc3ac..072bd5039b 100644
--- a/src/d/d_msg_object.cpp
+++ b/src/d/d_msg_object.cpp
@@ -30,12 +30,16 @@
 #include "m_Do/m_Do_lib.h"
 
 #if TARGET_PC
+#include <algorithm>
+#include <array>
+#include <vector>
+#include "dusk/language.hpp"
+#include "dusk/logging.h"
 #include "dusk/menu_pointer.h"
+#include "dusk/mods/item.hpp"
+#include "dusk/mods/svc/flow.hpp"
 #include "dusk/settings.h"
 #include "dusk/version.hpp"
-#include <vector>
-#include <array>
-#include <algorithm>
 #endif
 
 static void dMsgObject_addFundRaising(s16 param_0);
@@ -314,9 +318,16 @@ dMsgObject_HIO_c::dMsgObject_HIO_c() {
 }
 
 int dMsgObject_c::_create(msg_class* param_1) {
+#if TARGET_PC
+    if (dusk::version::isRegionJpn())
+        g_MsgObject_HIO_c.mBoxTalkScaleX = 1.1f;
+    else
+        g_MsgObject_HIO_c.mBoxTalkScaleX = 1.2f;
+#endif
+
     field_0x124 = NULL;
     field_0x100 = param_1;
-    field_0x16c = -1;
+    mCurrentGroupID = -1;
     field_0x16e = -1;
     mNowTalkFlowNo = 0;
     mpTalkActor = NULL;
@@ -403,7 +414,7 @@ int dMsgObject_c::_create(msg_class* param_1) {
     field_0x197 = 0;
     mMessageID = 1000;
     field_0x158 = mMessageID;
-    field_0x15c = 0;
+    mSelectMessageID = 0;
     field_0x172 = 0;
     setStatusLocal(1);
     mpMsgString = JKR_NEW dMsgString_c();
@@ -425,7 +436,7 @@ static void dummyStrings() {
     DEAD_STRING("");
 }
 
-dMsgObject_HIO_c g_MsgObject_HIO_c;
+DUSK_GAME_DATA dMsgObject_HIO_c g_MsgObject_HIO_c;
 
 int dMsgObject_c::_execute() {
     field_0x4c7 = 0;
@@ -644,8 +655,21 @@ static const MirrorMsgOverride mirrorMsgOverrides[] = {
     {0x17e2, 0x3ef2},
     {0x1dae, 0x44be},
     {0x14ca, 0x3bda},
-    {0x470, 0x493}, 
+    {0x470, 0x493},
     {0x473, 0x492},
+    {0x1f41, 0x4651},
+    {0x1f42, 0x4652},
+    {0x0847, 0x0870},
+    {0x0d5c, 0x0d65},
+    {0x0a97, 0x0a98},
+    {0x0327, 0x12ba},
+    {0x0328, 0x12bb},
+    {0x1534, 0x3c44},
+    {0x1536, 0x3c46},
+    {0x1557, 0x3c67},
+    {0x1b88, 0x4298},
+    {0x14c8, 0x3bd8},
+    {0x151b, 0x3c2b},
 };
 
 static u32 getMirrorMsgOverride(u32 msgId) {
@@ -658,14 +682,14 @@ static u32 getMirrorMsgOverride(u32 msgId) {
 }
 #endif
 
-void dMsgObject_c::setMessageIndex(u32 revoIndex, u32 param_2, bool param_3) {
+void dMsgObject_c::setMessageIndex(u32 revoIndex, u32 i_selectMsgID, bool param_3) {
     field_0x158 = revoIndex;
     revoIndex = getRevoMessageIndex(revoIndex);
     if (field_0x4cc == 0) {
         mNoDemoFlag = 1;
     }
     mMessageID = revoIndex;
-    field_0x15c = param_2;
+    mSelectMessageID = i_selectMsgID;
     field_0x4d1 = 0;
     if (mpTalkPartner != field_0x13c && mpTalkPartner != NULL) {
         dComIfGp_event_setTalkPartner(mpTalkPartner);
@@ -680,12 +704,58 @@ void dMsgObject_c::setMessageIndex(u32 revoIndex, u32 param_2, bool param_3) {
 
     JMSMesgInfo_c* pMsg = (JMSMesgInfo_c*)((char*)mpMsgDt + 0x20);
     u8* iVar2 = (u8*)pMsg + pMsg->header.size;
-    u32 msg_id = getMessageIndex(revoIndex);
-    dComIfGp_setMesgCameraAttrInfo(pMsg->entries[msg_id].camera_id);
-    if (field_0x15c == 1000) {
-        mpRefer->setSelMsgPtr(NULL);
+#if TARGET_PC
+    const void* customEntry = NULL;
+    const char* customText = NULL;
+    u16 customGroup = 0;
+    if (dusk::flow::custom_message_group(static_cast<u16>(revoIndex), customGroup)) {
+        if (dusk::flow::custom_message_for_control(
+                mpCtrl, static_cast<u16>(revoIndex), customEntry, customText))
+        {
+            dComIfGp_setMesgCameraAttrInfo(static_cast<const u8*>(customEntry)[0x0f]);
+        }
     } else {
-        u32 msgIndex = getMessageIndex(field_0x15c);
+#endif
+    u32 msg_id = getMessageIndex(revoIndex);
+    dComIfGp_setMesgCameraAttrInfo(pMsg->entries[msg_id].camera_attr);
+#if TARGET_PC
+    }
+    const auto setSelectionMessage = [&] {
+        const void* selectionEntry = NULL;
+        const char* selectionText = NULL;
+        u16 selectionGroup = 0;
+        if (dusk::flow::custom_message_group(static_cast<u16>(mSelectMessageID), selectionGroup)) {
+            if (dusk::flow::custom_message_for_control(
+                    mpCtrl, static_cast<u16>(mSelectMessageID), selectionEntry, selectionText))
+            {
+                mpRefer->setSelMsgPtr(const_cast<char*>(selectionText));
+            } else {
+                mpRefer->setSelMsgPtr(NULL);
+            }
+            return;
+        }
+        u32 msgIndex = getMessageIndex(mSelectMessageID);
+        if (msgIndex == 0x264) {
+            mpRefer->setSelMsgPtr(NULL);
+            return;
+        }
+        char* nativeText = (char*)(iVar2 + pMsg->entries[msgIndex].string_offset + 8);
+        const void* resolvedEntry = &pMsg->entries[msgIndex];
+        const char* resolvedText = nativeText;
+        dusk::flow::resolve_message_for_control(mpCtrl, mpMsgDt, static_cast<u16>(msgIndex),
+            resolvedEntry, nativeText, resolvedEntry, resolvedText);
+        mpRefer->setSelMsgPtr(const_cast<char*>(resolvedText));
+    };
+#endif
+    if (mSelectMessageID == 1000) {
+        mpRefer->setSelMsgPtr(NULL);
+#if TARGET_PC
+    } else {
+        setSelectionMessage();
+    }
+#else
+    } else {
+        u32 msgIndex = getMessageIndex(mSelectMessageID);
         if (msgIndex == 0x264) {
             mpRefer->setSelMsgPtr(NULL);
         } else {
@@ -693,6 +763,7 @@ void dMsgObject_c::setMessageIndex(u32 revoIndex, u32 param_2, bool param_3) {
             mpRefer->setSelMsgPtr(my_ptr);
         }
     }
+#endif
     if (param_3) {
         mpCtrl->setMessageID(mMessageID, 0, NULL);
     }
@@ -705,7 +776,7 @@ void dMsgObject_c::setMessageIndexDemo(u32 revoMsgIndex, bool param_2) {
     field_0x4d4 = 1;
     dMsgObject_onCameraCancelFlag();
     mMessageID = revoMsgIndex;
-    field_0x15c = 0x264;
+    mSelectMessageID = 0x264;
     field_0x4d1 = 0;
     if (mpTalkPartner != field_0x13c && mpTalkPartner != NULL) {
         dComIfGp_event_setTalkPartner(mpTalkPartner);
@@ -719,8 +790,23 @@ void dMsgObject_c::setMessageIndexDemo(u32 revoMsgIndex, bool param_2) {
     mpRefer->setPageNum(field_0x172);
     JMSMesgInfo_c* info_header_p = (JMSMesgInfo_c*)((char*)mpMsgDt + 0x20);
     JMSMesgInfo_c* reg_25 = (JMSMesgInfo_c*)((char*) info_header_p + info_header_p->header.size);
+#if TARGET_PC
+    const void* customEntry = NULL;
+    const char* customText = NULL;
+    u16 customGroup = 0;
+    if (dusk::flow::custom_message_group(static_cast<u16>(revoMsgIndex), customGroup)) {
+        if (dusk::flow::custom_message_for_control(
+                mpCtrl, static_cast<u16>(revoMsgIndex), customEntry, customText))
+        {
+            dComIfGp_setMesgCameraAttrInfo(static_cast<const u8*>(customEntry)[0x0f]);
+        }
+    } else {
+#endif
     int ind = getMessageIndex(revoMsgIndex);
-    dComIfGp_setMesgCameraAttrInfo(info_header_p->entries[ind].camera_id);
+    dComIfGp_setMesgCameraAttrInfo(info_header_p->entries[ind].camera_attr);
+#if TARGET_PC
+    }
+#endif
     mpRefer->setSelMsgPtr(NULL);
     if (param_2) {
         mpCtrl->setMessageID(mMessageID, 0, NULL);
@@ -746,10 +832,24 @@ u32 dMsgObject_c::getMessageIndex(u32 param_0) {
 }
 
 u32 dMsgObject_c::getRevoMessageIndex(u32 param_1) {
-#if TARGET_PC 
-    if (!dusk::getSettings().game.enableMirrorMode) { 
-        if (!g_MsgObject_HIO_c.mMessageDisplay) { return param_1; } } 
-    if (param_1 == getMirrorMsgOverride(param_1)) { return param_1; } 
+#if TARGET_PC
+    const u16 sourceGroup = param_1 > 5000 ? static_cast<u16>(s_groupID) : 0;
+    param_1 = dusk::mods::item_check_message(sourceGroup, param_1);
+
+    u16 customGroup = 0;
+    if (param_1 <= 0xffff &&
+        dusk::flow::custom_message_group(static_cast<u16>(param_1), customGroup))
+    {
+        return param_1;
+    }
+    if (!dusk::getSettings().game.enableMirrorMode) {
+        if (!g_MsgObject_HIO_c.mMessageDisplay) {
+            return param_1;
+        }
+    }
+    if (param_1 == getMirrorMsgOverride(param_1)) {
+        return param_1;
+    }
 #else 
     if (!g_MsgObject_HIO_c.mMessageDisplay) { return param_1; } 
 #endif
@@ -805,6 +905,14 @@ u32 dMsgObject_c::getMessageIDAlways(u32 param_0) {
 }
 
 s16 dMsgObject_c::getMessageGroup(u32 param_0) {
+#if TARGET_PC
+    u16 customGroup = 0;
+    if (param_0 <= 0xffff &&
+        dusk::flow::custom_message_group(static_cast<u16>(param_0), customGroup))
+    {
+        return static_cast<s16>(customGroup);
+    }
+#endif
     s16 messageGroup = 0;
     OS_REPORT("getMessgeGroup! msg no====>%d\n", param_0);
     if (param_0 > 5000) {
@@ -831,7 +939,7 @@ void dMsgObject_c::waitProc() {
                     if (mMessageID >= 0x47f && mMessageID <= 0x487) {
                         setMessageIndexDemo(mMessageID, true);
                     } else {
-                        setMessageIndex(mMessageID, field_0x15c, true);
+                        setMessageIndex(mMessageID, mSelectMessageID, true);
                     }
                 }
             }
@@ -1078,7 +1186,7 @@ void dMsgObject_c::continueProc() {
         field_0x199 = 0;
         updateEquipBombInfoLocal();
         offAutoMessageFlagLocal();
-        setMessageIndex(field_0x100->msg_idx, field_0x100->field_0xf0, true);
+        setMessageIndex(field_0x100->msg_idx, field_0x100->select_msg_idx, true);
         mpScrnDraw->fukiPosCalc(pRef->getFukiPosType());
         SAFE_STRCPY(pRef->getTextPtr(), "");
         SAFE_STRCPY(pRef->getTextSPtr(), "");
@@ -1330,7 +1438,7 @@ void dMsgObject_c::endProc() {
         }
         mMessageID = 0;
         field_0x158 = mMessageID;
-        field_0x15c = 1000;
+        mSelectMessageID = 1000;
         field_0x172 = 0;
         field_0x199 = 0;
         mpRefer->setPageNum(field_0x172);
@@ -1402,12 +1510,22 @@ void dMsgObject_c::talkStartInit() {
     field_0x19b = 0;
     bool bVar1 = false;
     if (mFukiKind != mpRefer->getFukiKind()) {
+#if TARGET_PC
+        // Safety check if MESSAGE_BOX_NOTICE is requested during a conversation
+        if (mpScrnDraw != NULL && mpRefer->getFukiKind() == 15 &&
+            dComIfGp_isHeapLockFlag() == 5) {
+            DuskLog.error("MESSAGE_BOX_NOTICE cannot be created during a conversation\n");
+        } else {
+#endif
         if (mpScrnDraw != NULL) {
             delete_screen(false);
             dVar19 = 1.0f;
             bVar1 = true;
         }
         mFukiKind = mpRefer->getFukiKind();
+#if TARGET_PC
+        }
+#endif
     }
     if (dComIfGp_isHeapLockFlag() == 8 ||
         (dComIfGp_isHeapLockFlag() == 5 && dMeter2Info_isFloatingMessageVisible() && !field_0x4cd))
@@ -1711,7 +1829,9 @@ void dMsgObject_c::readMessageGroupLocal(mDoDvdThd_mountXArchive_c** p_arcMount)
 #endif
 
     int msgGroup = dStage_stagInfo_GetMsgGroup(dComIfGp_getStage()->getStagInfo());
-    #if REGION_PAL
+#if TARGET_PC
+    snprintf(arcName, sizeof(arcName), "/res/%s/bmgres%d.arc", dusk::language::msg_folder(), msgGroup);
+#elif REGION_PAL
     switch (dComIfGs_getPalLanguage()) {
     case dSv_player_config_c::LANGUAGE_GERMAN:
         sprintf(arcName, "/res/Msgde/bmgres%d.arc", msgGroup);
@@ -1728,39 +1848,11 @@ void dMsgObject_c::readMessageGroupLocal(mDoDvdThd_mountXArchive_c** p_arcMount)
     default:
         sprintf(arcName, "/res/Msguk/bmgres%d.arc", msgGroup);
     }
-    #elif REGION_JPN
+#elif REGION_JPN
     sprintf(arcName, "/res/Msgjp/bmgres%d.arc", msgGroup);
-    #else
-#if TARGET_PC
-    // Original game UB
-
-    if (dusk::version::isRegionPal()) {
-        switch (dComIfGs_getPalLanguage()) {
-        case dSv_player_config_c::LANGUAGE_GERMAN:
-            snprintf(arcName, sizeof(arcName), "/res/Msgde/bmgres%d.arc", msgGroup);
-            break;
-        case dSv_player_config_c::LANGUAGE_FRENCH:
-            snprintf(arcName, sizeof(arcName), "/res/Msgfr/bmgres%d.arc", msgGroup);
-            break;
-        case dSv_player_config_c::LANGUAGE_SPANISH:
-            snprintf(arcName, sizeof(arcName), "/res/Msgsp/bmgres%d.arc", msgGroup);
-            break;
-        case dSv_player_config_c::LANGUAGE_ITALIAN:
-            snprintf(arcName, sizeof(arcName), "/res/Msgit/bmgres%d.arc", msgGroup);
-            break;
-        default:
-            snprintf(arcName, sizeof(arcName), "/res/Msguk/bmgres%d.arc", msgGroup);
-        }
-    } else if (dusk::version::isRegionJpn()) {
-        snprintf(arcName, sizeof(arcName), "/res/Msgjp/bmgres%d.arc", msgGroup);
-    } else {
-        snprintf(arcName, sizeof(arcName), "/res/Msgus/bmgres%d.arc", msgGroup);
-    }
-
 #else
     sprintf(arcName, "/res/Msgus/bmgres%d.arc", msgGroup);
 #endif
-    #endif
 
     *p_arcMount = mDoDvdThd_mountXArchive_c::create(arcName, 0, JKRArchive::MOUNT_MEM, NULL);
 
@@ -1773,7 +1865,11 @@ void dMsgObject_c::readMessageGroupLocal(mDoDvdThd_mountXArchive_c** p_arcMount)
 
 void dMsgObject_c::changeFlowGroupLocal(s32 param_0) {
     mFlowChk = 1;
+#if TARGET_PC
+    changeGroup(param_0 >= 3000 && param_0 < dusk::flow::kCustomNodeMin ? (s16)0 : s_groupID);
+#else
     changeGroup(param_0 >= 3000 ? (s16)0 : s_groupID);
+#endif
 }
 
 void dMsgObject_c::demoMessageGroupLocal() {
@@ -1787,25 +1883,28 @@ void dMsgObject_c::endFlowGroupLocal() {
 
 void dMsgObject_c::changeGroupLocal(s16 param_1) {
     JKRHeap* prevHeap = mDoExt_setCurrentHeap(dComIfGp_getMsgExpHeap());
-    if (field_0x16c != param_1) {
+    if (mCurrentGroupID != param_1) {
         if (mFlowChk != 0) {
             JUT_ASSERT(3688, mFlowChk != 2);
             mFlowChk = 2;
         }
         OS_REPORT("group change =====> %d\n", param_1);
         if (param_1 >= 1) {
-            OS_REPORT("bmg data change =====> %d --> %d\n", field_0x16c, param_1);
-            if (field_0x16c == 0) {
+            OS_REPORT("bmg data change =====> %d --> %d\n", mCurrentGroupID, param_1);
+            if (mCurrentGroupID == 0) {
                 field_0x19d = 1;
             }
             mpMsgDt = dMeter2Info_getStageMsgResource();
         } else {
             mpMsgDt = mpMsgRes;
         }
-        if (field_0x16c >= 0) {
+        if (mCurrentGroupID >= 0) {
             field_0x124->parse(mpMsgDt, 0x80);
         }
-        field_0x16c = param_1;
+#if TARGET_PC
+        dusk::flow::bind_resource(mpMsgDt, static_cast<u16>(param_1));
+#endif
+        mCurrentGroupID = param_1;
     }
     mDoExt_setCurrentHeap(prevHeap);
 }
diff --git a/src/d/d_msg_out_font.cpp b/src/d/d_msg_out_font.cpp
index efc655d529..ce5e97c2d0 100644
--- a/src/d/d_msg_out_font.cpp
+++ b/src/d/d_msg_out_font.cpp
@@ -1,13 +1,17 @@
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_out_font.h"
 #include "JSystem/J2DGraph/J2DTextBox.h"
 #include "JSystem/JUtility/JUTTexture.h"
 #include "d/d_meter2_info.h"
 #include "d/d_msg_object.h"
-#include "dusk/frame_interpolation.h"
+#include "d/d_msg_out_font.h"
 #include "f_op/f_op_msg_mng.h"
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/version.hpp"
+#endif
+
 COutFontSet_c::COutFontSet_c() {
     initialize();
 }
@@ -289,8 +293,10 @@ void COutFont_c::initialize() {
 
 void COutFont_c::drawFont(J2DTextBox* i_textbox, u8 i_type, f32 i_posX, f32 i_posY, f32 i_sizeX,
                           f32 i_sizeY, u32 i_color, u8 i_alpha) {
-#if VERSION != VERSION_GCN_JPN
+#if TARGET_PC || VERSION != VERSION_GCN_JPN
+    IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
     i_posY += 1.0f;
+    IF_DUSK_BLOCK_END;
 #endif
     for (int i = 0; i < 35; i++) {
         if (mpOfs[i]->getType() == 0x47) {
@@ -312,9 +318,8 @@ void COutFont_c::draw(J2DTextBox* i_textbox, f32 param_1, f32 param_2, f32 param
         sp256[i] = field_0x1b4[i];
     }
 
-#ifdef TARGET_PC
-    bool uiTickPending = dusk::frame_interp::get_ui_tick_pending();
-    if (!uiTickPending) {
+#if TARGET_PC
+    if (dusk::interp::get_ui_tick_pending()) {
         for (int i = 0; i < 70; i++) {
             sp256[i] = -1;
         }
@@ -380,7 +385,15 @@ void COutFont_c::draw(J2DTextBox* i_textbox, f32 param_1, f32 param_2, f32 param
                     break;
                 case 5:
                 case 6: {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+                    if (dusk::version::isRegionJpn()) {
+                        posY -= 2.0f;
+                        sizeY -= 2.0f;
+                    } else {
+                        posY += 1.0f;
+                        sizeY -= 3.0f;
+                    }
+#elif VERSION == VERSION_GCN_JPN
                     posY -= 2.0f;
                     sizeY -= 2.0f;
 #else
@@ -515,15 +528,12 @@ void COutFont_c::draw(J2DTextBox* i_textbox, f32 param_1, f32 param_2, f32 param
                 case 20:
                 case 21:
                 case 22:
-#ifdef TARGET_PC
-                    if (uiTickPending)
-#endif
-                    {
-                        field_0x1b4[type]++;
-                        if (field_0x1b4[type] >= 28) {
-                            field_0x1b4[type] = 0;
-                        }
+                    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                    field_0x1b4[type]++;
+                    if (field_0x1b4[type] >= 28) {
+                        field_0x1b4[type] = 0;
                     }
+                    IF_DUSK_BLOCK_END
 
                     mpPane[type]->rotate(0.5f * sizeX, 0.5f * sizeY, ROTATE_Z,
                                          (360.0f * (f32)field_0x1b4[type]) / 28.0f);
diff --git a/src/d/d_msg_scrn_3select.cpp b/src/d/d_msg_scrn_3select.cpp
index fd85da423f..b7e0e8a8db 100644
--- a/src/d/d_msg_scrn_3select.cpp
+++ b/src/d/d_msg_scrn_3select.cpp
@@ -18,6 +18,7 @@
 
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
+#include "dusk/version.hpp"
 
 namespace {
 bool hit_choice_pane(CPaneMgr* pane, f32 padding) {
@@ -28,7 +29,7 @@ bool hit_choice_pane(CPaneMgr* pane, f32 padding) {
 #endif
 
 typedef void (dMsgScrn3Select_c::*processFn)();
-processFn process[] = {
+DUSK_GAME_DATA processFn process[] = {
     &dMsgScrn3Select_c::open1Proc,  &dMsgScrn3Select_c::open2Proc,  &dMsgScrn3Select_c::waitProc,
     &dMsgScrn3Select_c::selectProc, &dMsgScrn3Select_c::changeProc, &dMsgScrn3Select_c::closeProc,
 };
@@ -118,7 +119,97 @@ dMsgScrn3Select_c::dMsgScrn3Select_c() {
         mCursorPos[i] = mpCursor_c[i]->getGlobalVtxCenter(true, 0);
     }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() == 0) {
+            mpTmSel_c[0] = JKR_NEW CPaneMgr(mpScreen, 'a_tf', 0, NULL);
+
+            mpTmSel_c[1] = JKR_NEW CPaneMgr(mpScreen, 'b_tf', 0, NULL);
+
+            mpTmSel_c[2] = JKR_NEW CPaneMgr(mpScreen, 'c_tf', 0, NULL);
+
+            mpTmrSel_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('a_tf_f'), 0, NULL);
+
+            mpTmrSel_c[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('b_tf_f'), 0, NULL);
+
+            mpTmrSel_c[2] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('c_tf_f'), 0, NULL);
+
+            for (int i = 0; i < 3; i++) {
+                ((J2DTextBox*)(mpTmSel_c[i]->getPanePtr()))->setString(64, "");
+                ((J2DTextBox*)(mpTmSel_c[i]->getPanePtr()))->setFont(mDoExt_getMesgFont());
+
+                ((J2DTextBox*)(mpTmrSel_c[i]->getPanePtr()))->setString(64, "");
+                ((J2DTextBox*)(mpTmrSel_c[i]->getPanePtr()))->setFont(mDoExt_getMesgFont());
+            }
+
+            mpScreen->search(MULTI_CHAR('a_t_e'))->hide();
+            mpScreen->search(MULTI_CHAR('b_t_e'))->hide();
+            mpScreen->search(MULTI_CHAR('c_t_e'))->hide();
+            mpScreen->search('a_tf')->show();
+            mpScreen->search('b_tf')->show();
+            mpScreen->search('c_tf')->show();
+            mpScreen->search(MULTI_CHAR('a_tf_f'))->show();
+            mpScreen->search(MULTI_CHAR('b_tf_f'))->show();
+            mpScreen->search(MULTI_CHAR('c_tf_f'))->show();
+            mpScreen->search('a_t')->hide();
+            mpScreen->search('b_t')->hide();
+            mpScreen->search('c_t')->hide();
+        } else {
+            mpTmSel_c[0] = JKR_NEW CPaneMgr(mpScreen, 'a_t', 0, NULL);
+
+            mpTmSel_c[1] = JKR_NEW CPaneMgr(mpScreen, 'b_t', 0, NULL);
+
+            mpTmSel_c[2] = JKR_NEW CPaneMgr(mpScreen, 'c_t', 0, NULL);
+
+            for (int i = 0; i < 3; i++) {
+                ((J2DTextBox*)(mpTmSel_c[i]->getPanePtr()))->setString(64, "");
+                ((J2DTextBox*)(mpTmSel_c[i]->getPanePtr()))->setFont(mDoExt_getMesgFont());
+                mpTmrSel_c[i] = NULL;
+            }
+
+            mpScreen->search(MULTI_CHAR('a_t_e'))->hide();
+            mpScreen->search(MULTI_CHAR('b_t_e'))->hide();
+            mpScreen->search(MULTI_CHAR('c_t_e'))->hide();
+            mpScreen->search('a_tf')->hide();
+            mpScreen->search('b_tf')->hide();
+            mpScreen->search('c_tf')->hide();
+            mpScreen->search(MULTI_CHAR('a_tf_f'))->hide();
+            mpScreen->search(MULTI_CHAR('b_tf_f'))->hide();
+            mpScreen->search(MULTI_CHAR('c_tf_f'))->hide();
+            mpScreen->search('a_t')->show();
+            mpScreen->search('b_t')->show();
+            mpScreen->search('c_t')->show();
+        }
+    } else {
+        mpTmSel_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('a_t_e'), 0, NULL);
+        JUT_ASSERT(0, mpTmSel_c[0] != NULL);
+
+        mpTmSel_c[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('b_t_e'), 0, NULL);
+        JUT_ASSERT(0, mpTmSel_c[1] != NULL);
+
+        mpTmSel_c[2] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('c_t_e'), 0, NULL);
+        JUT_ASSERT(0, mpTmSel_c[2] != NULL);
+
+        for (int i = 0; i < 3; i++) {
+            ((J2DTextBox*)(mpTmSel_c[i]->getPanePtr()))->setString(64, "");
+            ((J2DTextBox*)(mpTmSel_c[i]->getPanePtr()))->setFont(mDoExt_getMesgFont());
+            mpTmrSel_c[i] = NULL;
+        }
+
+        mpScreen->search(MULTI_CHAR('a_t_e'))->show();
+        mpScreen->search(MULTI_CHAR('b_t_e'))->show();
+        mpScreen->search(MULTI_CHAR('c_t_e'))->show();
+        mpScreen->search('a_tf')->hide();
+        mpScreen->search('b_tf')->hide();
+        mpScreen->search('c_tf')->hide();
+        mpScreen->search(MULTI_CHAR('a_tf_f'))->hide();
+        mpScreen->search(MULTI_CHAR('b_tf_f'))->hide();
+        mpScreen->search(MULTI_CHAR('c_tf_f'))->hide();
+        mpScreen->search('a_t')->hide();
+        mpScreen->search('b_t')->hide();
+        mpScreen->search('c_t')->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() == 0) {
         mpTmSel_c[0] = JKR_NEW CPaneMgr(mpScreen, 'a_tf', 0, NULL);
 
@@ -966,7 +1057,18 @@ void dMsgScrn3Select_c::selectTrans() {
 
     f32 sp68[3];
     for (int i = 0; i < 3; i++) {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            if (dComIfGs_getOptRuby() == 0 && (field_0x112 & (u8)(1 << i)) != 0) {
+                sp68[i] = 0.0f;
+            } else {
+                f32 temp = mpTmSel_c[i]->getInitPosY();
+                sp68[i] = mpScreen->search(tag_n[i])->getBounds().i.y - temp;
+            }
+        } else {
+            sp68[i] = 0.0f;
+        }
+#elif VERSION == VERSION_GCN_JPN
         if (dComIfGs_getOptRuby() == 0 && (field_0x112 & (u8)(1 << i)) != 0) {
             sp68[i] = 0.0f;
         } else {
diff --git a/src/d/d_msg_scrn_boss.cpp b/src/d/d_msg_scrn_boss.cpp
index 54938ceb72..b747887316 100644
--- a/src/d/d_msg_scrn_boss.cpp
+++ b/src/d/d_msg_scrn_boss.cpp
@@ -1,10 +1,11 @@
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_scrn_boss.h"
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "d/d_msg_object.h"
+#include "d/d_msg_scrn_boss.h"
 #include "d/d_pane_class.h"
+#include "dusk/version.hpp"
 
 #if TARGET_PC
 #include "dusk/settings.h"
@@ -37,8 +38,10 @@ dMsgScrnBoss_c::dMsgScrnBoss_c() {
     for (int i = 0; i < 7; i++) {
         mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag[i], 0, NULL);
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getRubyFont());
-#if VERSION != VERSION_GCN_JPN
+#if TARGET_PC || VERSION != VERSION_GCN_JPN
+        IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setCharSpace(1.0f);
+        IF_DUSK_BLOCK_END
 #endif
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x100, "");
     }
diff --git a/src/d/d_msg_scrn_explain.cpp b/src/d/d_msg_scrn_explain.cpp
index 29a88590ee..4771257ccd 100644
--- a/src/d/d_msg_scrn_explain.cpp
+++ b/src/d/d_msg_scrn_explain.cpp
@@ -14,7 +14,11 @@
 #include <cstdio>
 #include <cstring>
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+#include "dusk/version.hpp"
+#endif
+
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
 #define STR_BUF_LEN 528
 #else
 #define STR_BUF_LEN 512
@@ -95,7 +99,13 @@ dMsgScrnExplain_c::dMsgScrnExplain_c(STControl* i_stick, u8 param_1, bool i_isUs
         mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
         mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x50 = 0.0f;
+        } else {
+            field_0x50 = -10.0f;
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x50 = 0.0f;
 #else
         field_0x50 = -10.0f;
@@ -109,7 +119,48 @@ dMsgScrnExplain_c::dMsgScrnExplain_c(STControl* i_stick, u8 param_1, bool i_isUs
 
         mpScreen->search(MULTI_CHAR('n_all'))->scale(g_MsgObject_HIO_c.mBoxTalkScaleX,
                                          g_MsgObject_HIO_c.mBoxTalkScaleY);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            field_0x50 = 0.0f;
+
+            if (dComIfGs_getOptRuby() == 0) {
+                mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
+                mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s'), 0, NULL);
+
+                mpTmr_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f'), 0, NULL);
+                mpTmr_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f_s'), 0, NULL);
+
+                mpTxScreen->search(MULTI_CHAR('n_3line'))->hide();
+                mpTxScreen->search(MULTI_CHAR('n_3fline'))->show();
+                mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
+            } else {
+                mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+                mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, 't3_s', 0, NULL);
+
+                mpTmr_c[0] = NULL;
+                mpTmr_c[1] = NULL;
+
+                mpTxScreen->search(MULTI_CHAR('n_3line'))->show();
+                mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
+                mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
+            }
+        } else {
+            field_0x50 = -10.0f;
+
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+            JUT_ASSERT(162, mpTm_c[0] != NULL);
+
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, 't4_s', 0, NULL);
+            JUT_ASSERT(165, mpTm_c[1] != NULL);
+
+            mpTmr_c[0] = NULL;
+            mpTmr_c[1] = NULL;
+
+            mpTxScreen->search(MULTI_CHAR('n_3line'))->hide();
+            mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
+            mpTxScreen->search(MULTI_CHAR('n_e4line'))->show();
+        }
+#elif VERSION == VERSION_GCN_JPN
         field_0x50 = 0.0f;
 
         if (dComIfGs_getOptRuby() == 0) {
@@ -160,20 +211,12 @@ dMsgScrnExplain_c::dMsgScrnExplain_c(STControl* i_stick, u8 param_1, bool i_isUs
     f32 lineSpace = ((J2DTextBox*)mpTm_c[0]->getPanePtr())->getLineSpace();
     for (int i = 0; i < 2; i++) {
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-        ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x210, "");
-#else
-        ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+        ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setLineSpace(lineSpace);
 
         if (mpTmr_c[i] != NULL) {
             ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x210, "");
-#else
-            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
             ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setLineSpace(lineSpace);
         }
     }
@@ -320,7 +363,13 @@ void dMsgScrnExplain_c::draw(J2DOrthoGraph* i_graf) {
     SAFE_STRCPY(string_buf, ((J2DTextBox*)mpTm_c[0]->getPanePtr())->getStringPtr());
 
     mpTxScreen->draw(0.0f, 0.0f, (J2DGrafContext*)i_graf);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpString_c->getString(mOpenMsgId, (J2DTextBox*)mpTm_c[0]->getPanePtr(), NULL, NULL, NULL, 12);
+    } else {
+        mpString_c->getString(mOpenMsgId, (J2DTextBox*)mpTm_c[0]->getPanePtr(), NULL, NULL, NULL, 8);
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpString_c->getString(mOpenMsgId, (J2DTextBox*)mpTm_c[0]->getPanePtr(), NULL, NULL, NULL, 12);
 #else
     mpString_c->getString(mOpenMsgId, (J2DTextBox*)mpTm_c[0]->getPanePtr(), NULL, NULL, NULL, 8);
diff --git a/src/d/d_msg_scrn_howl.cpp b/src/d/d_msg_scrn_howl.cpp
index c701ea0b2b..c87c4bbb0f 100644
--- a/src/d/d_msg_scrn_howl.cpp
+++ b/src/d/d_msg_scrn_howl.cpp
@@ -4,24 +4,24 @@
 
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_scrn_howl.h"
-#include "m_Do/m_Do_controller_pad.h"
-#include "m_Do/m_Do_graphic.h"
-#include "d/d_msg_object.h"
-#include "d/d_pane_class.h"
+#include "JSystem/J2DGraph/J2DGrafContext.h"
+#include "JSystem/J2DGraph/J2DScreen.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "JSystem/JUtility/JUTTexture.h"
+#include "Z2AudioLib/Z2WolfHowlMgr.h"
 #include "d/actor/d_a_alink.h"
 #include "d/d_meter2.h"
 #include "d/d_meter2_draw.h"
 #include "d/d_meter2_info.h"
-#include "JSystem/JUtility/JUTTexture.h"
-#include "JSystem/JUtility/JUTAssert.h"
-#include "JSystem/J2DGraph/J2DGrafContext.h"
-#include "JSystem/J2DGraph/J2DScreen.h"
-#include "Z2AudioLib/Z2WolfHowlMgr.h"
+#include "d/d_msg_object.h"
+#include "d/d_msg_scrn_howl.h"
+#include "d/d_pane_class.h"
+#include "dusk/version.hpp"
+#include "m_Do/m_Do_controller_pad.h"
+#include "m_Do/m_Do_graphic.h"
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
-#include "dusk/settings.h"
+#include "dusk/interp/frame_interpolation.h"
 #endif
 
 // POSIX already defines a macro with this name, but we know that this specific name is
@@ -89,7 +89,21 @@ dMsgScrnHowl_c::dMsgScrnHowl_c() {
     JUT_ASSERT(96, mpButtonIcon[1] != NULL);
     mpButtonText[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('gr_txt_n'), 2, NULL);
     JUT_ASSERT(98, mpButtonText[1] != NULL);
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    J2DTextBox* piStack_19c;
+    J2DTextBox* piStack_1a0;
+    if (dusk::version::isRegionJpn()) {
+        piStack_19c = (J2DTextBox*)mpScreen->search(MULTI_CHAR('g_l_info'));
+        piStack_1a0 = (J2DTextBox*)mpScreen->search(MULTI_CHAR('g_r_info'));
+        mpScreen->search(MULTI_CHAR('fgr_info'))->hide();
+        mpScreen->search(MULTI_CHAR('fgl_info'))->hide();
+    } else {
+        piStack_19c = (J2DTextBox*)mpScreen->search(MULTI_CHAR('fgl_info'));
+        piStack_1a0 = (J2DTextBox*)mpScreen->search(MULTI_CHAR('fgr_info'));
+        mpScreen->search(MULTI_CHAR('g_l_info'))->hide();
+        mpScreen->search(MULTI_CHAR('g_r_info'))->hide();
+    }
+#elif VERSION == VERSION_GCN_JPN
     J2DTextBox* piStack_19c = (J2DTextBox*)mpScreen->search(MULTI_CHAR('g_l_info'));
     J2DTextBox* piStack_1a0 = (J2DTextBox*)mpScreen->search(MULTI_CHAR('g_r_info'));
     mpScreen->search(MULTI_CHAR('fgr_info'))->hide();
@@ -581,15 +595,12 @@ void dMsgScrnHowl_c::drawWave() {
                 f17 = local_60;
                 f18 = local_64;
             } else {
-#if TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                {
-                    field_0x2134++;
-                    if (field_0x2134 > 30) {
-                        field_0x2134 = 0;
-                    }
+                IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                field_0x2134++;
+                if (field_0x2134 > 30) {
+                    field_0x2134 = 0;
                 }
+                IF_DUSK_BLOCK_END
                 if (field_0x2134 < 15) {
                     local_dc = field_0x2134 / 15.0f;
                 } else {
diff --git a/src/d/d_msg_scrn_item.cpp b/src/d/d_msg_scrn_item.cpp
index 26a741e320..17007403dc 100644
--- a/src/d/d_msg_scrn_item.cpp
+++ b/src/d/d_msg_scrn_item.cpp
@@ -24,6 +24,10 @@
 #include "JSystem/JUtility/JUTTexture.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/version.hpp"
+#endif
+
 dMsgScrnItem_c::dMsgScrnItem_c(u8 param_1, u8 param_2, JKRExpHeap* param_3) {
     if (param_3 != NULL) {
         field_0x138 = param_3;
@@ -198,7 +202,53 @@ dMsgScrnItem_c::dMsgScrnItem_c(u8 param_1, u8 param_2, JKRExpHeap* param_3) {
 
     mpPmP_c->scale(g_MsgObject_HIO_c.mBoxItemScaleX, g_MsgObject_HIO_c.mBoxItemScaleY);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() == 0) {
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
+            JUT_ASSERT(407, mpTm_c[0] != NULL);
+
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s'), 0, NULL);
+            JUT_ASSERT(410, mpTm_c[1] != NULL);
+
+            mpTm_c[2] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_w'), 0, NULL);
+            JUT_ASSERT(413, mpTm_c[2] != NULL);
+
+            mpTmr_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f'), 0, NULL);
+            JUT_ASSERT(416, mpTmr_c[0] != NULL);
+
+            mpTmr_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f_s'), 0, NULL);
+            JUT_ASSERT(419, mpTmr_c[1] != NULL);
+
+            mpTmr_c[2] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f_w'), 0, NULL);
+            JUT_ASSERT(422, mpTmr_c[2] != NULL);
+
+            mpTxScreen->search(MULTI_CHAR('n_3line'))->hide();
+            mpTxScreen->search(MULTI_CHAR('n_3fline'))->show();
+            mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        } else {
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+            JUT_ASSERT(407, mpTm_c[0] != NULL);
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, 't3_s', 0, NULL);
+            JUT_ASSERT(410, mpTm_c[1] != NULL);
+            mpTm_c[2] = JKR_NEW CPaneMgr(mpTxScreen, 't3_w', 0, NULL);
+            JUT_ASSERT(413, mpTm_c[2] != NULL);
+            mpTxScreen->search(MULTI_CHAR('n_3line'))->show();
+            mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
+            mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        }
+    } else {
+        mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+        JUT_ASSERT(407, mpTm_c[0] != NULL);
+        mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, 't4_s', 0, NULL);
+        JUT_ASSERT(410, mpTm_c[1] != NULL);
+        mpTm_c[2] = JKR_NEW CPaneMgr(mpTxScreen, 't4_w', 0, NULL);
+        JUT_ASSERT(413, mpTm_c[2] != NULL);
+        mpTxScreen->search(MULTI_CHAR('n_3line'))->hide();
+        mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
+        mpTxScreen->search(MULTI_CHAR('n_e4line'))->show();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() == 0) {
         mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
         JUT_ASSERT(407, mpTm_c[0] != NULL);
diff --git a/src/d/d_msg_scrn_jimaku.cpp b/src/d/d_msg_scrn_jimaku.cpp
index ce059bd194..832befb543 100644
--- a/src/d/d_msg_scrn_jimaku.cpp
+++ b/src/d/d_msg_scrn_jimaku.cpp
@@ -15,6 +15,14 @@
 #include "d/d_pane_class.h"
 #include <cstring>
 
+#include "dusk/version.hpp"
+
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
+#define STR_BUF_LEN 528
+#else
+#define STR_BUF_LEN 512
+#endif
+
 dMsgScrnJimaku_c::dMsgScrnJimaku_c(u8 param_0, JKRExpHeap* i_heap) {
     if (i_heap != NULL) {
         heap = i_heap;
@@ -46,7 +54,38 @@ dMsgScrnJimaku_c::dMsgScrnJimaku_c(u8 param_0, JKRExpHeap* i_heap) {
     field_0xcc = g_MsgObject_HIO_c.mBoxPos[0][5];
     mpPmP_c->paneTrans(0.0f, field_0xcc);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() == 0) {
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('t3f_s'), 0, NULL);
+
+            mpTmr_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('mg_3f'), 0, NULL);
+            mpTmr_c[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('mg_3f_s'), 0, NULL);
+
+            mpScreen->search(MULTI_CHAR('n_3line'))->hide();
+            mpScreen->search(MULTI_CHAR('n_3fline'))->show();
+            mpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        } else {
+            mpTm_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+            mpTm_c[1] = JKR_NEW CPaneMgr(mpScreen, 't3_s', 0, NULL);
+
+            mpScreen->search(MULTI_CHAR('n_3line'))->show();
+            mpScreen->search(MULTI_CHAR('n_3fline'))->hide();
+            mpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        }
+    } else {
+        mpTm_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+        JUT_ASSERT(0, mpTm_c[0] != NULL);
+
+        mpTm_c[1] = JKR_NEW CPaneMgr(mpScreen, 't4_s', 0, NULL);
+        JUT_ASSERT(0, mpTm_c[1] != NULL);
+
+        mpScreen->search(MULTI_CHAR('n_3line'))->hide();
+        mpScreen->search(MULTI_CHAR('n_3fline'))->hide();
+        mpScreen->search(MULTI_CHAR('n_e4line'))->show();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() == 0) {
         mpTm_c[0] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
         mpTm_c[1] = JKR_NEW CPaneMgr(mpScreen, MULTI_CHAR('t3f_s'), 0, NULL);
@@ -79,21 +118,13 @@ dMsgScrnJimaku_c::dMsgScrnJimaku_c(u8 param_0, JKRExpHeap* i_heap) {
 
     for (int i = 0; i < 2; i++) {
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-        ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x210, "");
-#else
-        ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+        ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
         mpTm_c[i]->setBlackWhite(g_MsgObject_HIO_c.mBoxStartBlack[i][4],
                                  g_MsgObject_HIO_c.mBoxStartWhite[i][4]);
 
         if (mpTmr_c[i] != NULL) {
             ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x210, "");
-#else
-            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
             mpTmr_c[i]->setBlackWhite(g_MsgObject_HIO_c.mBoxStartBlack[i][4],
                                       g_MsgObject_HIO_c.mBoxStartWhite[i][4]);
         }
diff --git a/src/d/d_msg_scrn_kanban.cpp b/src/d/d_msg_scrn_kanban.cpp
index d6e91b12f6..7f254bbafb 100644
--- a/src/d/d_msg_scrn_kanban.cpp
+++ b/src/d/d_msg_scrn_kanban.cpp
@@ -4,17 +4,18 @@
 
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_scrn_kanban.h"
 #include "JSystem/J2DGraph/J2DAnmLoader.h"
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "d/d_msg_object.h"
 #include "d/d_msg_out_font.h"
+#include "d/d_msg_scrn_kanban.h"
 #include "d/d_pane_class.h"
 
 #if TARGET_PC
 #include "dusk/settings.h"
+#include "dusk/version.hpp"
 #endif
 
 dMsgScrnKanban_c::dMsgScrnKanban_c(JKRExpHeap* param_0) {
@@ -60,8 +61,48 @@ dMsgScrnKanban_c::dMsgScrnKanban_c(JKRExpHeap* param_0) {
 
     mpSpot_c->getPanePtr()->setAnimation(field_0xd0);
 
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() != 0) {
+            static u64 const t_tag[3] = {MULTI_CHAR('mg_3line'), 't3_w', 't3_s'};
+            for (int i = 0; i < 3; i++) {
+                mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag[i], 0, NULL);
+                ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
+            }
 
-#if VERSION == VERSION_GCN_JPN
+            mpScreen->search(MULTI_CHAR('n_3line'))->show();
+            mpScreen->search(MULTI_CHAR('n_3fline'))->hide();
+            mpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        } else {
+            static u64 const t_tag_2[3] = {MULTI_CHAR('t3fline'), MULTI_CHAR('t3f_w'), MULTI_CHAR('t3f_s')};
+            static u64 const tr_tag[3] = {MULTI_CHAR('mg_3f'), MULTI_CHAR('mg_3f_w'), MULTI_CHAR('mg_3f_s')};
+
+            for (int i = 0; i < 3; i++) {
+                mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag_2[i], 0, NULL);
+                ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
+
+                mpTmr_c[i] = JKR_NEW CPaneMgr(mpScreen, tr_tag[i], 0, NULL);
+                ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
+            }
+
+            mpScreen->search(MULTI_CHAR('n_3line'))->hide();
+            mpScreen->search(MULTI_CHAR('n_3fline'))->show();
+            mpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        }
+    } else {
+        static u64 const t_tag[3] = {MULTI_CHAR('mg_e4lin'), 'f4_w', 't4_s'};
+
+        for (int i = 0; i < 3; i++) {
+            mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag[i], 0, NULL);
+            JUT_ASSERT(81, mpTm_c[i] != NULL);
+            ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
+        }
+
+        mpScreen->search(MULTI_CHAR('n_3line'))->hide();
+        mpScreen->search(MULTI_CHAR('n_3fline'))->hide();
+        mpScreen->search(MULTI_CHAR('n_e4line'))->show();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() != 0) {
         static u64 const t_tag[3] = {MULTI_CHAR('mg_3line'), 't3_w', 't3_s'};
         for (int i = 0; i < 3; i++) {
diff --git a/src/d/d_msg_scrn_light.cpp b/src/d/d_msg_scrn_light.cpp
index 19671b5d57..0d9f409978 100644
--- a/src/d/d_msg_scrn_light.cpp
+++ b/src/d/d_msg_scrn_light.cpp
@@ -6,7 +6,10 @@
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "d/d_com_inf_game.h"
 #include "d/d_pane_class.h"
-#include "dusk/frame_interpolation.h"
+
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 class dMsgScrnLight_HIO_c {
 public:
@@ -203,15 +206,12 @@ void dMsgScrnLight_c::draw(f32* i_anmFrame, f32 i_posX, f32 i_posY, f32 i_scaleX
     }
 
     if (mPlayAnim) {
-#ifdef TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            *i_anmFrame += 1.0f;
-            if (*i_anmFrame >= mpBck->getFrameMax()) {
-                *i_anmFrame = 0.0f;
-            }
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        *i_anmFrame += 1.0f;
+        if (*i_anmFrame >= mpBck->getFrameMax()) {
+            *i_anmFrame = 0.0f;
         }
+        IF_DUSK_BLOCK_END
 
         mBckFrame = *i_anmFrame;
         mBpkFrame = *i_anmFrame;
@@ -226,16 +226,13 @@ void dMsgScrnLight_c::draw(f32* i_anmFrame, f32 i_posX, f32 i_posY, f32 i_scaleX
     mpParent_c->setBlackWhite(i_black, i_white);
 
     if (mPlayAnim) {
-#ifdef TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            *i_anmFrame += i_anmRate;
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        *i_anmFrame += i_anmRate;
 
-            if (*i_anmFrame >= mpBck->getFrameMax()) {
-                *i_anmFrame = 0.0f;
-            }
+        if (*i_anmFrame >= mpBck->getFrameMax()) {
+            *i_anmFrame = 0.0f;
         }
+        IF_DUSK_BLOCK_END
 
         mBckFrame = *i_anmFrame;
         mBpkFrame = *i_anmFrame;
diff --git a/src/d/d_msg_scrn_place.cpp b/src/d/d_msg_scrn_place.cpp
index 93c2ec7c20..31718f6d49 100644
--- a/src/d/d_msg_scrn_place.cpp
+++ b/src/d/d_msg_scrn_place.cpp
@@ -5,12 +5,13 @@
 
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_scrn_place.h"
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "d/d_camera.h"
 #include "d/d_msg_object.h"
+#include "d/d_msg_scrn_place.h"
 #include "d/d_pane_class.h"
+#include "dusk/version.hpp"
 
 #if TARGET_PC
 #include "dusk/settings.h"
@@ -32,7 +33,13 @@ dMsgScrnPlace_c::dMsgScrnPlace_c() {
     }
 
     mpScreen = JKR_NEW J2DScreen();
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mpScreen->setPriority("zelda_stage_title.blo", 0x20000, dComIfGp_getMsgArchive(4));
+    } else {
+        mpScreen->setPriority("zelda_stage_title_foreign.blo", 0x20000, dComIfGp_getMsgArchive(4));
+    }
+#elif VERSION == VERSION_GCN_JPN
     mpScreen->setPriority("zelda_stage_title.blo", 0x20000, dComIfGp_getMsgArchive(4));
 #else
     mpScreen->setPriority("zelda_stage_title_foreign.blo", 0x20000, dComIfGp_getMsgArchive(4));
@@ -59,7 +66,9 @@ dMsgScrnPlace_c::dMsgScrnPlace_c() {
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getRubyFont());
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x80, "");
 #if VERSION != VERSION_GCN_JPN
+        IF_DUSK_BLOCK(!dusk::version::isRegionJpn())
         ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setCharSpace(1.0f);
+        IF_DUSK_BLOCK_END
 #endif
     }
 
diff --git a/src/d/d_msg_scrn_talk.cpp b/src/d/d_msg_scrn_talk.cpp
index 5cf1b184da..1e63d67a9b 100644
--- a/src/d/d_msg_scrn_talk.cpp
+++ b/src/d/d_msg_scrn_talk.cpp
@@ -22,6 +22,15 @@
 
 #if TARGET_PC
 #include "dusk/settings.h"
+#include "dusk/version.hpp"
+#endif
+
+#if TARGET_PC
+#define STR_BUF_LEN 528
+#elif VERSION == VERSION_GCN_JPN
+#define STR_BUF_LEN 528
+#else
+#define STR_BUF_LEN 512
 #endif
 
 dMsgScrnTalk_c::dMsgScrnTalk_c(u8 param_1, u8 param_2, JKRExpHeap* param_3) {
@@ -100,7 +109,12 @@ dMsgScrnTalk_c::dMsgScrnTalk_c(u8 param_1, u8 param_2, JKRExpHeap* param_3) {
     JUT_ASSERT(153, mpMg_c[1] != NULL);
     OSInitFastCast();
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+   if (dusk::version::isRegionJpn())
+       field_0xf4 = 0.0f;
+   else
+       field_0xf4 = -10.0f;
+#elif VERSION == VERSION_GCN_JPN
     field_0xf4 = 0.0f;
 #else
     field_0xf4 = -10.0f;
@@ -110,7 +124,68 @@ dMsgScrnTalk_c::dMsgScrnTalk_c(u8 param_1, u8 param_2, JKRExpHeap* param_3) {
     JUT_ASSERT(176, mpPmP_c != NULL);
     mpPmP_c->scale(g_MsgObject_HIO_c.mBoxTalkScaleX, g_MsgObject_HIO_c.mBoxTalkScaleY);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+   if (dusk::version::isRegionJpn()) {
+       if (dComIfGs_getOptRuby() == 0) {
+           mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
+           mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s'), 0, NULL);
+
+           mpTmr_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f'), 0, NULL);
+           if (dMsgObject_getMsgObjectClass()->getFukiKind() == 8) {
+               mpTm_c[2] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s1'), 0, NULL);
+               mpTm_c[3] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s2'), 0, NULL);
+               mpTm_c[4] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s3'), 0, NULL);
+               mpTm_c[5] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s4'), 0, NULL);
+               mpTmr_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f_s1'), 0, NULL);
+               mpTmr_c[2] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f_s2'), 0, NULL);
+           } else {
+               mpTmr_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3f_s'), 0, NULL);
+           }
+
+           mpTxScreen->search(MULTI_CHAR('n_3line'))->hide();
+           mpTxScreen->search(MULTI_CHAR('n_3fline'))->show();
+           mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
+       } else {
+           mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3line'), 0, NULL);
+           mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, 't3_s', 0, NULL);
+
+           if (dMsgObject_getMsgObjectClass()->getFukiKind() == 8) {
+               mpTm_c[2] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3_s1'), 0, NULL);
+               JUT_ASSERT(189, mpTm_c[2] != NULL);
+               mpTm_c[3] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3_s2'), 0, NULL);
+               JUT_ASSERT(191, mpTm_c[3] != NULL);
+               mpTm_c[4] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3_s3'), 0, NULL);
+               JUT_ASSERT(193, mpTm_c[4] != NULL);
+               mpTm_c[5] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3_s4'), 0, NULL);
+               JUT_ASSERT(193, mpTm_c[5] != NULL);
+           }
+
+           mpTxScreen->search(MULTI_CHAR('n_3line'))->show();
+           mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
+           mpTxScreen->search(MULTI_CHAR('n_e4line'))->hide();
+       }
+   } else {
+       mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_e4lin'), 0, NULL);
+       JUT_ASSERT(182, mpTm_c[0] != NULL);
+       mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, 't4_s', 0, NULL);
+       JUT_ASSERT(185, mpTm_c[1] != NULL);
+
+       if (dMsgObject_getMsgObjectClass()->getFukiKind() == 8) {
+           mpTm_c[2] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t4_s1'), 0, NULL);
+           JUT_ASSERT(189, mpTm_c[2] != NULL);
+           mpTm_c[3] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t4_s2'), 0, NULL);
+           JUT_ASSERT(191, mpTm_c[3] != NULL);
+           mpTm_c[4] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t4_s3'), 0, NULL);
+           JUT_ASSERT(193, mpTm_c[4] != NULL);
+           mpTm_c[5] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t4_s4'), 0, NULL);
+           JUT_ASSERT(193, mpTm_c[5] != NULL);
+       }
+
+       mpTxScreen->search(MULTI_CHAR('n_3line'))->hide();
+       mpTxScreen->search(MULTI_CHAR('n_3fline'))->hide();
+       mpTxScreen->search(MULTI_CHAR('n_e4line'))->show();
+   }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() == 0) {
         mpTm_c[0] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('mg_3flin'), 0, NULL);
         mpTm_c[1] = JKR_NEW CPaneMgr(mpTxScreen, MULTI_CHAR('t3f_s'), 0, NULL);
@@ -173,19 +248,11 @@ dMsgScrnTalk_c::dMsgScrnTalk_c(u8 param_1, u8 param_2, JKRExpHeap* param_3) {
     for (int i = 0; i < 6; i++) {
         if (mpTm_c[i] != NULL) {
             ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-            ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x210, "");
-#else
-            ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+            ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
         }
         if (mpTmr_c[i] != NULL) {
             ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setFont(mDoExt_getMesgFont());
-#if VERSION == VERSION_GCN_JPN
-            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x210, "");
-#else
-            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x200, "");
-#endif
+            ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(STR_BUF_LEN, "");
         }
     }
     if (dMsgObject_getMsgObjectClass()->getFukiKind() != 8) {
diff --git a/src/d/d_msg_scrn_tree.cpp b/src/d/d_msg_scrn_tree.cpp
index 899a8f449a..bbed47cb05 100644
--- a/src/d/d_msg_scrn_tree.cpp
+++ b/src/d/d_msg_scrn_tree.cpp
@@ -1,16 +1,17 @@
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_scrn_tree.h"
 #include "JSystem/J2DGraph/J2DAnmLoader.h"
 #include "JSystem/J2DGraph/J2DGrafContext.h"
 #include "JSystem/J2DGraph/J2DScreen.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "d/d_msg_object.h"
 #include "d/d_msg_out_font.h"
+#include "d/d_msg_scrn_tree.h"
 #include "d/d_pane_class.h"
 
 #if TARGET_PC
 #include "dusk/settings.h"
+#include "dusk/version.hpp"
 #endif
 
 dMsgScrnTree_c::dMsgScrnTree_c(JUTFont* param_0, JKRExpHeap* param_1) {
@@ -61,7 +62,52 @@ dMsgScrnTree_c::dMsgScrnTree_c(JUTFont* param_0, JKRExpHeap* param_1) {
 
     mpScreen->search(MULTI_CHAR('white_m'))->setAnimation(field_0xd4);
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        if (dComIfGs_getOptRuby() != 0) {
+            for (int i = 0; i < 3; i++) {
+                static u64 const t_tag[3] = {MULTI_CHAR('mg_3line'), 't3_w', 't3_s'};
+
+                mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag[i], 0, NULL);
+                ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(field_0x54);
+                ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x210, "");
+            }
+
+            mpScreen->search(MULTI_CHAR('n_3line'))->show();
+            mpScreen->search(MULTI_CHAR('n_3fline'))->hide();
+            mpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        } else {
+            for (int i = 0; i < 3; i++) {
+                static u64 const t_tag[3] = {MULTI_CHAR('t3fline'), MULTI_CHAR('t3f_w'), MULTI_CHAR('t3f_s')};
+                static u64 const tr_tag[3] = {MULTI_CHAR('mg_3f'), MULTI_CHAR('mg_3f_w'), MULTI_CHAR('mg_3f_s')};
+
+                mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag[i], 0, NULL);
+                ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(field_0x54);
+                ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x210, "");
+
+                mpTmr_c[i] = JKR_NEW CPaneMgr(mpScreen, tr_tag[i], 0, NULL);
+                ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setFont(field_0x54);
+                ((J2DTextBox*)mpTmr_c[i]->getPanePtr())->setString(0x210, "");
+            }
+
+            mpScreen->search(MULTI_CHAR('n_3line'))->hide();
+            mpScreen->search(MULTI_CHAR('n_3fline'))->show();
+            mpScreen->search(MULTI_CHAR('n_e4line'))->hide();
+        }
+    } else {
+        for (int i = 0; i < 3; i++) {
+            static u64 const t_tag[3] = {MULTI_CHAR('mg_e4lin'), 'f4_w', 't4_s'};
+
+            mpTm_c[i] = JKR_NEW CPaneMgr(mpScreen, t_tag[i], 0, NULL);
+            ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setFont(field_0x54);
+            ((J2DTextBox*)mpTm_c[i]->getPanePtr())->setString(0x200, "");
+        }
+
+        mpScreen->search(MULTI_CHAR('n_3line'))->hide();
+        mpScreen->search(MULTI_CHAR('n_3fline'))->hide();
+        mpScreen->search(MULTI_CHAR('n_e4line'))->show();
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGs_getOptRuby() != 0) {
         for (int i = 0; i < 3; i++) {
             static u64 const t_tag[3] = {MULTI_CHAR('mg_3line'), 't3_w', 't3_s'};
diff --git a/src/d/d_msg_unit.cpp b/src/d/d_msg_unit.cpp
index 55fc588d4e..e81e5cd2b5 100644
--- a/src/d/d_msg_unit.cpp
+++ b/src/d/d_msg_unit.cpp
@@ -1,11 +1,12 @@
 #include "d/dolzel.h" // IWYU pragma: keep
 
-#include "d/d_msg_unit.h"
-#include "d/d_com_inf_game.h"
 #include <cstdio>
 #include <cstring>
+#include "d/d_com_inf_game.h"
 #include "d/d_kankyo.h"
 #include "d/d_meter2_info.h"
+#include "d/d_msg_unit.h"
+#include "dusk/version.hpp"
 
 // temporary until a better solution is found
 typedef struct dMsgUnit_inf1_entry {
@@ -41,6 +42,197 @@ dMsgUnit_c::dMsgUnit_c() {}
 
 dMsgUnit_c::~dMsgUnit_c() {}
 
+#if TARGET_PC
+typedef struct dMsgUnit_inf1_entry_JPN {
+    BE(u32) dat1EntryOffset;
+    BE(u16) field_0x04;
+    BE(u16) field_0x06;
+    BE(u16) field_0x08;
+    BE(u16) field_0x0a;
+    BE(u16) field_0x0c;
+    BE(u16) field_0x0e;
+    BE(u16) field_0x10;
+    BE(u16) field_0x12;
+    BE(u16) field_0x14;
+    BE(u16) field_0x16;
+    BE(u16) field_0x18;
+    BE(u16) field_0x1A;
+} dMsgUnit_inf1_entry_JPN;
+
+typedef struct dMsgUnit_inf1_section_JPN {
+    /* 0x00 */ BE(u32) msgType;   // sectionType
+    /* 0x04 */ BE(u32) size;    // total size of the section
+    /* 0x08 */ BE(u16) entryCount;
+    /* 0x0A */ BE(u16) entryLength;
+    /* 0x0C */ BE(u16) msgArchiveId;
+    /* 0x10 */ dMsgUnit_inf1_entry_JPN entries[0];
+} dMsgUnit_inf1_section_JPN;
+
+void dMsgUnit_c::setTag_jpn(int i_type, int i_value, TEXT_SPAN o_buffer, bool param_4) {
+    *o_buffer = 0;
+    bool stack9 = false;
+    bool stack8 = false;
+    int value = i_value;
+
+    if (i_type == 0x10000) {
+        SAFE_SPRINTF(o_buffer, "%d", i_value);
+        return;
+    }
+
+    if (i_type == 0x10001) {
+        int tens_digit = i_value / 10;
+        int ones_digit = i_value % 10;
+        SAFE_SPRINTF(o_buffer, "%d-%d", tens_digit, ones_digit);
+        return;
+    }
+
+    if ((i_type == 4 && param_4 == true) || (i_type == 5 && param_4 == false)) {
+        int seconds = i_value / 1000;
+        int minutes = seconds / 60;
+        seconds -= minutes * 60;
+        if (minutes > 99) {
+            minutes = 99;
+            seconds = 59;
+        }
+
+        if (minutes == 0 && seconds == 0) {
+            if (strcmp(dComIfGp_getStartStageName(), "F_SP00") == 0) {
+                return;
+            }
+        }
+
+        if (i_type == 4) {
+            i_value = minutes;
+            if (minutes == 0) {
+                stack9 = true;
+            }
+        }
+
+        if (i_type == 5) {
+            if (seconds == 0 && minutes != 0) {
+                return;
+            }
+            i_value = seconds;
+        }
+    }
+
+    if ((i_type == 3 && param_4 == true) || (i_type == 4 && param_4 == false)) {
+        f32 dayTime = g_env_light.getDaytime();
+        f32 hour = dayTime / 15.0f;
+
+        f32 iVar8b = ((s32)(1000000.0f * dayTime) % 15000000) / 1000000.0f;
+        f32 minute = 60.0f * (iVar8b / 15.0f);
+        // not sure why this affects codegen, in theory it should be optimized out
+        f32 minute2 = 60.0f * (iVar8b / 15.0f);
+        if (i_type == 3) {
+            i_value = (s32)hour;
+        }
+
+        if (i_type == 4) {
+            i_value = (s32)minute;
+        }
+    }
+
+    if (i_type == 9 && param_4 == true) {
+        SAFE_SPRINTF(o_buffer, "%d", i_value);
+        stack8 = true;
+    }
+
+    if (!stack9) {
+        bmg_header_t* pHeader = (bmg_header_t*)dMeter2Info_getMsgUnitResource();
+        bmg_section_t* pInfoBlock = NULL;
+        const void* pMsgDataBlock = NULL;
+        str1_section_t* pStrAttributeBlock = NULL;
+        int filepos = sizeof(bmg_header_t);
+        u32 filesize = pHeader->size;
+        u8* pSection = ((u8*)pHeader) + filepos;
+
+        while (filepos < filesize) {
+            switch(((bmg_section_t*)pSection)->magic) {
+            case 'FLW1':
+                break;
+            case 'FLI1':
+                break;
+            case 'INF1':
+                pInfoBlock = (bmg_section_t*)pSection;
+                break;
+            case 'DAT1':
+                pMsgDataBlock = pSection;
+                break;
+            case 'STR1':
+                pStrAttributeBlock = (str1_section_t*)pSection;
+                break;
+            }
+            filepos += ((bmg_section_t*)pSection)->size;
+            pSection += ((bmg_section_t*)pSection)->size;
+        }
+
+        u16 vals[12];
+        vals[0] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x04;
+        vals[1] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x06;
+        vals[2] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x08;
+        vals[3] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x0a;
+        vals[4] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x0c;
+        vals[5] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x0e;
+        vals[6] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x10;
+        vals[7] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x12;
+        vals[8] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x14;
+        vals[9] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x16;
+        vals[10] = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].field_0x18;
+        u32 dat1EntryOffset = ((dMsgUnit_inf1_section_JPN*)pInfoBlock)->entries[i_type].dat1EntryOffset;
+
+        char* dat1Entry = (char*)((u8*)pMsgDataBlock + dat1EntryOffset + 8);
+
+        const char* uVar5;
+        if (i_value == 0) {
+            uVar5 = pStrAttributeBlock->entries->str + vals[0];
+        } else if ((i_value % 10) == 0) {
+            uVar5 = pStrAttributeBlock->entries->str + (vals[10]);
+        } else {
+            uVar5 = pStrAttributeBlock->entries->str + vals[i_value % 10];
+        }
+
+        int uVar5Len = strlen(uVar5);
+        if (uVar5Len == 0) {
+            if (stack8) {
+                SAFE_STRCAT(o_buffer, dat1Entry);
+            } else {
+                SAFE_SPRINTF(o_buffer, "%d%s", i_value, dat1Entry);
+            }
+        } else {
+            char unkCharArr[7];
+            unkCharArr[0] = 26;
+            unkCharArr[1] = uVar5Len + 6;
+            unkCharArr[2] = -1;
+            unkCharArr[3] = -1;
+            unkCharArr[4] = 2;
+            unkCharArr[5] = strlen(dat1Entry) / 2;
+            unkCharArr[6] = 0;
+
+            if (stack8) {
+                SAFE_STRCAT(o_buffer, unkCharArr);
+                SAFE_STRCAT(o_buffer, uVar5);
+                SAFE_STRCAT(o_buffer, dat1Entry);
+            } else {
+                SAFE_SPRINTF(o_buffer, "%d%s%s%s", i_value, unkCharArr, uVar5, dat1Entry);
+            }
+        }
+    }
+
+    if (i_type == 3 && param_4 == true) {
+        char buffer[20];
+        setTag(4, 0, buffer, false);
+        SAFE_STRCAT(o_buffer, buffer);
+    }
+
+    if (i_type == 4 && param_4 == true) {
+        char buffer[20];
+        setTag(5, value, buffer, false);
+        SAFE_STRCAT(o_buffer, buffer);
+    }
+}
+#endif
+
 #if REGION_JPN
 void dMsgUnit_c::setTag(int i_type, int i_value, TEXT_SPAN o_buffer, bool param_4) {
     *o_buffer = 0;
@@ -208,6 +400,13 @@ void dMsgUnit_c::setTag(int i_type, int i_value, TEXT_SPAN o_buffer, bool param_
 }
 #else
 void dMsgUnit_c::setTag(int i_type, int i_value, TEXT_SPAN o_buffer, bool param_4) {
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        setTag_jpn(i_type, i_value, o_buffer, param_4);
+        return;
+    }
+#endif
+
     *o_buffer = 0;
     bool stack9 = false;
     bool stack8 = false;
@@ -379,4 +578,4 @@ void dMsgUnit_c::setTag(int i_type, int i_value, TEXT_SPAN o_buffer, bool param_
 }
 #endif
 
-dMsgUnit_c g_msg_unit;
+DUSK_GAME_DATA dMsgUnit_c g_msg_unit;
diff --git a/src/d/d_name.cpp b/src/d/d_name.cpp
index 6e3f8bca89..89506e8078 100644
--- a/src/d/d_name.cpp
+++ b/src/d/d_name.cpp
@@ -8,15 +8,76 @@
 #include "m_Do/m_Do_controller_pad.h"
 #include <cstdio>
 #include <cstring>
-
 #include "JSystem/J2DGraph/J2DAnmLoader.h"
-#include "dusk/version.hpp"
 #include "f_op/f_op_msg_mng.h"
 
+#if TARGET_PC
+#include "dusk/utilities.hpp"
+#include "dusk/version.hpp"
+
 static bool isPalOrJpn() {
     return dusk::version::isRegionPal() || dusk::version::isRegionJpn();
 }
 
+#define SJIS_MOJI(wmoji) ((static_cast<u16>(static_cast<u8>((wmoji)[0])) << 8) | static_cast<u8>((wmoji)[1]))
+
+static const char* l_mojiHira[65] = {
+    "\x82\xA0", "\x82\xA2", "\x82\xA4", "\x82\xA6", "\x82\xA8", "\x82\xA9", "\x82\xAB", "\x82\xAD", "\x82\xAF", "\x82\xB1", "\x82\xB3", "\x82\xB5", "\x82\xB7",
+    "\x82\xB9", "\x82\xBB", "\x82\xBD", "\x82\xBF", "\x82\xC2", "\x82\xC4", "\x82\xC6", "\x82\xC8", "\x82\xC9", "\x82\xCA", "\x82\xCB", "\x82\xCC", "\x82\xCD",
+    "\x82\xD0", "\x82\xD3", "\x82\xD6", "\x82\xD9", "\x82\xDC", "\x82\xDD", "\x82\xDE", "\x82\xDF", "\x82\xE0", "\x82\xE2", "\x81\x40", "\x82\xE4", "\x81\x40",
+    "\x82\xE6", "\x82\xE7", "\x82\xE8", "\x82\xE9", "\x82\xEA", "\x82\xEB", "\x82\xED", "\x81\x40", "\x82\xF0", "\x81\x40", "\x82\xF1", "\x82\x9F", "\x82\xA1",
+    "\x82\xA3", "\x82\xA5", "\x82\xA7", "\x82\xE1", "\x81\x40", "\x82\xE3", "\x81\x40", "\x82\xE5", "\x82\xC1", "\x81\x40", "\x81\x5B", "\x81\x4A", "\x81\x4B",
+};
+
+static const char* l_mojiHira2[65] = {
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x82\xAA", "\x82\xAC", "\x82\xAE", "\x82\xB0", "\x82\xB2", "\x82\xB4", "\x82\xB6", "\x82\xB8",
+    "\x82\xBA", "\x82\xBC", "\x82\xBE", "\x82\xC0", "\x82\xC3", "\x82\xC5", "\x82\xC7", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x82\xCE",
+    "\x82\xD1", "\x82\xD4", "\x82\xD7", "\x82\xDA", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+};
+
+static const char* l_mojiHira3[65] = {
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x82\xCF",
+    "\x82\xD2", "\x82\xD5", "\x82\xD8", "\x82\xDB", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+};
+
+static const char* l_mojikata[65] = {
+    "\x83\x41", "\x83\x43", "\x83\x45", "\x83\x47", "\x83\x49", "\x83\x4A", "\x83\x4C", "\x83\x4E", "\x83\x50", "\x83\x52", "\x83\x54", "\x83\x56", "\x83\x58",
+    "\x83\x5A", "\x83\x5C", "\x83\x5E", "\x83\x60", "\x83\x63", "\x83\x65", "\x83\x67", "\x83\x69", "\x83\x6A", "\x83\x6B", "\x83\x6C", "\x83\x6D", "\x83\x6E",
+    "\x83\x71", "\x83\x74", "\x83\x77", "\x83\x7A", "\x83\x7D", "\x83\x7E", "\x83\x80", "\x83\x81", "\x83\x82", "\x83\x84", "\x81\x40", "\x83\x86", "\x81\x40",
+    "\x83\x88", "\x83\x89", "\x83\x8A", "\x83\x8B", "\x83\x8C", "\x83\x8D", "\x83\x8F", "\x81\x40", "\x83\x93", "\x81\x40", "\x83\x93", "\x83\x40", "\x83\x42",
+    "\x83\x44", "\x83\x46", "\x83\x48", "\x83\x83", "\x81\x40", "\x83\x85", "\x81\x40", "\x83\x87", "\x83\x62", "\x81\x40", "\x81\x5B", "\x81\x4A", "\x81\x4B",
+};
+
+static const char* l_mojikata2[65] = {
+    "\x81\x8F", "\x81\x8F", "\x83\x94", "\x81\x8F", "\x81\x8F", "\x83\x4B", "\x83\x4D", "\x83\x4F", "\x83\x51", "\x83\x53", "\x83\x55", "\x83\x57", "\x83\x59",
+    "\x83\x5B", "\x83\x5D", "\x83\x5F", "\x83\x61", "\x83\x64", "\x83\x66", "\x83\x68", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x83\x6F",
+    "\x83\x72", "\x83\x75", "\x83\x78", "\x83\x7B", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+};
+
+static const char* l_mojikata3[65] = {
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x83\x70",
+    "\x83\x73", "\x83\x76", "\x83\x79", "\x83\x7C", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+    "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F", "\x81\x8F",
+};
+
+static const char* l_mojiEisu[65] = {
+    "A", "N", "a", "n", "1", "B", "O", "b", "o", "2", "C", "P", "c", "p", "3", "D", "Q",
+    "d", "q", "4", "E", "R", "e", "r", "5", "F", "S", "f", "s", "6", "G", "T", "g", "t",
+    "7", "H", "U", "h", "u", "8", "I", "V", "i", "v", "9", "J", "W", "j", "w", "0", "K",
+    "X", "k", "x", ",", "L", "Y", "l", "y", ".", "M", "Z", "m", "z", " ",
+};
+#else
+#define SJIS_MOJI(wmoji) *(u16*)wmoji
+
 static const char* l_mojiHira[65] = {
     "あ", "い", "う", "え", "お", "か", "き", "く", "け", "こ", "さ", "し", "す",
     "せ", "そ", "た", "ち", "つ", "て", "と", "な", "に", "ぬ", "ね", "の", "は",
@@ -71,6 +132,7 @@ static const char* l_mojiEisu[65] = {
     "7", "H", "U", "h", "u", "8", "I", "V", "i", "v", "9", "J", "W", "j", "w", "0", "K",
     "X", "k", "x", ",", "L", "Y", "l", "y", ".", "M", "Z", "m", "z", " ",
 };
+#endif
 
 #if TARGET_PC
 // The game normally mutates this string list to fill in the real character codes.
@@ -106,7 +168,7 @@ static const char* l_mojiEisuPal_2[65] = {
 
 #if TARGET_PC
 // '　' (full-width space)
-#define SPACE_MAYBE_FULL (dusk::version::isRegionJpn() ? '\x81\x40' : ' ')
+#define SPACE_MAYBE_FULL (dusk::version::isRegionJpn() ? 0x8140U : ' ')
 #elif REGION_JPN
 // '　' (full-width space)
 #define SPACE_MAYBE_FULL '\x81\x40'
@@ -274,11 +336,15 @@ void dName_c::_move() {
         mDoAud_seStart(Z2SE_SY_DUMMY, 0, 0, 0);
         mPrevMojiSet = mMojiSet;
         mMojiSet++;
-        #if REGION_JPN
-        if (mMojiSet > MOJI_EIGO) {
+
+        #if TARGET_PC
+        if ((dusk::version::isRegionJpn() && mMojiSet > MOJI_EIGO) || (!dusk::version::isRegionJpn() && mMojiSet > MOJI_KATA))
+        #elif REGION_JPN
+        if (mMojiSet > MOJI_EIGO)
         #else
-        if (mMojiSet > MOJI_KATA) {
+        if (mMojiSet > MOJI_KATA)
         #endif
+        {
             mMojiSet = MOJI_HIRA;
         }
         mojiListChange();
@@ -373,7 +439,7 @@ int dName_c::nameCheck() {
         #if REGION_JPN
         if (mChrInfo[len].mCharacter != ' ' && mChrInfo[len].mCharacter != '\x81\x40') {
         #else
-        if (mChrInfo[len].mCharacter != ' ' IF_DUSK(&& (!dusk::version::isRegionJpn() || mChrInfo[len].mCharacter != '\x81\x40'))) {
+        if (mChrInfo[len].mCharacter != ' ' IF_DUSK(&& (!dusk::version::isRegionJpn() || mChrInfo[len].mCharacter != 0x8140U))) {
         #endif
             return len + 1;
         }
@@ -392,7 +458,12 @@ void dName_c::playNameSet(int nameLength) {
             *str = mChrInfo[i].mCharacter;
             str += 1;
         } else {
+            #if TARGET_PC
+            str[0] = mChrInfo[i].mCharacter >> 8;
+            str[1] = mChrInfo[i].mCharacter & 0xFF;
+            #else
             *(u16*)str = mChrInfo[i].mCharacter;
+            #endif
             str += 2;
         }
         #else
@@ -625,30 +696,41 @@ int dName_c::mojiChange(u8 idx) {
 }
 
 void dName_c::selectMojiSet() {
-    #if REGION_JPN
-    int moji = getMoji();
-    if (moji != -1) {
-        if (moji == '゛' || moji == '゜') {
-            if (mCurPos != 0) {
-                if (checkDakuon(moji, mCurPos - 1) == 1) {
-                    mDoAud_seStart(Z2SE_SY_NAME_INPUT, NULL, 0, 0);
-                    setDakuon(moji, mCurPos - 1);
-                } else {
-                    mDoAud_seStart(Z2SE_SYS_ERROR, NULL, 0, 0);
+#if TARGET_PC || REGION_JPN
+    #if TARGET_PC
+    if (dusk::version::isRegionJpn())
+    #endif
+    {
+        int moji = getMoji();
+        if (moji != -1) {
+            if (moji == SJIS('゛', 0x814AU) || moji == SJIS('゜', 0x814BU)) {
+                if (mCurPos != 0) {
+                    if (checkDakuon(moji, mCurPos - 1) == 1) {
+                        mDoAud_seStart(Z2SE_SY_NAME_INPUT, NULL, 0, 0);
+                        setDakuon(moji, mCurPos - 1);
+                    } else {
+                        mDoAud_seStart(Z2SE_SYS_ERROR, NULL, 0, 0);
+                    }
                 }
+            } else {
+                setMoji(moji);
             }
-        } else {
-            setMoji(moji);
         }
     }
+    #if TARGET_PC
+    else {
+        setMoji(getMoji());
+    }
+    #endif
+
     setNameText();
-    #else
+#else
     setMoji(getMoji());
     setNameText();
-    #endif
+#endif
 }
 
-#if REGION_JPN
+#if TARGET_PC || REGION_JPN
 int dName_c::checkDakuon(int param_0, u8 param_1) {
     if (mChrInfo[param_1].mMojiSet == MOJI_EIGO) {
         return 0;
@@ -658,17 +740,17 @@ int dName_c::checkDakuon(int param_0, u8 param_1) {
         return 0;
     }
 
-    if (param_0 == '゜' && mChrInfo[param_1].mColumn != 5) {
+    if (param_0 == SJIS('゜', 0x814BU) && mChrInfo[param_1].mColumn != 5) {
         return 0;
     }
 
-    if (param_0 == '゛' &&
-        (mChrInfo[param_1].mCharacter == 'ウ' || mChrInfo[param_1].mCharacter == 'ヴ'))
+    if (param_0 == SJIS('゛', 0x814AU) &&
+        (mChrInfo[param_1].mCharacter == SJIS('ウ', 0x8345U) || mChrInfo[param_1].mCharacter == SJIS('ヴ', 0x8394U)))
     {
         return 1;
     }
 
-    if (param_0 == '゛' && mChrInfo[param_1].mColumn != 1 && mChrInfo[param_1].mColumn != 2 &&
+    if (param_0 == SJIS('゛', 0x814AU) && mChrInfo[param_1].mColumn != 1 && mChrInfo[param_1].mColumn != 2 &&
         mChrInfo[param_1].mColumn != 3 && mChrInfo[param_1].mColumn != 5)
     {
         return 0;
@@ -680,46 +762,46 @@ int dName_c::checkDakuon(int param_0, u8 param_1) {
 int dName_c::setDakuon(int param_1, u8 param_2) {
     int c;
 
-    if (param_1 == '゛') {
+    if (param_1 == SJIS('゛', 0x814AU)) {
         switch (mChrInfo[param_2].mColumn) {
         case 0: {
             c = -1;
-            if (mChrInfo[param_2].mCharacter == 'ウ' || mChrInfo[param_2].mCharacter == 'ヴ') {
+            if (mChrInfo[param_2].mCharacter == SJIS('ウ', 0x8345U) || mChrInfo[param_2].mCharacter == SJIS('ヴ', 0x8394U)) {
                 c = 4;
-                mChrInfo[param_2].mCharacter = 'ヴ';
+                mChrInfo[param_2].mCharacter = SJIS('ヴ', 0x8394U);
             }
             break;
         }
         case 1: {
-            int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'カ' : 'か';
+            int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('カ', 0x834AU) : SJIS('か', 0x82A9U);
             c = (mChrInfo[param_2].mCharacter - c2) % 2;
             break;
         }
         case 2: {
-            int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'サ' : 'さ';
+            int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('サ', 0x8354U) : SJIS('さ', 0x82B3U);
             c = (mChrInfo[param_2].mCharacter - c2) % 2;
             break;
         }
         case 3: {
             int c2;
             if (mChrInfo[param_2].mCharacter <=
-                ((mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'ヂ' : 'ぢ')))
+                ((mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('ヂ', 0x8361U) : SJIS('ぢ', 0x82C0U))))
             {
-                c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'タ' : 'た';
+                c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('タ', 0x835EU) : SJIS('た', 0x82BDU);
                 c = (mChrInfo[param_2].mCharacter - c2) % 2;
             } else {
-                if (mChrInfo[param_2].mCharacter <= (mChrInfo[param_2].mMojiSet != 0 ? 'ド' : 'ど'))
+                if (mChrInfo[param_2].mCharacter <= (mChrInfo[param_2].mMojiSet != 0 ? SJIS('ド', 0x8368U) : SJIS('ど', 0x82C7U)))
                 {
                     if (mChrInfo[param_2].mCharacter >=
-                        (mChrInfo[param_2].mMojiSet != 0 ? 'テ' : 'て'))
+                        (mChrInfo[param_2].mMojiSet != 0 ? SJIS('テ', 0x8365U) : SJIS('て', 0x82C4U)))
                     {
-                        c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'テ' : 'て';
+                        c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('テ', 0x8365U) : SJIS('て', 0x82C4U);
                         c = (mChrInfo[param_2].mCharacter - c2) % 2;
                         break;
                     }
                 }
 
-                c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'ッ' : 'っ';
+                c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('ッ', 0x8362U) : SJIS('っ', 0x82C1U);
                 c = (mChrInfo[param_2].mCharacter - c2) % 3;
                 if (c == 2) {
                     c = 1;
@@ -732,7 +814,7 @@ int dName_c::setDakuon(int param_1, u8 param_2) {
             break;
         }
         case 5: {
-            int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'ハ' : 'は';
+            int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('ハ', 0x836EU) : SJIS('は', 0x82CDU);
             c = (mChrInfo[param_2].mCharacter - c2) % 3;
             break;
         }
@@ -751,8 +833,8 @@ int dName_c::setDakuon(int param_1, u8 param_2) {
 
             return 1;
         }
-    } else if (param_1 == '゜') {
-        int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? 'ハ' : 'は';
+    } else if (param_1 == SJIS('゜', 0x814BU)) {
+        int c2 = mChrInfo[param_2].mMojiSet != MOJI_HIRA ? SJIS('ハ', 0x836EU) : SJIS('は', 0x82CDU);
         c = (mChrInfo[param_2].mCharacter - c2) % 3;
         if (c != 2) {
             mChrInfo[param_2].mCharacter = mChrInfo[param_2].mCharacter + (2 - c);
@@ -823,7 +905,7 @@ int dName_c::getMoji() {
     #if TARGET_PC
     if (dusk::version::isRegionJpn()) {
         if (*(u8*)moji >> 4 == 0x8 || *(u8*)moji >> 4 == 0x9) {
-            result = *(u16*)moji;
+            result = SJIS_MOJI(moji);
         } else {
             result = *moji;
         }
@@ -905,8 +987,8 @@ void dName_c::setNameText() {
         //"\x1bCD\x1bCR\x1bCC[000000]\x1bGM[0]%c\x1bHM\x1bCC[ffffff]\x1bGM[0]%c"
         //"\x1bCD\x1bCR\x1bCC[000000]\x1bGM[0]%c%c\x1bHM\x1bCC[ffffff]\x1bGM[0]%c%c"
         if (mChrInfo[i].field_0x3 != 0) {
-            #if REGION_JPN
-            if (mChrInfo[i].mMojiSet == 2) {
+            #if TARGET_PC || REGION_JPN
+            if (IF_DUSK(!dusk::version::isRegionJpn() ||) mChrInfo[i].mMojiSet == 2) {
             #endif
                 SAFE_SPRINTF(mNameText[i],
                         "\x1b"
@@ -917,7 +999,7 @@ void dName_c::setNameText() {
                         CHAR_TRUNC((u8)mChrInfo[i].mCharacter),
                         CHAR_TRUNC((u8)mChrInfo[i].mCharacter)
                 );
-            #if REGION_JPN
+            #if TARGET_PC || REGION_JPN
             } else {
                 SAFE_SPRINTF(mNameText[i],
                         "\x1b"
@@ -1005,10 +1087,8 @@ void dName_c::selectCursorMove() {
                                                                g_nmHIO.mSelCharScale);
     ((J2DTextBox*)mMojiIcon[mCharRow + mCharColumn * 5]->getPanePtr())
         ->setWhite(JUtility::TColor(0xC8, 0xC8, 0xC8, 0xFF));
-    
-    #if TARGET_PC
-    nameWide();
-    #endif
+
+    IF_DUSK(nameWide());
 
     Vec pos = mMojiIcon[mCharRow + mCharColumn * 5]->getGlobalVtxCenter(false, 0);
     mSelIcon->setPos(pos.x, pos.y, mMojiIcon[mCharRow + mCharColumn * 5]->getPanePtr(), true);
@@ -1429,30 +1509,50 @@ void dName_c::selectCursorPosSet(int row) {
 }
 
 #if TARGET_PC
+
+static dusk::utils::PaneCache l_tagName[] = {
+    {MULTI_CHAR('m_00_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_00_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_01_3'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m_01_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_02_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m03_0'), 0.0f, 0.0f, false},  {MULTI_CHAR('m03_1'), 0.0f, 0.0f, false},  {MULTI_CHAR('m03_2'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m03_3'), 0.0f, 0.0f, false},  {MULTI_CHAR('m03_4'), 0.0f, 0.0f, false},  {MULTI_CHAR('m_04_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_04_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_1'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m_05_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_05_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_06_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_0'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m_07_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_07_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_08_4'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m_09_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_09_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_10_3'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m_10_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_0'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_3'), 0.0f, 0.0f, false}, {MULTI_CHAR('m_11_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('m12_0'), 0.0f, 0.0f, false},  {MULTI_CHAR('m12_1'), 0.0f, 0.0f, false},  {MULTI_CHAR('m12_2'), 0.0f, 0.0f, false},
+    {MULTI_CHAR('m12_3'), 0.0f, 0.0f, false},  {MULTI_CHAR('m12_4'), 0.0f, 0.0f, false}, {MULTI_CHAR('p_end_2'), 0.0f, 0.0f, false}, {MULTI_CHAR('p_end_1'), 0.0f, 0.0f, false}, {MULTI_CHAR('p_end_0'), 0.0f, 0.0f, false},
+};
+
+static dusk::utils::PaneCache l_nameTagName[] = {
+    {MULTI_CHAR('name_00'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_01'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_02'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_03'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_04'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_05'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_06'), 0.0f, 0.0f, false}, {MULTI_CHAR('name_07'), 0.0f, 0.0f, false},
+};
+
+static dusk::utils::PaneCache l_nameCurTagName[] = {
+    {MULTI_CHAR('s__n_00'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_01'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_02'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_03'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_04'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_05'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_06'), 0.0f, 0.0f, false}, {MULTI_CHAR('s__n_07'), 0.0f, 0.0f, false},
+};
+
 void dName_c::nameWide() {
     static bool cachedPanes = false;
     // Get pre-scale values for each pane
     if (!cachedPanes) {
-        for (PaneCache& entry : l_tagName) {
+        for (dusk::utils::PaneCache& entry : l_tagName) {
             J2DPane* pane = nameIn.NameInScr->search(entry.tag);
             if (!entry.cached) {
-                entry.origTransX = pane->getTranslateX(); 
+                entry.origTransX = pane->getTranslateX();
                 entry.origTransY = pane->getTranslateY();
                 entry.cached = true;
             }
         }
-        for (PaneCache& entry : l_nameTagName) {
+        for (dusk::utils::PaneCache& entry : l_nameTagName) {
             J2DPane* pane = nameIn.NameInScr->search(entry.tag);
             if (!entry.cached) {
-                entry.origTransX = pane->getTranslateX(); 
+                entry.origTransX = pane->getTranslateX();
                 entry.origTransY = pane->getTranslateY();
                 entry.cached = true;
             }
         }
-        for (PaneCache& entry : l_nameCurTagName) {
+        for (dusk::utils::PaneCache& entry : l_nameCurTagName) {
             J2DPane* pane = nameIn.NameInScr->search(entry.tag);
             if (!entry.cached) {
-                entry.origTransX = pane->getTranslateX(); 
+                entry.origTransX = pane->getTranslateX();
                 entry.origTransY = pane->getTranslateY();
                 entry.cached = true;
             }
@@ -1463,19 +1563,19 @@ void dName_c::nameWide() {
     // Reset all panes
     nameIn.NameInScr->scale(1.0f, 1.0f);
     nameIn.NameInScr->translate(0.0f, 0.0f);
-    for (PaneCache& entry : l_tagName) {
+    for (dusk::utils::PaneCache& entry : l_tagName) {
         J2DPane* pane = nameIn.NameInScr->search(entry.tag);
         pane->setBasePosition(J2DBasePosition_4);
         pane->scale(1.0f, 1.0f);
         pane->translate(entry.origTransX, entry.origTransY);
     }
-    for (PaneCache& entry : l_nameTagName) {
+    for (dusk::utils::PaneCache& entry : l_nameTagName) {
         J2DPane* pane = nameIn.NameInScr->search(entry.tag);
         pane->setBasePosition(J2DBasePosition_4);
         pane->scale(1.0f, 1.0f);
         pane->translate(entry.origTransX, entry.origTransY);
     }
-    for (PaneCache& entry : l_nameCurTagName) {
+    for (dusk::utils::PaneCache& entry : l_nameCurTagName) {
         J2DPane* pane = nameIn.NameInScr->search(entry.tag);
         pane->setBasePosition(J2DBasePosition_4);
         pane->scale(1.0f, 1.0f);
@@ -1491,17 +1591,17 @@ void dName_c::nameWide() {
             break;
         default: // Wii and Dusklight
             // List of Characters Box
-            for (PaneCache& entry : l_tagName) {
+            for (dusk::utils::PaneCache& entry : l_tagName) {
                 J2DPane* pane = nameIn.NameInScr->search(entry.tag);
                 pane->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
             }
             // Letters being typed
-            for (PaneCache& entry : l_nameTagName) {
+            for (dusk::utils::PaneCache& entry : l_nameTagName) {
                 J2DPane* pane = nameIn.NameInScr->search(entry.tag);
                 pane->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
             }
             // Underscores when typing below letters
-            for (PaneCache& entry : l_nameCurTagName) {
+            for (dusk::utils::PaneCache& entry : l_nameCurTagName) {
                 J2DPane* pane = nameIn.NameInScr->search(entry.tag);
                 pane->scale(mDoGph_gInf_c::hudAspectScaleDown, 1.0f);
             }
@@ -1530,7 +1630,42 @@ void dName_c::screenSet() {
     static u64 l_cur1TagName[8] = {
         's_0r', MULTI_CHAR('s_01r'), MULTI_CHAR('s_02r'), MULTI_CHAR('s_03r'), MULTI_CHAR('s_04r'), MULTI_CHAR('s_05r'), MULTI_CHAR('s_06r'), MULTI_CHAR('s_07r'),
     };
-#if REGION_JPN
+
+#if TARGET_PC
+    static u64 l_menu_icon_tag_jpn[4] = {
+        MULTI_CHAR('j_hira_n'),
+        MULTI_CHAR('j_kata_n'),
+        MULTI_CHAR('j_eigo_n'),
+        MULTI_CHAR('j_end_n'),
+    };
+    static u64 l_menu_tag_jpn[5][3] = {
+        MULTI_CHAR('m_hira_0'),  MULTI_CHAR('m_hira_1'),  MULTI_CHAR('m_hira_s'),  MULTI_CHAR('m_kata_0'), MULTI_CHAR('m_kata_1'), MULTI_CHAR('m_kata_s'),
+        MULTI_CHAR('m_eigo_0'), MULTI_CHAR('m_eigo_1'), MULTI_CHAR('m_eigo_s'), MULTI_CHAR('j_end_0'), MULTI_CHAR('j_end_1'), MULTI_CHAR('j_end_s'),
+    };
+    static u32 l_menu_msg_jpn[4] = {
+        0x386,
+        0x387,
+        0x388,
+        0x38A,
+    };
+
+    static u64 l_menu_icon_tag[4] = {
+        MULTI_CHAR('p_ABC_n'),
+        MULTI_CHAR('p_abc_n'),
+        MULTI_CHAR('j_eigo_n'),
+        MULTI_CHAR('p_end_n'),
+    };
+    static u64 l_menu_tag[5][3] = {
+        MULTI_CHAR('p_ABC_0'),  MULTI_CHAR('p_ABC_1'),  MULTI_CHAR('p_ABC_2'),  MULTI_CHAR('p_abc_0'), MULTI_CHAR('p_abc_1'), MULTI_CHAR('p_abc_2'),
+        MULTI_CHAR('m_eigo_0'), MULTI_CHAR('m_eigo_1'), MULTI_CHAR('m_eigo_2'), MULTI_CHAR('p_end_0'), MULTI_CHAR('p_end_1'), MULTI_CHAR('p_end_2'),
+    };
+    static u32 l_menu_msg[4] = {
+        0x38B,
+        0x38C,
+        0x388,
+        0x38E,
+    };
+#elif REGION_JPN
     static u64 l_menu_icon_tag[4] = {
         MULTI_CHAR('j_hira_n'),
         MULTI_CHAR('j_kata_n'),
@@ -1612,7 +1747,26 @@ void dName_c::screenSet() {
         panes1[i]->setAnimation(mCursorColorKey);
     }
 
-    #if REGION_JPN
+    #if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        nameIn.NameInScr->search(MULTI_CHAR('pal_n'))->hide();
+        mMenuPane = nameIn.NameInScr->search(MULTI_CHAR('jpn_n'));
+        mMenuPane->show();
+
+        nameIn.NameInScr->search(MULTI_CHAR('p_ABC_n'))->scale(0.0f, 0.0f);
+        nameIn.NameInScr->search(MULTI_CHAR('p_abc_n'))->scale(0.0f, 0.0f);
+        nameIn.NameInScr->search(MULTI_CHAR('p_end_n'))->scale(0.0f, 0.0f);
+    } else {
+        nameIn.NameInScr->search(MULTI_CHAR('jpn_n'))->hide();
+        mMenuPane = nameIn.NameInScr->search(MULTI_CHAR('pal_n'));
+        mMenuPane->show();
+
+        nameIn.NameInScr->search(MULTI_CHAR('j_hira_n'))->scale(0.0f, 0.0f);
+        nameIn.NameInScr->search(MULTI_CHAR('j_kata_n'))->scale(0.0f, 0.0f);
+        nameIn.NameInScr->search(MULTI_CHAR('j_eigo_n'))->scale(0.0f, 0.0f);
+        nameIn.NameInScr->search(MULTI_CHAR('j_end_n'))->scale(0.0f, 0.0f);
+    }
+    #elif REGION_JPN
     nameIn.NameInScr->search(MULTI_CHAR('pal_n'))->hide();
     mMenuPane = nameIn.NameInScr->search(MULTI_CHAR('jpn_n'));
     mMenuPane->show();
@@ -1633,19 +1787,31 @@ void dName_c::screenSet() {
 
     J2DTextBox* menuPane[3];
     for (int i = 0; i < 4; i++) {
-        #if !REGION_JPN
-        if (i == 2) {
+        #if TARGET_PC || !REGION_JPN
+        if (IF_DUSK(!dusk::version::isRegionJpn() &&) i == 2) {
             mMenuIcon[i] = NULL;
             mMenuText[i] = NULL;
         } else {
         #endif
+            #if TARGET_PC
+            mMenuIcon[i] = JKR_NEW CPaneMgr(nameIn.NameInScr, dusk::version::isRegionJpn() ? l_menu_icon_tag_jpn[i] : l_menu_icon_tag[i], 1, NULL);
+            #else
             mMenuIcon[i] = JKR_NEW CPaneMgr(nameIn.NameInScr, l_menu_icon_tag[i], 1, NULL);
+            #endif
 
             char buf[16];
+            #if TARGET_PC
+            fopMsgM_messageGet(buf, dusk::version::isRegionJpn() ? l_menu_msg_jpn[i] : l_menu_msg[i]);
+            #else
             fopMsgM_messageGet(buf, l_menu_msg[i]);
+            #endif
 
             for (int j = 0; j < 3; j++) {
+                #if TARGET_PC
+                menuPane[j] = (J2DTextBox*)nameIn.NameInScr->search(dusk::version::isRegionJpn() ? l_menu_tag_jpn[i][j] : l_menu_tag[i][j]);
+                #else
                 menuPane[j] = (J2DTextBox*)nameIn.NameInScr->search(l_menu_tag[i][j]);
+                #endif
 
                 if (j == 0) {
                     mMenuText[i] = menuPane[j];
@@ -1654,7 +1820,7 @@ void dName_c::screenSet() {
                 menuPane[j]->setFont(nameIn.font);
                 menuPane[j]->setString(buf);
             }
-        #if !REGION_JPN
+        #if TARGET_PC || !REGION_JPN
         }
         #endif
     }
@@ -1795,20 +1961,20 @@ void dName_c::NameStrSet() {
             i++;
         } else {
             if (*(u8*)moji >> 4 == 8 || *(u8*)moji >> 4 == 9) {
-                mChrInfo[i].mCharacter = *(u16*)moji;
+                mChrInfo[i].mCharacter = SJIS_MOJI(moji);
 
                 for (int j = 0; j < 65; j++) {
-                    if (mChrInfo[i].mCharacter == *(u16*)l_mojiHira[j] ||
-                        mChrInfo[i].mCharacter == *(u16*)l_mojiHira2[j] ||
-                        mChrInfo[i].mCharacter == *(u16*)l_mojiHira3[j])
+                    if (mChrInfo[i].mCharacter == SJIS_MOJI(l_mojiHira[j]) ||
+                        mChrInfo[i].mCharacter == SJIS_MOJI(l_mojiHira2[j]) ||
+                        mChrInfo[i].mCharacter == SJIS_MOJI(l_mojiHira3[j]))
                     {
                         mChrInfo[i].mColumn = j / 5;
                         mChrInfo[i].mRow = j % 5;
                         mChrInfo[i].mMojiSet = MOJI_HIRA;
                         break;
-                    } else if (mChrInfo[i].mCharacter == *(u16*)l_mojikata[j] ||
-                               mChrInfo[i].mCharacter == *(u16*)l_mojikata2[j] ||
-                               mChrInfo[i].mCharacter == *(u16*)l_mojikata3[j])
+                    } else if (mChrInfo[i].mCharacter == SJIS_MOJI(l_mojikata[j]) ||
+                               mChrInfo[i].mCharacter == SJIS_MOJI(l_mojikata2[j]) ||
+                               mChrInfo[i].mCharacter == SJIS_MOJI(l_mojikata3[j]))
                     {
                         mChrInfo[i].mColumn = j / 5;
                         mChrInfo[i].mRow = j % 5;
diff --git a/src/d/d_particle.cpp b/src/d/d_particle.cpp
index c3f4e9067f..d1e175dfc1 100644
--- a/src/d/d_particle.cpp
+++ b/src/d/d_particle.cpp
@@ -8,26 +8,27 @@
 // weak data from it (unlike here).
 
 #include "d/d_particle.h"
-#include <cstdio>
-#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
-#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "d/d_jnt_col.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
-#include "JSystem/JMath/JMATrigonometric.h"
+#include "JSystem/J3DGraphBase/J3DMaterial.h"
+#include "JSystem/J3DGraphAnimator/J3DMaterialAnm.h"
 #include "JSystem/JParticle/JPAEmitterManager.h"
 #include "JSystem/JParticle/JPAResourceManager.h"
-#include "SSystem/SComponent/c_math.h"
-#include "d/actor/d_a_player.h"
-#include "d/d_com_inf_game.h"
-#include "d/d_jnt_col.h"
+#include "JSystem/JMath/JMATrigonometric.h"
 #include "d/d_s_play.h"
-#include "f_op/f_op_actor_mng.h"
-#include "m_Do/m_Do_graphic.h"
+#include <cstdio>
+#include "d/d_com_inf_game.h"
 #include "m_Do/m_Do_lib.h"
-#include "tracy/Tracy.hpp"
+#include "m_Do/m_Do_graphic.h"
+#include "f_op/f_op_actor_mng.h"
+#include "d/actor/d_a_player.h"
+#include "SSystem/SComponent/c_math.h"
 
-#ifndef __MWERKS__
-#include "dusk/math.h"
+#if TARGET_PC
+#include "dusk/game_clock.h"
+
+#include <tracy/Tracy.hpp>
 #endif
 
 #if DEBUG
@@ -35,7 +36,7 @@
 #endif
 
 extern "C" {
-    extern dPa_particleTracePcallBack_c JPTracePCB4;
+    DUSK_GAME_EXTERN dPa_particleTracePcallBack_c JPTracePCB4;
 }
 
 void dPa_cleanupGX() {
@@ -125,11 +126,11 @@ u32 dummy(JPABaseEmitter* i_emitter) {
     return i_emitter->getAge();
 }
 
-dPa_modelEcallBack dPa_modelEcallBack::mEcallback;
+DUSK_GAME_DATA dPa_modelEcallBack dPa_modelEcallBack::mEcallback;
 
-dPa_modelPcallBack dPa_modelEcallBack::mPcallback;
+DUSK_GAME_DATA dPa_modelPcallBack dPa_modelEcallBack::mPcallback;
 
-dPa_modelEcallBack::model_c* dPa_modelEcallBack::mModel;
+DUSK_GAME_DATA dPa_modelEcallBack::model_c* dPa_modelEcallBack::mModel;
 
 #if DEBUG
 u8 dPa_modelEcallBack::mNum;
@@ -1120,7 +1121,7 @@ void dPa_control_c::level_c::cutTable(dPa_control_c::level_c::emitter_c* i_emitt
     i_emitter->cleanup();
 }
 
-dPa_selectTexEcallBack dPa_control_c::mTsubo[] = {
+DUSK_GAME_DATA dPa_selectTexEcallBack dPa_control_c::mTsubo[] = {
     dPa_selectTexEcallBack(0),
     dPa_selectTexEcallBack(1),
     dPa_selectTexEcallBack(2),
@@ -1137,35 +1138,35 @@ static GXColor l_lifeBallColor[3] = {
     {0xEB, 0xD7, 0x2F, 0xFF},
 };
 
-dPa_setColorEcallBack dPa_control_c::mLifeBall[3] = {
+DUSK_GAME_DATA dPa_setColorEcallBack dPa_control_c::mLifeBall[3] = {
     dPa_setColorEcallBack(l_lifeBallColor[0]),
     dPa_setColorEcallBack(l_lifeBallColor[1]),
     dPa_setColorEcallBack(l_lifeBallColor[2]),
 };
 
-JPAEmitterManager* dPa_control_c::mEmitterMng;
+DUSK_GAME_DATA JPAEmitterManager* dPa_control_c::mEmitterMng;
 
-dPa_wbPcallBack_c dPa_control_c::mWaterBubblePcallBack;
+DUSK_GAME_DATA dPa_wbPcallBack_c dPa_control_c::mWaterBubblePcallBack;
 
-dPa_fsenthPcallBack dPa_control_c::mFsenthPcallBack;
+DUSK_GAME_DATA dPa_fsenthPcallBack dPa_control_c::mFsenthPcallBack;
 
-dPa_light8EcallBack dPa_control_c::mLight8EcallBack;
+DUSK_GAME_DATA dPa_light8EcallBack dPa_control_c::mLight8EcallBack;
 
-dPa_light8PcallBack dPa_control_c::mLight8PcallBack;
+DUSK_GAME_DATA dPa_light8PcallBack dPa_control_c::mLight8PcallBack;
 
-dPa_gen_b_light8EcallBack dPa_control_c::m_b_Light8EcallBack;
+DUSK_GAME_DATA dPa_gen_b_light8EcallBack dPa_control_c::m_b_Light8EcallBack;
 
-dPa_gen_b_light8PcallBack dPa_control_c::m_b_Light8PcallBack;
+DUSK_GAME_DATA dPa_gen_b_light8PcallBack dPa_control_c::m_b_Light8PcallBack;
 
-dPa_gen_d_light8EcallBack dPa_control_c::m_d_Light8EcallBack;
+DUSK_GAME_DATA dPa_gen_d_light8EcallBack dPa_control_c::m_d_Light8EcallBack;
 
-dPa_gen_d_light8PcallBack dPa_control_c::m_d_Light8PcallBack;
+DUSK_GAME_DATA dPa_gen_d_light8PcallBack dPa_control_c::m_d_Light8PcallBack;
 
-u8 dPa_control_c::mStatus;
+DUSK_GAME_DATA u8 dPa_control_c::mStatus;
 
-Mtx dPa_control_c::mWindViewMatrix;
+DUSK_GAME_DATA Mtx dPa_control_c::mWindViewMatrix;
 
-dPa_particleTracePcallBack_c dPa_control_c::mParticleTracePCB;
+DUSK_GAME_DATA dPa_particleTracePcallBack_c dPa_control_c::mParticleTracePCB;
 
 dPa_control_c::dPa_control_c() {
 #if DEBUG
@@ -1975,7 +1976,7 @@ void dPa_light8PcallBack::draw(JPABaseEmitter* param_1, JPABaseParticle* param_2
     JGeometry::TVec3<f32> local_160;
     JGeometry::TVec3<f32> local_16c;
 #if TARGET_PC
-    if (dusk::frame_interp::is_sim_frame())
+    if (dusk::game_clock::is_sim_frame())
 #endif
     {
         dPa_setWindPower(param_2);
diff --git a/src/d/d_particle_copoly.cpp b/src/d/d_particle_copoly.cpp
index f14e90e488..a6ce6e573e 100644
--- a/src/d/d_particle_copoly.cpp
+++ b/src/d/d_particle_copoly.cpp
@@ -214,24 +214,24 @@ void dPaPoF_c::clearFourAllID() {
     clearTwoAllID();
 }
 
-const dPaPoT_c::effTypeFunc dPaPoT_c::m_typeTwoData[] = {
+DUSK_GAME_DATA const dPaPoT_c::effTypeFunc dPaPoT_c::m_typeTwoData[] = {
     &dPaPoT_c::getCenterEffType,
     &dPaPoT_c::getLeftEffType,
     &dPaPoT_c::getRightEffType,
 };
 
-const dPaPoT_c::emitterFunc dPaPoT_c::m_emitterTwoData[] = {
+DUSK_GAME_DATA const dPaPoT_c::emitterFunc dPaPoT_c::m_emitterTwoData[] = {
     &dPaPoT_c::getCenterEmitter,
     &dPaPoT_c::getLeftEmitter,
     &dPaPoT_c::getRightEmitter,
 };
 
-const dPaPoF_c::effTypeFunc dPaPoF_c::m_typeFourData[] = {
+DUSK_GAME_DATA const dPaPoF_c::effTypeFunc dPaPoF_c::m_typeFourData[] = {
     &dPaPoF_c::getCenterEffType,   &dPaPoF_c::getLeftEffType,      &dPaPoF_c::getRightEffType,
     &dPaPoF_c::getBackLeftEffType, &dPaPoF_c::getBackRightEffType,
 };
 
-const  dPaPoF_c::emitterFunc dPaPoF_c::m_emitterFourData[] = {
+DUSK_GAME_DATA const  dPaPoF_c::emitterFunc dPaPoF_c::m_emitterFourData[] = {
     &dPaPoF_c::getCenterEmitter,   &dPaPoF_c::getLeftEmitter,      &dPaPoF_c::getRightEmitter,
     &dPaPoF_c::getBackLeftEmitter, &dPaPoF_c::getBackRightEmitter,
 };
diff --git a/src/d/d_particle_name.cpp b/src/d/d_particle_name.cpp
index 68f4dd8d3a..b9a3cd9ea0 100644
--- a/src/d/d_particle_name.cpp
+++ b/src/d/d_particle_name.cpp
@@ -2,7 +2,7 @@
 
 #include "d/d_particle_name.h"
 
-u16 dPa_name::j_o_id[5] = {
+DUSK_GAME_DATA u16 dPa_name::j_o_id[5] = {
     ID_ZI_J_O_DIGTGA_A,
     ID_ZI_J_O_DIGTGA_B,
     ID_ZI_J_O_FIRE_A,
@@ -10,7 +10,7 @@ u16 dPa_name::j_o_id[5] = {
     ID_ZI_J_O_KAGEROU,
 };
 
-u16 dPa_name::s_o_id[14] = {
+DUSK_GAME_DATA u16 dPa_name::s_o_id[14] = {
     dPa_RM(ID_ZI_S_O_FIRE2_A),
     dPa_RM(ID_ZI_S_O_FIRE2_B),
     dPa_RM(ID_ZI_S_O_KAGEROU2),
@@ -35,7 +35,7 @@ DUSK_CONST char* dPa_name::getName(u32 i_id) {
     return jpaName[i_id];
 }
 
-DUSK_CONST char* dPa_name::jpaName[] = {
+DUSK_GAME_DATA DUSK_CONST char* dPa_name::jpaName[] = {
     "AK_JN_M_breakFaceRock00.jpa",
     "AK_JN_M_breakGreatRock00.jpa",
     "AK_JN_M_breakLittleRock00.jpa",
diff --git a/src/d/d_resorce.cpp b/src/d/d_resorce.cpp
index bb982c4afb..26295158f4 100644
--- a/src/d/d_resorce.cpp
+++ b/src/d/d_resorce.cpp
@@ -95,13 +95,28 @@ static void setIndirectTex(J3DModelData* i_modelData) {
 
     for (u16 i = 0; i < texture->getNum(); i++) {
         textureName = nameTab->getName(i);
+#if TARGET_PC
+        if (textureName == NULL) {
+            continue;
+        }
+        if (strcmp(textureName, "fbtex_dummy") == 0) {
+#else
         if (memcmp(textureName, "fbtex_dummy", 0xc) == 0) {
+#endif
             texture->setResTIMG(i, *mDoGph_gInf_c::getFrameBufferTimg());
         }
+#if TARGET_PC
+        if (strcmp(textureName, "dummy") == 0) {
+#else
         if (memcmp(textureName, "dummy", 6) == 0) {
+#endif
             texture->setResTIMG(i, *mDoGph_gInf_c::getFrameBufferTimg());
         }
+#if TARGET_PC
+        if (strcmp(textureName, "Zbuffer") == 0) {
+#else
         if (memcmp(textureName, "Zbuffer", 8) == 0) {
+#endif
             texture->setResTIMG(i, *mDoGph_gInf_c::getZbufferTimg());
         }
     }
@@ -335,7 +350,7 @@ int dRes_info_c::loadResource() {
 #endif
                 void* res = mArchive->getIdxResource(fileIndex);
 #if TARGET_PC
-                u32 size = mArchive->findIdxResource(fileIndex)->data_size;
+                u32 size = mArchive->getFileSize(mArchive->findIdxResource(fileIndex));
                 std::string fileName = mArchive->mStringTable +
                         (mArchive->findIdxResource(fileIndex)->type_flags_and_name_offset & 0xFFFFFF);
                 DuskLog.debug("Loading Resource: {} (Size: {})", fileName, size);
@@ -369,7 +384,7 @@ int dRes_info_c::loadResource() {
                         parentHeap = NULL;
                     }
 
-                    int rt = dComIfG_setObjectRes(arcName, res, entry->data_size, parentHeap);
+                    int rt = dComIfG_setObjectRes(arcName, res, DUSK_IF_ELSE(mArchive->getFileSize(entry),entry->data_size), parentHeap);
                     JUT_ASSERT(788, rt);
                 } else if (nodeType == 'BMDP') {
 #if DEBUG
@@ -581,7 +596,7 @@ int dRes_info_c::setRes(JKRArchive* i_archive, JKRHeap* i_heap) {
     return rt >> 0x1F;
 }
 
-bool data_8074C6C0_debug;
+DUSK_GAME_DATA bool data_8074C6C0_debug;
 
 int dRes_info_c::setRes() {
     if (mArchive == NULL) {
diff --git a/src/d/d_s_logo.cpp b/src/d/d_s_logo.cpp
index 570dfac577..48c7519ded 100644
--- a/src/d/d_s_logo.cpp
+++ b/src/d/d_s_logo.cpp
@@ -23,8 +23,15 @@
 #include "m_Do/m_Do_main.h"
 #include "JSystem/JUtility/JUTConsole.h"
 
+#ifdef TARGET_PC
+#include "dusk/game_mode.hpp"
+#include "dusk/language.hpp"
 #include "dusk/logging.h"
+#include "dusk/main.h"
+#include "dusk/mods/svc/save.hpp"
 #include "dusk/version.hpp"
+#include "m_Do/m_Do_MemCard.h"
+#endif
 
 #if !PLATFORM_GCN
 #include <revolution/os.h>
@@ -48,8 +55,8 @@ struct homeBtnData {
 #if TARGET_PC
 using namespace dusk::version;
 
-#define LOGO_ARC versionSelect<const char*>({{GameVersion::GcnJpn, "Logo"}, {GameVersion::GcnPal, "LogoPal"}}, "LogoUs")
-#define MSG_PATH versionSelect<const char*>({{GameVersion::GcnJpn, "/res/Msgjp/bmgres.arc"}}, "/res/Msgus/bmgres.arc")
+#define LOGO_ARC regionSelect<const char*>("LogoUs", "LogoPal", "Logo")
+#define MSG_PATH regionSelect<const char*>("/res/Msgus/bmgres.arc", "/res/Msgus/bmgres.arc", "/res/Msgjp/bmgres.arc")
 #elif VERSION == VERSION_SHIELD
 #define LOGO_ARC "LogoUs"
 #define MSG_PATH  "/res/Msgcn/bmgres.arc"
@@ -72,7 +79,20 @@ using namespace dusk::version;
 #define PROGRESSIVE_MODE_ON  OS_PROGRESSIVE_MODE_ON
 #endif
 
-#if PLATFORM_WII || VERSION == VERSION_SHIELD_DEBUG
+// TODO: Probably shouldn't actually load LayoutRevo, so I disabled it for now
+#if TARGET_PC && 0
+using namespace dusk::version;
+
+#define FMAP_RES_PATH platformSelect("/res/Layout/fmapres.arc", "/res/LayoutRevo/fmapresR.arc")
+#define DMAP_RES_PATH platformSelect("/res/Layout/dmapres.arc", "/res/LayoutRevo/dmapresR.arc")
+#define COLLECT_RES_PATH platformSelect("/res/Layout/clctres.arc", "/res/LayoutRevo/clctresR.arc")
+
+#define MSG_COM_PATH platformSelect("/res/Layout/msgcom.arc", "/res/LayoutRevo/msgcomR.arc")
+#define MSG_RES0_PATH platformSelect("/res/Layout/msgres00.arc", "/res/LayoutRevo/msgres00R.arc")
+#define MSG_RES1_PATH platformSelect("/res/Layout/msgres01.arc", "/res/LayoutRevo/msgres01R.arc")
+#define MSG_RES2_PATH platformSelect("/res/Layout/msgres02.arc", "/res/LayoutRevo/msgres02R.arc")
+#define MSG_RES3_PATH platformSelect("/res/Layout/msgres03.arc", "/res/LayoutRevo/msgres03R.arc")
+#elif PLATFORM_WII || VERSION == VERSION_SHIELD_DEBUG
 #define FMAP_RES_PATH "/res/LayoutRevo/fmapresR.arc"
 #define DMAP_RES_PATH "/res/LayoutRevo/dmapresR.arc"
 #define COLLECT_RES_PATH "/res/LayoutRevo/clctresR.arc"
@@ -94,7 +114,10 @@ using namespace dusk::version;
 #define MSG_RES3_PATH "/res/Layout/msgres03.arc"
 #endif
 
-#if PLATFORM_WII || PLATFORM_SHIELD
+#if TARGET_PC
+#define ICON_RES_PATH "/res/CardIcon/cardicon.arc"
+#define PARTICLE_COM_PATH platformSelect<const char*>("/res/Particle/common.jpc", "/res/Particle/common-r.jpc")
+#elif PLATFORM_WII || PLATFORM_SHIELD
 #define ICON_RES_PATH "/res/WiiBannerIcon/bannerIcon.arc"
 #define PARTICLE_COM_PATH "/res/Particle/common-r.jpc"
 #else
@@ -102,7 +125,13 @@ using namespace dusk::version;
 #define PARTICLE_COM_PATH "/res/Particle/common.jpc"
 #endif
 
-#if PLATFORM_WII
+// TODO: Probably shouldn't actually load LayoutRevo, so I disabled it for now
+#if TARGET_PC && 0
+#define RING_RES_PATH platformSelect("/res/Layout/ringres.arc", "/res/LayoutRevo/ringresR.arc")
+#define ITEM_INF_RES_PATH platformSelect("/res/Layout/itmInfRes.arc", "/res/LayoutRevo/itmInfResR.arc")
+#define BUTTON_RES_PATH platformSelect("/res/Layout/button.arc", "/res/LayoutRevo/buttonR.arc")
+#define MAIN2D_PATH platformSelect("/res/Layout/main2D.arc", "/res/LayoutRevo/main2DR.arc")
+#elif PLATFORM_WII
 #define RING_RES_PATH "/res/LayoutRevo/ringresR.arc"
 #define ITEM_INF_RES_PATH "/res/LayoutRevo/itmInfResR.arc"
 #define BUTTON_RES_PATH "/res/LayoutRevo/buttonR.arc"
@@ -757,7 +786,73 @@ void dScnLogo_c::nextSceneChange() {
     if (!mDoRst::isReset()) {
         if (!isOpeningCut())
         {
-            dComIfG_changeOpeningScene(this, fpcNm_OPENING_SCENE_e);
+#ifdef TARGET_PC
+            // If we are requesting a save from the command line, load it here and set the scene to play instead of loading the LOGO SCENE
+            if (dusk::SaveRequested >= 1 && dusk::SaveRequested <= 3) {
+                u8 buf[SAVEDATA_SIZE * 3];
+                mDoMemCd_Load();
+                uint8_t status;
+                do {
+                    status = mDoMemCd_LoadSync(buf, sizeof(buf), 0);
+                    // Wait until the card is loaded
+                } while (status == 0);
+
+                const uint32_t saveSlot = dusk::SaveRequested - 1;
+                if (status == 1) {
+                    dComIfGs_setCardToMemory(buf, saveSlot);
+                } else {
+                    dComIfGs_init();
+                }
+
+                dComIfGs_setNoFile(dusk::SaveRequested);
+                dComIfGs_setDataNum(saveSlot);
+                if (status == 1) {
+                    dusk::mods::svc::save_slot_loaded(
+                        saveSlot, buf + saveSlot * SAVEDATA_SIZE);
+                    const dusk::gamemode::GameMode* gameMode =
+                        dusk::gamemode::getGameModeManager().getCurrentGameMode();
+                    if (gameMode) {
+                        gameMode->invokeOnSaveLoadedFunction();
+                    }
+                }
+
+                dComIfGs_gameStart();
+            
+                fopScnM_ChangeReq(this, fpcNm_PLAY_SCENE_e, 0, 30);
+            
+                dKy_clear_game_init();
+                dComIfGs_resetDan();
+                dComIfGs_setRestartRoomParam(0);
+            
+                DuskLog.info("Loaded Save From Slot {}",dusk::SaveRequested);
+                dusk::SaveRequested = 0xff;
+            } else if (dusk::SaveRequested == 0xff) {
+                // This indicates that the save has loaded, but we are waiting for the scene
+                // manager to change to play
+            } else if (dusk::StageRequested.set) {
+                // Do nothing if we need to request a stage to load later in the function
+            } else{
+#endif
+                dComIfG_changeOpeningScene(this, fpcNm_OPENING_SCENE_e);
+#ifdef TARGET_PC
+            }
+
+            if (dusk::StageRequested.set) {
+                // If we aren't loading a save, initialize a blank save file and request the correct scene to load
+                if (dusk::SaveRequested == 0) {
+                    dComIfGs_init();
+
+                    fopScnM_ChangeReq(this, fpcNm_PLAY_SCENE_e, 0, 30);
+                    dusk::SaveRequested = 0xff; //Skip requesting the scene from above
+                }
+
+                // Use both to force-set start stage
+                dComIfGp_setNextStage(dusk::StageRequested.stage.c_str(), dusk::StageRequested.point, dusk::StageRequested.room, dusk::StageRequested.layer);
+                g_dComIfG_gameInfo.play.mNextStage.getStartStage()->set(dusk::StageRequested.stage.c_str(), dusk::StageRequested.room, dusk::StageRequested.point, dusk::StageRequested.layer);
+
+                dusk::StageRequested.set = false; // Setting the stage should only happen once
+            }
+#endif
         } else {
             #if DEBUG
             fopScnM_ChangeReq(this, fpcNm_MENU_SCENE_e, 0, 30);
@@ -796,7 +891,7 @@ dScnLogo_c::~dScnLogo_c() {
     JKR_DELETE(mProgressiveSel);
 
     #if TARGET_PC
-    if (getGameVersion() == GameVersion::GcnPal) {
+    if (isRegionPal()) {
         mpPalLogoResCommand->getArchive()->removeResourceAll();
         mpPalLogoResCommand->getArchive()->unmount();
         mpPalLogoResCommand->destroy();
@@ -907,7 +1002,14 @@ dScnLogo_c::~dScnLogo_c() {
     mDoExt_getRubyFont();
     mDoExt_setAraCacheSize(free_size - aram_heap->getTotalFreeSize());
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+    if (isRegionJpn()) {
+        if (dComIfGp_getFontArchive() != NULL) {
+            dComIfGp_getFontArchive()->unmount();
+            dComIfGp_setFontArchive(NULL);
+        }
+    }
+#elif VERSION == VERSION_GCN_JPN
     if (dComIfGp_getFontArchive() != NULL) {
         dComIfGp_getFontArchive()->unmount();
         dComIfGp_setFontArchive(NULL);
@@ -964,7 +1066,7 @@ static int phase_0(dScnLogo_c* i_this) {
     JKRHEAP_NAME(i_this->mLogo01Heap, "Logo01");
 
     #if TARGET_PC || VERSION == VERSION_GCN_PAL
-    IF_DUSK_BLOCK(getGameVersion() == GameVersion::GcnPal)
+    IF_DUSK_BLOCK(isRegionPal())
     switch (i_this->getPalLanguage()) {
     case 1:
         i_this->mpPalLogoResCommand = mDoDvdThd_mountArchive_c::create("/res/Layout/LogoPalGm.arc", 0, NULL);
@@ -1005,7 +1107,7 @@ static int phase_1(dScnLogo_c* i_this) {
     #endif
 
     #if TARGET_PC || VERSION == VERSION_GCN_PAL
-    IF_DUSK_BLOCK(getGameVersion() == GameVersion::GcnPal)
+    IF_DUSK_BLOCK(isRegionPal())
     if (!mDoDvdThd::SyncWidthSound) {
         return cPhs_INIT_e;
     }
@@ -1240,7 +1342,7 @@ void dScnLogo_c::logoInitGC() {
     mDolbyLogo = JKR_NEW dDlst_2D_c(dolbyImg, 189, 150, 232, 112, 255);
 
 #if TARGET_PC
-    if (getGameVersion() == GameVersion::GcnPal) {
+    if (isRegionPal()) {
         u8 language = getPalLanguage();
         if (language >= 5) {
             language = 0;
@@ -1503,30 +1605,15 @@ void dScnLogo_c::dvdDataLoad() {
     mpButtonCommand = aramMount(BUTTON_RES_PATH, mDoExt_getJ2dHeap());
     mpCardIconCommand = aramMount(ICON_RES_PATH, mDoExt_getJ2dHeap());
 
-    #if TARGET_PC
-    if (getGameVersion() == GameVersion::GcnPal) {
-        switch (getPalLanguage()) {
-        case 1:
-            mpBmgResCommand = onMemMount("/res/Msgde/bmgres.arc");
-            break;
-        case 2:
-            mpBmgResCommand = onMemMount("/res/Msgfr/bmgres.arc");
-            break;
-        case 3:
-            mpBmgResCommand = onMemMount("/res/Msgsp/bmgres.arc");
-            break;
-        case 4:
-            mpBmgResCommand = onMemMount("/res/Msgit/bmgres.arc");
-            break;
-        case 0:
-        default:
-            mpBmgResCommand = onMemMount("/res/Msguk/bmgres.arc");
-            break;
-        }
-    } else {
-        mpBmgResCommand = onMemMount(MSG_PATH);
-    }
-    #elif VERSION == VERSION_GCN_PAL
+#if TARGET_PC
+#if AVOID_UB
+    static char bmgPath[32];
+#else
+    static char bmgPath[22];
+#endif
+    snprintf(bmgPath, sizeof(bmgPath), "/res/%s/bmgres.arc", dusk::language::msg_folder());
+    mpBmgResCommand = onMemMount(bmgPath);
+#elif VERSION == VERSION_GCN_PAL
     switch (getPalLanguage()) {
     case 1:
         mpBmgResCommand = onMemMount("/res/Msgde/bmgres.arc");
@@ -1545,7 +1632,7 @@ void dScnLogo_c::dvdDataLoad() {
         mpBmgResCommand = onMemMount("/res/Msguk/bmgres.arc");
         break;
     }
-    #elif VERSION == VERSION_SHIELD_DEBUG
+#elif VERSION == VERSION_SHIELD_DEBUG
     switch (getPalLanguage()) {
     case 2:
         mpBmgResCommand = onMemMount("/res/Msgfr/bmgres.arc");
@@ -1557,9 +1644,9 @@ void dScnLogo_c::dvdDataLoad() {
         mpBmgResCommand = onMemMount("/res/Msgus/bmgres.arc");
         break;
     }
-    #else
+#else
     mpBmgResCommand = onMemMount(MSG_PATH);
-    #endif
+#endif
 
     mpMsgComCommand = aramMount(MSG_COM_PATH, mDoExt_getJ2dHeap());
     mpMsgResCommand[0] = aramMount(MSG_RES0_PATH, mDoExt_getJ2dHeap());
@@ -1567,8 +1654,10 @@ void dScnLogo_c::dvdDataLoad() {
     mpMsgResCommand[2] = aramMount(MSG_RES2_PATH, mDoExt_getJ2dHeap());
     mpMsgResCommand[3] = aramMount(MSG_RES3_PATH, mDoExt_getJ2dHeap());
 #if TARGET_PC
-    const auto res4Path = versionSelect<const char*>({{GameVersion::GcnJpn, "/res/Layout/msgres04.arc"}}, "/res/Layout/msgres04F.arc");
-    mpMsgResCommand[4] = aramMount( res4Path, mDoExt_getJ2dHeap());
+    const auto res4Path = regionSelect<const char*>("/res/Layout/msgres04F.arc",
+                                                    "/res/Layout/msgres04F.arc",
+                                                    "/res/Layout/msgres04.arc");
+    mpMsgResCommand[4] = aramMount(res4Path, mDoExt_getJ2dHeap());
 #elif VERSION == VERSION_GCN_JPN
     mpMsgResCommand[4] = aramMount("/res/Layout/msgres04.arc", mDoExt_getJ2dHeap());
 #else
@@ -1580,16 +1669,12 @@ void dScnLogo_c::dvdDataLoad() {
     mpMain2DCommand = onMemMount(MAIN2D_PATH);
 
 #if TARGET_PC
-    const auto fontResPath = versionSelect<const char*>(
-        {
-            {GameVersion::GcnJpn, "/res/Fontjp/fontres.arc"},
-            {GameVersion::GcnPal, "/res/Fonteu/fontres.arc"},
-        }, "/res/Fontus/fontres.arc");
-    const auto fontRubyPath = versionSelect<const char*>(
-        {
-            {GameVersion::GcnJpn, "/res/Fontjp/rubyres.arc"},
-            {GameVersion::GcnPal, "/res/Fonteu/rubyres.arc"},
-        }, "/res/Fontus/rubyres.arc");
+    const auto fontResPath = regionSelect<const char*>("/res/Fontus/fontres.arc",
+                                                       "/res/Fonteu/fontres.arc",
+                                                       "/res/Fontjp/fontres.arc");
+    const auto fontRubyPath = regionSelect<const char*>("/res/Fontus/rubyres.arc",
+                                                        "/res/Fonteu/rubyres.arc",
+                                                        "/res/Fontjp/rubyres.arc");
 
     // Note: GCN_JPN mounts this archive as tail instead of head.
     // I'm guessing this is fine since we have more RAM.
diff --git a/src/d/d_s_name.cpp b/src/d/d_s_name.cpp
index d0e33adce4..7faabde76b 100644
--- a/src/d/d_s_name.cpp
+++ b/src/d/d_s_name.cpp
@@ -5,25 +5,25 @@
 
 #include "d/dolzel.h" // IWYU pragma: keep
 
+#include "d/d_s_name.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "d/d_com_inf_game.h"
 #include "d/d_meter2_info.h"
-#include "d/d_s_name.h"
-#include "dusk/imgui/ImGuiConsole.hpp"
-#include "dusk/livesplit.h"
-#include "dusk/memory.h"
-#include "dusk/speedrun.h"
-#include "dusk/settings.h"
-#include "f_op/f_op_overlap_mng.h"
 #include "f_op/f_op_scene_mng.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_graphic.h"
 #include "m_Do/m_Do_machine.h"
-#include "m_Do/m_Do_main.h"
 #include "m_Do/m_Do_mtx.h"
-#include <dusk/autosave.h>
+#include "m_Do/m_Do_main.h"
+#include "f_op/f_op_overlap_mng.h"
 
 #if TARGET_PC
+#include "dusk/autosave.h"
+#include "dusk/game_mode.hpp"
+#include "dusk/imgui/ImGuiConsole.hpp"
+#include "dusk/memory.h"
+#include "dusk/settings.h"
+
 #define SHOW_TV_SETTINGS_SCREEN (this->mShowTvSettingsScreen)
 #else
 #define SHOW_TV_SETTINGS_SCREEN (1)
@@ -418,15 +418,6 @@ void dScnName_c::changeGameScene() {
         dComIfGs_setRestartRoomParam(0);
 
 #if TARGET_PC
-        if (dusk::getSettings().game.speedrunMode && dusk::getSettings().game.hideTvSettingsScreen) {
-            // start a new run on file load if a run isn't already in progress
-            if (!dusk::m_speedrunInfo.m_isRunStarted) {
-                dusk::resetForSpeedrunMode();
-                dusk::m_speedrunInfo.startRun();
-                dusk::speedrun::start();
-            }
-        }
-
         toggleAutoSave(true);
 #endif
     }
diff --git a/src/d/d_s_play.cpp b/src/d/d_s_play.cpp
index 0e84b060db..ab342d6654 100644
--- a/src/d/d_s_play.cpp
+++ b/src/d/d_s_play.cpp
@@ -42,7 +42,10 @@
 #if TARGET_PC
 #include "dusk/autosave.h"
 #include "dusk/memory.h"
+#include "dusk/mods/item.hpp"
+#include "dusk/trigger_viewer.h"
 #include "dusk/ui/ui.hpp"
+#include "mods/items.h"
 #endif
 
 #if DEBUG
@@ -93,9 +96,9 @@ static OSTime resPreLoadTime1;
 
 static dScnPly_preLoad_HIO_c g_preLoadHIO;
 
-s8 dScnPly_c::pauseTimer;
+DUSK_GAME_DATA s8 dScnPly_c::pauseTimer;
 
-s8 dScnPly_c::nextPauseTimer;
+DUSK_GAME_DATA s8 dScnPly_c::nextPauseTimer;
 
 #if DEBUG
 u8 dScnPly_c::debugPause;
@@ -675,6 +678,10 @@ static int dScnPly_Draw(dScnPly_c* i_this) {
         dComIfG_Ccsp()->Draw();
         dComIfG_Bgsp().Draw();
 
+        #if TARGET_PC
+        dusk::TriggerView::execute();
+        #endif
+
         #if DEBUG
         dPath_Draw();
         #endif
@@ -1192,11 +1199,35 @@ static int phase_1(dScnPly_c* i_this) {
     }
 
     // Stage: Ordon Spring, Room: Ordon Spring
+#if TARGET_PC
+    const bool iliaMemoryArrival =
+        !strcmp(dComIfGp_getStartStageName(), "F_SP104") && dComIfGp_getStartStageRoomNo() == 1 &&
+        dComIfGp_getStartStagePoint() == 23 && dComIfGp_getStartStageLayer() == 12;
+    const u32 iliaMemoryTag = dusk::mods::item_give_tag(ITEM_CHECK_ILIA_MEMORY);
+    if (!iliaMemoryArrival) {
+        dusk::mods::item_check_cancel(iliaMemoryTag);
+    }
+    if (iliaMemoryArrival)
+#else
     if (!strcmp(dComIfGp_getStartStageName(), "F_SP104") && dComIfGp_getStartStageRoomNo() == 1 &&
         dComIfGp_getStartStagePoint() == 23 && dComIfGp_getStartStageLayer() == 12)
+#endif
     {
-        dComIfGs_onItemFirstBit(dItemNo_HORSE_FLUTE_e);
-        dComIfGs_setItem(SLOT_21, dItemNo_HORSE_FLUTE_e);
+#if TARGET_PC
+        const auto itemCheck =
+            dusk::mods::item_check_commit(iliaMemoryTag, dItemNo_HORSE_FLUTE_e, nullptr);
+        if (itemCheck.itemNo == dItemNo_HORSE_FLUTE_e) {
+#endif
+            dComIfGs_onItemFirstBit(dItemNo_HORSE_FLUTE_e);
+            dComIfGs_setItem(SLOT_21, dItemNo_HORSE_FLUTE_e);
+#if TARGET_PC
+            dusk::mods::item_check_complete(itemCheck, nullptr);
+        } else if (itemCheck.itemNo == dItemNo_NONE_e) {
+            dusk::mods::item_check_complete(itemCheck, nullptr);
+        } else {
+            dusk::mods::item_check_enqueue(itemCheck, dusk::mods::ItemGiveMode::Silent);
+        }
+#endif
     }
 
     if ((u8)dKy_darkworld_stage_check(dComIfGp_getStartStageName(),
@@ -1393,9 +1424,9 @@ static int phase_3(dScnPly_c* i_this) {
     return cPhs_NEXT_e;
 }
 
-dScnPly_reg_HIO_c g_regHIO;
+DUSK_GAME_DATA dScnPly_reg_HIO_c g_regHIO;
 
-dScnPly_env_HIO_c g_envHIO;
+DUSK_GAME_DATA dScnPly_env_HIO_c g_envHIO;
 
 #if DEBUG
 dScnPly_preset_HIO_c g_presetHIO;
diff --git a/src/d/d_save.cpp b/src/d/d_save.cpp
index af2a6db28a..6a4d4c3c05 100644
--- a/src/d/d_save.cpp
+++ b/src/d/d_save.cpp
@@ -16,8 +16,6 @@
 #include <cstdio>
 #include <cstring>
 
-#include "dusk/version.hpp"
-
 #if PLATFORM_WII || PLATFORM_SHIELD
 #include <revolution/sc.h>
 #include <revolution/wpad.h>
@@ -28,11 +26,12 @@
 #endif
 
 #if TARGET_PC
+#include "dusk/game_mode.hpp"
 #include "dusk/settings.h"
-#include <f_ap/f_ap_game.h>
+#include "dusk/version.hpp"
+#include "helpers/string.hpp"
 
-#include "dusk/string.hpp"
-#define strcpy dusk::SafeStringCopy
+#define strcpy SafeStringCopy
 #endif
 
 static u8 dSv_item_rename(u8 i_itemNo) {
@@ -1016,7 +1015,12 @@ void dSv_player_info_c::init() {
 }
 
 void dSv_player_config_c::init() {
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+   if (dusk::version::isRegionJpn())
+       mRuby = 0;
+   else
+       mRuby = 1;
+#elif VERSION == VERSION_GCN_JPN
     mRuby = 0;
 #else
     mRuby = 1;
@@ -1081,7 +1085,7 @@ void dSv_player_config_c::setVibration(u8 i_status) {
 
 u8 dSv_player_config_c::getPalLanguage() const {
 #if TARGET_PC || VERSION == VERSION_GCN_PAL
-    IF_DUSK_BLOCK(dusk::version::getGameVersion() == dusk::version::GameVersion::GcnPal)
+    IF_DUSK_BLOCK(dusk::version::isRegionPal())
     switch (OSGetLanguage()) {
     case 0:
         return LANGUAGE_ENGLISH;
@@ -1823,7 +1827,7 @@ int dSv_info_c::memory_to_card(char* card_ptr, int dataNum) {
         savedata->getPlayer().getPlayerInfo().setTotalTime(play_time);
     }
 
-    savedata->getPlayer().getPlayerStatusB().setDateIpl(OSGetTime());
+    savedata->getPlayer().getPlayerStatusB().setDateIpl(DUSK_IF_ELSE(OSGetSystemTime(), OSGetTime()));
 
     memcpy(card_ptr, savedata, sizeof(dSv_save_c));
     card_ptr += 0x958;
@@ -2030,7 +2034,7 @@ void flagFile_c::listenPropertyEvent(const JORPropertyEvent* i_event) {
     }
     case 102: {
         OSCalendarTime time;
-        OSTicksToCalendarTime(OSGetTime(), &time);
+        OSTicksToCalendarTime(DUSK_IF_ELSE(OSGetSystemTime(), OSGetTime()), &time);
 
         const char* start_stage_name = dComIfGp_getStartStageName();
         char filename[64];
@@ -2089,7 +2093,7 @@ const
 #if PLATFORM_SHIELD
 s16
 #else
-u16
+DUSK_GAME_DATA u16
 #endif
 dSv_event_flag_c::saveBitLabels[822] = {
     UNUSED, TEST_001, TEST_002, TEST_003, TEST_004, F_0001, F_0002, F_0003, F_0004, F_0005, F_0006, 
@@ -2166,7 +2170,7 @@ dSv_event_flag_c::saveBitLabels[822] = {
     F_0816, F_0817, F_0818, F_0819, F_0820, KORO2_ALLCLEAR,
 };
 
-u16 const dSv_event_tmp_flag_c::tempBitLabels[185] = {
+DUSK_GAME_DATA u16 const dSv_event_tmp_flag_c::tempBitLabels[185] = {
     UNUSED, UNUSED, T_0002, T_0003, T_0004, T_0005, T_0006, T_0007, T_0001, T_0008, T_0009, T_0010,
     T_0011, T_0012, T_0013, T_0014, T_0015, T_0016, T_0017, T_0018, T_0019, T_0020, T_0021, T_0022,
     T_0023, T_0024, T_0025, T_0026, T_0027, T_0028, T_0029, T_0030, T_0031, T_0032, TREG_000, 
diff --git a/src/d/d_save_HIO.cpp b/src/d/d_save_HIO.cpp
index 013bc709bd..1f2d2bb212 100644
--- a/src/d/d_save_HIO.cpp
+++ b/src/d/d_save_HIO.cpp
@@ -186,4 +186,4 @@ void dSvBit_HIO_c::init() {
     mTransformFlag = field_0x49d = dComIfGs_isEventBit(dSv_event_flag_c::M_077);
 }
 
-dSvBit_HIO_c g_save_bit_HIO;
+DUSK_GAME_DATA dSvBit_HIO_c g_save_bit_HIO;
diff --git a/src/d/d_scope.cpp b/src/d/d_scope.cpp
index 2f68f534ed..cf58a8a6c2 100644
--- a/src/d/d_scope.cpp
+++ b/src/d/d_scope.cpp
@@ -10,14 +10,14 @@
 #include "JSystem/J2DGraph/J2DOrthoGraph.h"
 
 typedef void (dScope_c::*initFunc)();
-initFunc init_process[] = {
+DUSK_GAME_DATA initFunc init_process[] = {
     &dScope_c::open_init,
     &dScope_c::move_init,
     &dScope_c::close_init,
 };
 
 typedef void (dScope_c::*moveFunc)();
-moveFunc move_process[] = {
+DUSK_GAME_DATA moveFunc move_process[] = {
     &dScope_c::open_proc,
     &dScope_c::move_proc,
     &dScope_c::close_proc,
diff --git a/src/d/d_select_cursor.cpp b/src/d/d_select_cursor.cpp
index 640f8072cd..4fcc6fd5f8 100644
--- a/src/d/d_select_cursor.cpp
+++ b/src/d/d_select_cursor.cpp
@@ -5,9 +5,12 @@
 #include "d/d_com_inf_game.h"
 #include "JSystem/J2DGraph/J2DAnimation.h"
 #include "JSystem/J2DGraph/J2DAnmLoader.h"
-#include "dusk/frame_interpolation.h"
 #include <cstring>
 
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
+
 dSelect_cursorHIO_c::dSelect_cursorHIO_c() {
     field_0x8 = 1.0f;
     mXAxisExpansion = 1.0f;
@@ -281,21 +284,18 @@ void dSelect_cursor_c::update() {
     if (mUpdateFlag) {
         if (field_0x30) {
             if (chkPlayAnime(0)) {
-#ifdef TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                {
-                    if (mNameIdx == 1) {
-                        field_0x44 += mpCursorHIO->field_0x8 * fVar1;
-                    } else {
-                        field_0x44 += fVar1;
-                    }
-
-                    if (field_0x44 >= field_0x30->getFrameMax()) {
-                        field_0x44 -= field_0x30->getFrameMax();
-                    }
+                IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                if (mNameIdx == 1) {
+                    field_0x44 += mpCursorHIO->field_0x8 * fVar1;
+                } else {
+                    field_0x44 += fVar1;
                 }
 
+                if (field_0x44 >= field_0x30->getFrameMax()) {
+                    field_0x44 -= field_0x30->getFrameMax();
+                }
+                IF_DUSK_BLOCK_END
+
                 field_0x30->setFrame(field_0x44);
                 setBpkAnimation(field_0x30);
             } else {
@@ -310,19 +310,16 @@ void dSelect_cursor_c::update() {
         for (int i = 0; i < 2; i++) {
             if (field_0x34[i]) {
                 if ((i == 0 && chkPlayAnime(2)) || (i == 1 && chkPlayAnime(3))) {
-#ifdef TARGET_PC
-                    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                    {
-                        if (mNameIdx == 1) {
-                            field_0x48[i] += mpCursorHIO->field_0x8 * fVar1;
-                        } else {
-                            field_0x48[i] += fVar1;
-                        }
-                        if (field_0x48[i] >= field_0x34[i]->getFrameMax()) {
-                            field_0x48[i] -= field_0x34[i]->getFrameMax();
-                        }
+                    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                    if (mNameIdx == 1) {
+                        field_0x48[i] += mpCursorHIO->field_0x8 * fVar1;
+                    } else {
+                        field_0x48[i] += fVar1;
                     }
+                    if (field_0x48[i] >= field_0x34[i]->getFrameMax()) {
+                        field_0x48[i] -= field_0x34[i]->getFrameMax();
+                    }
+                    IF_DUSK_BLOCK_END
 
                     field_0x34[i]->setFrame(field_0x48[i]);
                 }
@@ -331,19 +328,16 @@ void dSelect_cursor_c::update() {
         }
 
         if (field_0x2C && chkPlayAnime(1)) {
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                if (mNameIdx == 1) {
-                    field_0x40 += mpCursorHIO->field_0x8 * fVar1;
-                } else {
-                    field_0x40 += fVar1;
-                }
-                if (field_0x40 >= field_0x2C->getFrameMax()) {
-                    field_0x40 -= field_0x2C->getFrameMax();
-                }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            if (mNameIdx == 1) {
+                field_0x40 += mpCursorHIO->field_0x8 * fVar1;
+            } else {
+                field_0x40 += fVar1;
             }
+            if (field_0x40 >= field_0x2C->getFrameMax()) {
+                field_0x40 -= field_0x2C->getFrameMax();
+            }
+            IF_DUSK_BLOCK_END
 
             field_0x2C->setFrame(field_0x40);
             setBckAnimation(field_0x2C);
@@ -351,12 +345,9 @@ void dSelect_cursor_c::update() {
         }
 
         if (chkPlayAnime(1) && mNameIdx == 0) {
-#ifdef TARGET_PC
-            if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-            {
-                setCursorAnimation();
-            }
+            IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+            setCursorAnimation();
+            IF_DUSK_BLOCK_END
         }
 
         mpScreen->animation();
diff --git a/src/d/d_select_icon.cpp b/src/d/d_select_icon.cpp
index 32be9c15e2..e55beaf54c 100644
--- a/src/d/d_select_icon.cpp
+++ b/src/d/d_select_icon.cpp
@@ -2,31 +2,28 @@
 
 #include "d/d_select_icon.h"
 #include "JSystem/J2DGraph/J2DAnimation.h"
-#include "dusk/frame_interpolation.h"
+
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#endif
 
 dSi_HIO_c::dSi_HIO_c() {}
 
 void dSelect_icon_c::animation() {
     if (field_0x10->getAlpha() != 0) {
-#ifdef TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            field_0x20 += field_0x2c;
-            if (field_0x20 >= field_0x1c->getFrameMax()) {
-                field_0x20 = 0.0f;
-            }
-            field_0x1c->setFrame(field_0x20);
-
-            field_0x28 += field_0x2c;
-            if (field_0x28 >= field_0x24->getFrameMax()) {
-                field_0x28 = 0.0f;
-            }
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        field_0x20 += field_0x2c;
+        if (field_0x20 >= field_0x1c->getFrameMax()) {
+            field_0x20 = 0.0f;
         }
-#ifdef TARGET_PC
-        // FRAME INTERP NOTE: Set even if not advancing
         field_0x1c->setFrame(field_0x20);
-#endif
+
+        field_0x28 += field_0x2c;
+        if (field_0x28 >= field_0x24->getFrameMax()) {
+            field_0x28 = 0.0f;
+        }
+        IF_DUSK_BLOCK_END
+        IF_DUSK(field_0x1c->setFrame(field_0x20));  // FRAME INTERP NOTE: Set even if not advancing
 
         field_0x24->setFrame(field_0x28);
         field_0x8->animation();
diff --git a/src/d/d_shop_system.cpp b/src/d/d_shop_system.cpp
index 5871d65d2a..1ff45e19a7 100644
--- a/src/d/d_shop_system.cpp
+++ b/src/d/d_shop_system.cpp
@@ -718,13 +718,21 @@ int dShopSystem_c::itemRotate() {
     return 1;
 }
 
+#if TARGET_PC
+#define D_SHOP_SELECTED_ITEM_NO                                                                    \
+    ((mCursorPos > 0 && mCursorPos <= ITEM_MAX_e) ? dShopSystem_itemNo[mCursorPos - 1] :           \
+                                                    dItemNo_NONE_e)
+#else
+#define D_SHOP_SELECTED_ITEM_NO dShopSystem_itemNo[mCursorPos - 1]
+#endif
+
 int dShopSystem_c::itemZoom(cXyz* param_0) {
     cXyz local_1c;
 
     if (field_0xf60 >= 0) {
         local_1c.set(*param_0);
 
-        if (dShopSystem_itemNo[mCursorPos - 1] == dItemNo_OIL_BOTTLE_e) {
+        if (D_SHOP_SELECTED_ITEM_NO == dItemNo_OIL_BOTTLE_e) {
             mItemCtrl.setZoomAnime(mCursorPos, &local_1c,
                                    g_cursorHIO.mSeraShopObjZoomAngleX + -5000,
                                    isFlag(8) ? true : false);
@@ -775,9 +783,9 @@ int dShopSystem_c::itemZoom(cXyz* param_0) {
                              g_cursorHIO.mObjZoom.z + 150.0f);
             } else {
                 if (mMasterType == 5) {
-                    if (dShopSystem_itemNo[mCursorPos - 1] == dItemNo_ARROW_10_e ||
-                        dShopSystem_itemNo[mCursorPos - 1] == dItemNo_ARROW_20_e ||
-                        dShopSystem_itemNo[mCursorPos - 1] == dItemNo_ARROW_30_e)
+                    if (D_SHOP_SELECTED_ITEM_NO == dItemNo_ARROW_10_e ||
+                        D_SHOP_SELECTED_ITEM_NO == dItemNo_ARROW_20_e ||
+                        D_SHOP_SELECTED_ITEM_NO == dItemNo_ARROW_30_e)
                     {
                         local_34.set(g_cursorHIO.mObjZoom.x, -50.0f + g_cursorHIO.mObjZoom.y + 5.0f,
                                      (g_cursorHIO.mObjZoom.z + 250.0f) - 60.0f);
@@ -808,7 +816,7 @@ int dShopSystem_c::itemZoom(cXyz* param_0) {
 
         u8 dvar1 = mMasterType;
         if (dvar1 == 1) {
-            if (dShopSystem_itemNo[mCursorPos - 1] == dItemNo_OIL_BOTTLE_e) {
+            if (D_SHOP_SELECTED_ITEM_NO == dItemNo_OIL_BOTTLE_e) {
                 mItemCtrl.setZoomAnime(mCursorPos, &local_1c,
                                        g_cursorHIO.mShopObjZoomAngleX + -7000,
                                        isFlag(8) ? true : false);
@@ -817,7 +825,7 @@ int dShopSystem_c::itemZoom(cXyz* param_0) {
                                        isFlag(8) ? true : false);
             }
         } else if (dvar1 == 2) {
-            if (dShopSystem_itemNo[mCursorPos - 1] == dItemNo_RED_BOTTLE_e) {
+            if (D_SHOP_SELECTED_ITEM_NO == dItemNo_RED_BOTTLE_e) {
                 mItemCtrl.setZoomAnime(mCursorPos, &local_1c, g_cursorHIO.mShopObjZoomAngleX - 3000,
                                        isFlag(8) ? true : false);
             } else {
@@ -825,9 +833,9 @@ int dShopSystem_c::itemZoom(cXyz* param_0) {
                                        isFlag(8) ? true : false);
             }
         } else if (dvar1 == 5) {
-            if (dShopSystem_itemNo[mCursorPos - 1] == dItemNo_ARROW_10_e ||
-                dShopSystem_itemNo[mCursorPos - 1] == dItemNo_ARROW_20_e ||
-                dShopSystem_itemNo[mCursorPos - 1] == dItemNo_ARROW_30_e)
+            if (D_SHOP_SELECTED_ITEM_NO == dItemNo_ARROW_10_e ||
+                D_SHOP_SELECTED_ITEM_NO == dItemNo_ARROW_20_e ||
+                D_SHOP_SELECTED_ITEM_NO == dItemNo_ARROW_30_e)
             {
                 mItemCtrl.setZoomAnime(mCursorPos, &local_1c, g_cursorHIO.mShopObjZoomAngleX - 4000,
                                        isFlag(8) ? true : false);
@@ -850,6 +858,8 @@ int dShopSystem_c::itemZoom(cXyz* param_0) {
     return 1;
 }
 
+#undef D_SHOP_SELECTED_ITEM_NO
+
 int dShopSystem_c::seq_wait(fopAc_ac_c* param_0, dMsgFlow_c* param_1) {
     return 0;
 }
@@ -905,8 +915,18 @@ int dShopSystem_c::seq_start(fopAc_ac_c* actor, dMsgFlow_c* i_flow) {
                 int itemNo;
                 if (mFlow.getEventId(&itemNo) == 1) {
                     if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                        mItemPartnerId = fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1,
-                                                                      -1, NULL, NULL);
+#if TARGET_PC
+                        u32 itemGiveTag = 0;
+                        if (itemNo == dItemNo_HALF_MILK_BOTTLE_e) {
+                            const auto itemCheck =
+                                dusk::mods::item_check_commit("sera_reward", itemNo, actor);
+                            itemNo = itemCheck.itemNo;
+                            itemGiveTag = itemCheck.tag;
+                        }
+#endif
+                        mItemPartnerId =
+                            fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL,
+                                NULL IF_DUSK_ARG(itemGiveTag));
                     }
 
                     if (fpcEx_IsExist(mItemPartnerId)) {
@@ -1195,8 +1215,14 @@ int dShopSystem_c::seq_decide_yes(fopAc_ac_c* actor, dMsgFlow_c* i_flow) {
     if (mFlow.getEventId(&itemNo) == 1) {
         if (i_flow->doFlow(actor, NULL, 0)) {
             if (mItemPartnerId == fpcM_ERROR_PROCESS_ID_e) {
-                mItemPartnerId =
-                    fopAcM_createItemForPresentDemo(&current.pos, itemNo, 0, -1, -1, NULL, NULL);
+#if TARGET_PC
+                const u32 itemGiveTag = dusk::mods::item_give_tag_shop(itemNo & 0xFF);
+                const auto itemCheck =
+                    dusk::mods::item_check_commit(itemGiveTag, itemNo & 0xFF, actor);
+                itemNo = itemCheck.itemNo;
+#endif
+                mItemPartnerId = fopAcM_createItemForPresentDemo(
+                    &current.pos, itemNo, 0, -1, -1, NULL, NULL IF_DUSK_ARG(itemGiveTag));
             }
 
             if (fpcEx_IsExist(mItemPartnerId)) {
diff --git a/src/d/d_stage.cpp b/src/d/d_stage.cpp
index 5836feccd2..14167723d9 100644
--- a/src/d/d_stage.cpp
+++ b/src/d/d_stage.cpp
@@ -22,10 +22,12 @@
 #include <cstdio>
 #include <cstring>
 
-#include "dusk/logging.h"
-#include "dusk/string.hpp"
 #if TARGET_PC
-#include <format>
+#include "dusk/logging.h"
+#include "dusk/mods/svc/actor.hpp"
+#include "dusk/mods/svc/stage.hpp"
+#include "helpers/string.hpp"
+
 #include <fmt/ranges.h>
 #endif
 
@@ -157,7 +159,7 @@ void dStage_startStage_c::set(const char* i_Name, s8 i_RoomNo, s16 i_Point, s8 i
 #if TARGET_PC
     // UB fix.
     if (mName != i_Name) {
-        dusk::SafeStringCopy(mName, i_Name);
+        SafeStringCopy(mName, i_Name);
     }
 #else
     strcpy(mName, i_Name);
@@ -167,7 +169,7 @@ void dStage_startStage_c::set(const char* i_Name, s8 i_RoomNo, s16 i_Point, s8 i
     mLayer = i_Layer;
 }
 
-dStage_roomStatus_c dStage_roomControl_c::mStatus[0x40];
+DUSK_GAME_DATA dStage_roomStatus_c dStage_roomControl_c::mStatus[0x40];
 
 void dStage_roomControl_c::init() {
     mStayNo = -1;
@@ -1523,6 +1525,14 @@ static void dummy0() {
 }
 
 dStage_objectNameInf* dStage_searchName(char const* objName) {
+#if TARGET_PC
+    dStage_objectNameInf* info =
+        dusk::mods::svc::actor_impl::get_stageinfo_from_full_name(objName);
+    if (info != nullptr) {
+        return info;
+    }
+#endif
+
     dStage_objectNameInf* obj = l_objectName;
 
     for (u32 i = 0; i < ARRAY_SIZEU(l_objectName); i++) {
@@ -1536,9 +1546,39 @@ dStage_objectNameInf* dStage_searchName(char const* objName) {
     return NULL;
 }
 
+#if TARGET_PC
+dStage_objectNameInf* dStage_searchNameCI(char const* objName) {
+    dStage_objectNameInf* obj = l_objectName;
+
+    for (u32 i = 0; i < ARRAY_SIZEU(l_objectName); i++) {
+        const char* a = obj->name;
+        const char* b = objName;
+        while (*a && *b && tolower((unsigned char)*a) == tolower((unsigned char)*b)) {
+            ++a;
+            ++b;
+        }
+        if (*a == '\0' && *b == '\0') {
+            return obj;
+        }
+        obj++;
+    }
+
+    return NULL;
+}
+#endif
+
 const char* dStage_getName(s16 procName, s8 argument) {
     static char tmp_name[dStage_NAME_LENGTH];
 
+#if TARGET_PC
+    const char* name = dusk::mods::svc::actor_impl::get_full_name_from_proc_name(procName);
+    if (name[0] != '\0') {
+        strncpy(tmp_name, name, sizeof(tmp_name) - 1);
+        tmp_name[sizeof(tmp_name) - 1] = '\0';
+        return tmp_name;
+    }
+#endif
+
     dStage_objectNameInf* obj = l_objectName;
     char* tmp = NULL;
 
@@ -1565,34 +1605,43 @@ const char* dStage_getName2(s16 procName, s8 argument) {
     return dStage_getName(procName, argument);
 }
 
-u8 data_8074C568_debug;
-u8 data_8074C569_debug;
-u8 data_8074C56A_debug;
-u8 data_8074C56B_debug;
-u8 data_8074C56C_debug;
+DUSK_GAME_DATA u8 data_8074C568_debug;
+DUSK_GAME_DATA u8 data_8074C569_debug;
+DUSK_GAME_DATA u8 data_8074C56A_debug;
+DUSK_GAME_DATA u8 data_8074C56B_debug;
+DUSK_GAME_DATA u8 data_8074C56C_debug;
 
-fpc_ProcID dStage_roomControl_c::mProcID;
+DUSK_GAME_DATA fpc_ProcID dStage_roomControl_c::mProcID;
 
-s8 dStage_roomControl_c::mStayNo;
+DUSK_GAME_DATA s8 dStage_roomControl_c::mStayNo;
 
-s8 dStage_roomControl_c::mOldStayNo;
+DUSK_GAME_DATA s8 dStage_roomControl_c::mOldStayNo;
 
-s8 dStage_roomControl_c::mNextStayNo;
+DUSK_GAME_DATA s8 dStage_roomControl_c::mNextStayNo;
 
-u8 dStage_roomControl_c::m_time_pass;
+DUSK_GAME_DATA u8 dStage_roomControl_c::m_time_pass;
 
-u8 dStage_roomControl_c::mNoChangeRoom;
+DUSK_GAME_DATA u8 dStage_roomControl_c::mNoChangeRoom;
 
-dStage_roomControl_c::dStage_bankName* dStage_roomControl_c::mArcBankName;
+DUSK_GAME_DATA dStage_roomControl_c::dStage_bankName* dStage_roomControl_c::mArcBankName;
 
-dStage_roomControl_c::dStage_bankData* dStage_roomControl_c::mArcBankData;
+DUSK_GAME_DATA dStage_roomControl_c::dStage_bankData* dStage_roomControl_c::mArcBankData;
 
-dStage_roomControl_c::roomDzs_c dStage_roomControl_c::m_roomDzs;
+DUSK_GAME_DATA dStage_roomControl_c::roomDzs_c dStage_roomControl_c::m_roomDzs;
 #if DEBUG
 u8 dStage_roomControl_c::mNoArcBank;
 #endif
 
-static void dStage_actorCreate(stage_actor_data_class* i_actorData, fopAcM_prm_class* i_actorPrm) {
+static void dStage_actorCreate(stage_actor_data_class* i_actorData, fopAcM_prm_class* i_actorPrm
+                                IF_DUSK_ARG(size_t recordSize = sizeof(stage_actor_data_class))) {
+#if TARGET_PC
+    if (!dusk::mods::svc::stage_apply_actor_edits(i_actorData, i_actorPrm, recordSize,
+            i_actorPrm->room_no))
+    {
+        JKRFree(i_actorPrm);
+        return;
+    }
+#endif
     dStage_objectNameInf* actorInf = dStage_searchName(i_actorData->name);
 
     if (actorInf == NULL) {
@@ -1654,6 +1703,8 @@ static int dStage_playerInit(dStage_dt_c* i_stage, void* i_data, int num, void*
     fopAcM_prm_class* appen = fopAcM_CreateAppend();
     JUT_ASSERT(1586, appen != NULL);
 
+    IF_DUSK(stage_actor_data_class newPoint{};) // data stored on the stack for any newly registered spawn points
+
     int point = dComIfGp_getStartStagePoint();
     u32 roomParam = dComIfGs_getRestartRoomParam();
     if (point == -2 || point == -3) {
@@ -1674,6 +1725,13 @@ static int dStage_playerInit(dStage_dt_c* i_stage, void* i_data, int num, void*
 
         int i;
         for (i = 0; i < num; i++) {
+#ifdef TARGET_PC
+            // If, for whatever reason, we want to patch the point ID, we need to do it here.
+            if (!dusk::mods::svc::stage_apply_actor_edits(player_data, nullptr, sizeof(*player_data), i_stage->getRoomNo())) {
+                player_data++;
+                continue; // If the spawn is deleted, check the next one
+            }
+#endif
             if ((u8)player_data->base.angle.z == unk) {
                 break;
             }
@@ -1681,16 +1739,43 @@ static int dStage_playerInit(dStage_dt_c* i_stage, void* i_data, int num, void*
         }
         if (i == num) {
 #if TARGET_PC
-            std::vector<s16> valid_points;
-            valid_points.reserve(num);
-            player_data = player->m_entries;
-            for (i = 0; i < num; i++) {
-                valid_points.push_back(player_data->base.angle.z);
-                player_data++;
+            // Search through all new actor edits and return the point data via userdata
+            struct newActors_userData {
+                stage_actor_data_class* out_point;
+                bool out_pointSet;
+                int16_t pointNo;
+            };
+            newActors_userData params = {
+                &newPoint, false, (int16_t)unk
+            };
+            dusk::mods::svc::stage_create_new_actors(i_stage->getRoomNo(),
+        [](void* user, const void* record, size_t size) {
+                const stage_actor_data_class* i_record =  static_cast<const stage_actor_data_class*>(record);
+                auto* params = static_cast<newActors_userData*>(user);
+                
+                // We don't cast i_record->base.angle.z to a u8 here so we can register any spawn point within the s16 range
+                if (i_record->base.angle.z == params->pointNo && size == sizeof(stage_actor_data_class) && strncmp(i_record->name,"Link",7) == 0) {
+                    std::memcpy(params->out_point, i_record, size);
+                    params->out_pointSet = true;
+                }
+            },
+            &params);
+
+            if (params.out_pointSet) {
+                player_data = &newPoint;
+            } else {
+                // If the requested spawn point isn't found, print all valid points within the log 
+                std::vector<s16> valid_points;
+                valid_points.reserve(num);
+                player_data = player->m_entries;
+                for (i = 0; i < num; i++) {
+                    valid_points.push_back(player_data->base.angle.z);
+                    player_data++;
+                }
+                std::ranges::sort(valid_points);
+                DuskLog.fatal("Failed to find player start point for next stage! Requested point: {}, Valid points: [{}]",
+                              point, fmt::join(valid_points, ", "));
             }
-            std::ranges::sort(valid_points);
-            DuskLog.fatal("Failed to find player start point for next stage! Requested point: {}, Valid points: [{}]",
-                          point, fmt::join(valid_points, ", "));
 #else
             OS_REPORT_ERROR("プレイヤーが発見できません。[No.%d]\n切り替えの情報や処理の確認をお願いします。\n", point);
 #endif
@@ -1992,7 +2077,12 @@ static int dStage_tgscCommonLayerInit(dStage_dt_c* i_stage, void* i_data, int en
                 appen->base = tgsc_data->base;
                 appen->room_no = (int)i_stage->getRoomNo();
                 appen->scale = tgsc_data->scale;
+#if TARGET_PC
+                dStage_actorCreate(actor_data, appen,
+                    sizeof(stage_actor_data_class) + sizeof(fopAcM_prmScale_class));
+#else
                 dStage_actorCreate(actor_data, appen);
+#endif
             }
         }
         tgsc_data++;
@@ -2063,7 +2153,12 @@ static int dStage_tgscInfoInit(dStage_dt_c* i_stage, void* i_data, int entryNum,
                 appen->base = actor_data->base;
                 appen->room_no = (int)i_stage->getRoomNo();
                 appen->scale = tgsc_data->scale;
+#if TARGET_PC
+                dStage_actorCreate(actor_data, appen,
+                    sizeof(stage_actor_data_class) + sizeof(fopAcM_prmScale_class));
+#else
                 dStage_actorCreate(actor_data, appen);
+#endif
             }
         }
         tgsc_data++;
@@ -2086,7 +2181,8 @@ static int dStage_doorInfoInit(dStage_dt_c* i_stage, void* i_data, int entryNum,
             appen->base = actor_data->base;
             appen->room_no = (int)i_stage->getRoomNo();
             appen->scale = tgsc_data->scale;
-            dStage_actorCreate(actor_data, appen);
+            dStage_actorCreate(actor_data, appen IF_DUSK_ARG(
+                sizeof(stage_actor_data_class) + sizeof(fopAcM_prmScale_class)));
         }
         tgsc_data++;
     }
@@ -2511,6 +2607,34 @@ static void dKankyo_create() {
     fopKyM_fastCreate(fpcNm_ENVSE_e, 0, NULL, NULL, NULL);
 }
 
+#if TARGET_PC
+static void dusk_stage_svc_new_actor_create(dStage_dt_c* i_stage) {
+    dusk::mods::svc::stage_create_new_actors(i_stage->getRoomNo(),
+        [](void* user, const void* record, size_t size) {
+            auto* stage = static_cast<dStage_dt_c*>(user);
+            stage_tgsc_data_class object{};
+            std::memcpy(&object, record, size);
+
+            if (strncmp(object.name,"Link",7) == 0) {
+                // We create new spawns for Link during dStage_playerInit. Ignore them here so we don't get duplicates.
+                return;
+            }
+
+            fopAcM_prm_class* appen = fopAcM_CreateAppend();
+            if (appen != nullptr) {
+                appen->base = object.base;
+                appen->room_no = static_cast<int>(stage->getRoomNo());
+                if (size > sizeof(stage_actor_data_class)) {
+                    appen->scale = object.scale;
+                }
+                dStage_actorCreate(
+                    reinterpret_cast<stage_actor_data_class*>(&object), appen, size);
+            }
+        },
+        i_stage);
+}
+#endif
+
 static void layerMemoryInfoLoader(void* i_data, dStage_dt_c* i_stage, int param_2) {
     UNUSED(param_2);
     static FuncTable l_layerFuncTable[] = {
@@ -2707,6 +2831,7 @@ void dStage_dt_c_roomReLoader(void* i_data, dStage_dt_c* i_stage, int param_2) {
     };
 
     dStage_dt_c_decode(i_data, i_stage, l_funcTable, ARRAY_SIZEU(l_funcTable));
+    IF_DUSK(dusk_stage_svc_new_actor_create(i_stage));
     layerActorLoader(i_data, i_stage, param_2);
 }
 
@@ -2723,12 +2848,12 @@ void dStage_dt_c_fieldMapLoader(void* i_data, dStage_dt_c* i_stage) {
     dStage_dt_c_decode(i_data, i_stage, l_funcTable, ARRAY_SIZEU(l_funcTable));
 }
 
-JKRExpHeap* dStage_roomControl_c::mMemoryBlock[MEMORY_BLOCK_MAX] = {
+DUSK_GAME_DATA JKRExpHeap* dStage_roomControl_c::mMemoryBlock[MEMORY_BLOCK_MAX] = {
     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
     NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
 };
 
-char dStage_roomControl_c::mArcBank[32][10] = {0};
+DUSK_GAME_DATA char dStage_roomControl_c::mArcBank[32][10] = {0};
 
 void dStage_infoCreate() {
     OS_REPORT("dStage_Create\n");
@@ -2739,7 +2864,7 @@ void dStage_infoCreate() {
     dStage_dt_c_stageInitLoader(stageRsrc, dComIfGp_getStage());
 }
 
-char dStage_roomControl_c::mDemoArcName[10];
+DUSK_GAME_DATA char dStage_roomControl_c::mDemoArcName[10];
 
 void dStage_Create() {
     void* stageRsrc = dComIfG_getStageRes("stage.dzs");
@@ -2807,7 +2932,7 @@ void dStage_Delete() {
     dComIfGp_getStage()->init();
 }
 
-s8 dStage_roomControl_c::mRoomReadId = -1;
+DUSK_GAME_DATA s8 dStage_roomControl_c::mRoomReadId = -1;
 
 int dStage_RoomCheck(cBgS_GndChk* gndChk) {
     int roomReadId = dStage_roomControl_c::getRoomReadId();
diff --git a/src/d/d_timer.cpp b/src/d/d_timer.cpp
index 1b4febc9f4..df1a3ef104 100644
--- a/src/d/d_timer.cpp
+++ b/src/d/d_timer.cpp
@@ -23,7 +23,10 @@
 #include "m_Do/m_Do_lib.h"
 #include <cstring>
 
-#include "dusk/frame_interpolation.h"
+#if TARGET_PC
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/version.hpp"
+#endif
 
 static int dTimer_createStart2D(s32 param_0, u16 param_1);
 
@@ -1339,23 +1342,20 @@ void dDlst_TimerScrnDraw_c::draw() {
                ((f32)g_drawHIO.mMiniGame.mGetInTextWaitFrames + 60.0f);
 
     for (int i = 0; i < 51; i++) {
-#if TARGET_PC
-        if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-        {
-            if (m_getin_info[i].bck_frame > 0.0f && m_getin_info[i].bck_frame < temp) {
-                if (m_getin_info[i].bck_frame < 60.0f) {
-                    m_getin_info[i].bck_frame += g_drawHIO.mMiniGame.mGetInTextAnimSpeed;
-                    if (m_getin_info[i].bck_frame > 60.0f) {
-                        m_getin_info[i].bck_frame = 60.0f;
-                    }
-                } else if (m_getin_info[i].bck_frame < g_drawHIO.mMiniGame.mGetInTextWaitFrames + 60.0f) {
-                    m_getin_info[i].bck_frame++;
-                } else if (m_getin_info[i].bck_frame < temp) {
-                    m_getin_info[i].bck_frame++;
+        IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+        if (m_getin_info[i].bck_frame > 0.0f && m_getin_info[i].bck_frame < temp) {
+            if (m_getin_info[i].bck_frame < 60.0f) {
+                m_getin_info[i].bck_frame += g_drawHIO.mMiniGame.mGetInTextAnimSpeed;
+                if (m_getin_info[i].bck_frame > 60.0f) {
+                    m_getin_info[i].bck_frame = 60.0f;
                 }
+            } else if (m_getin_info[i].bck_frame < g_drawHIO.mMiniGame.mGetInTextWaitFrames + 60.0f) {
+                m_getin_info[i].bck_frame++;
+            } else if (m_getin_info[i].bck_frame < temp) {
+                m_getin_info[i].bck_frame++;
             }
         }
+        IF_DUSK_BLOCK_END
 
         if (m_getin_info[i].bck_frame > 0.0f && m_getin_info[i].bck_frame < temp) {
             f32 var_f29 = 1.0f;
@@ -1395,20 +1395,17 @@ void dDlst_TimerScrnDraw_c::draw() {
             if (m_getin_info[i].pikari_frame > 0.0f) {
                 drawPikari(i);
             } else if (m_getin_info[i].pikari_frame == -1.0f) {
-#if TARGET_PC
-                if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-                {
-                    if (m_getin_info[i].field_0xc == 0) {
-                        if (m_getin_info[i].bck_frame > g_drawHIO.mMiniGame.mGetInPikariAppearFrames) {
-                            m_getin_info[i].pikari_frame =
-                                18.0f - g_drawHIO.mMiniGame.mGetInPikariAnimSpeed;
-                        }
-                    } else if (m_getin_info[i].bck_frame > g_drawHIO.mMiniGame.mStartPikariAppearFrames) {
+                IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+                if (m_getin_info[i].field_0xc == 0) {
+                    if (m_getin_info[i].bck_frame > g_drawHIO.mMiniGame.mGetInPikariAppearFrames) {
                         m_getin_info[i].pikari_frame =
-                            18.0f - g_drawHIO.mMiniGame.mStartPikariAnimSpeed;
+                            18.0f - g_drawHIO.mMiniGame.mGetInPikariAnimSpeed;
                     }
+                } else if (m_getin_info[i].bck_frame > g_drawHIO.mMiniGame.mStartPikariAppearFrames) {
+                    m_getin_info[i].pikari_frame =
+                        18.0f - g_drawHIO.mMiniGame.mStartPikariAnimSpeed;
                 }
+                IF_DUSK_BLOCK_END
             }
         }
     }
@@ -1430,7 +1427,7 @@ void dDlst_TimerScrnDraw_c::playBckAnimation(f32 i_frame) {
     mpGetInParent->getPanePtr()->setAnimation((J2DAnmTransform*)NULL);
 }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC || VERSION == VERSION_GCN_JPN
 bool dDlst_TimerScrnDraw_c::isLeadByte(int i_char) {
     return (i_char >= 0x81 && i_char <= 0x9f) || (i_char >= 0xe0 && i_char <= 0xfc);
 }
@@ -1466,7 +1463,18 @@ void dDlst_TimerScrnDraw_c::drawPikari(int i_no) {
                 var_f25 * static_cast<J2DTextBox*>(mpGetInText->getPanePtr())->getCharSpace();
         }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            if (isLeadByte(c)) {
+                c = ((string[str_idx] & 0xFF) << 8) | (string[str_idx + 1] & 0xFF);
+                str_idx++;
+            } else {
+                c = string[str_idx] & 0xFF;
+            }
+        } else {
+            c = string[str_idx] & 0xFF;
+        }
+#elif VERSION == VERSION_GCN_JPN
         if (isLeadByte(c)) {
             c = ((string[str_idx] & 0xFF) << 8) | (string[str_idx + 1] & 0xFF);
             str_idx++;
@@ -1492,7 +1500,18 @@ void dDlst_TimerScrnDraw_c::drawPikari(int i_no) {
                 var_f25 * static_cast<J2DTextBox*>(mpGetInText->getPanePtr())->getCharSpace();
         }
 
-#if VERSION == VERSION_GCN_JPN
+#if TARGET_PC
+        if (dusk::version::isRegionJpn()) {
+            if (isLeadByte(c)) {
+                c = ((string[str_idx] & 0xFF) << 8) | (string[str_idx + 1] & 0xFF);
+                str_idx++;
+            } else {
+                c = string[str_idx] & 0xFF;
+            }
+        } else {
+            c = string[str_idx] & 0xFF;
+        }
+#elif VERSION == VERSION_GCN_JPN
         if (isLeadByte(c)) {
             c = ((string[str_idx] & 0xFF) << 8) | (string[str_idx + 1] & 0xFF);
             str_idx++;
diff --git a/src/d/d_tresure.cpp b/src/d/d_tresure.cpp
index 90044360c8..54b416a69f 100644
--- a/src/d/d_tresure.cpp
+++ b/src/d/d_tresure.cpp
@@ -8,7 +8,7 @@
 
 static bool data_80450680 = true;
 
-dTres_c::typeGroupData_c* dTres_c::mTypeGroupData;
+DUSK_GAME_DATA dTres_c::typeGroupData_c* dTres_c::mTypeGroupData;
 
 int dTres_c::createWork() {
     mTypeGroupData = JKR_NEW_ARRAY(dTres_c::typeGroupData_c, 0x40);
@@ -25,9 +25,9 @@ void dTres_c::remove() {
     data_80450680 = true;
 }
 
-dTres_c::type_group_list dTres_c::mTypeGroupListAll[17];
+DUSK_GAME_DATA dTres_c::type_group_list dTres_c::mTypeGroupListAll[17];
 
-u16 dTres_c::mNum;
+DUSK_GAME_DATA u16 dTres_c::mNum;
 
 void dTres_c::reset() {
     if (data_80450680) {
@@ -229,7 +229,7 @@ void dTres_c::setPosition(int dataNo, u8 listIdx, Vec const* i_pos, int i_roomNo
     }
 }
 
-u8 const dTres_c::typeToTypeGroup[17][2] = {
+DUSK_GAME_DATA u8 const dTres_c::typeToTypeGroup[17][2] = {
     {0xFF, 0x00}, {0x00, 0x01}, {0x01, 0x02}, {0x02, 0x03}, {0x03, 0x04}, {0x04, 0x05},
     {0x05, 0x06}, {0x06, 0x07}, {0x07, 0x08}, {0x80, 0x09}, {0x81, 0x0A}, {0x82, 0x0B},
     {0x83, 0x0C}, {0x84, 0x0D}, {0x85, 0x0E}, {0x87, 0x0F}, {0x88, 0x10},
diff --git a/src/d/d_vib_pattern.cpp b/src/d/d_vib_pattern.cpp
index 6c06016cf5..774e16b3d9 100644
--- a/src/d/d_vib_pattern.cpp
+++ b/src/d/d_vib_pattern.cpp
@@ -3,7 +3,7 @@
 #include "d/d_vibration.h"
 
 // Motor Shock patterns
-const vib_pattern dVibration_c::MS_patt[VIBMODE_S_MAX] = {
+DUSK_GAME_DATA const vib_pattern dVibration_c::MS_patt[VIBMODE_S_MAX] = {
     /* VIBMODE_S_CUSTOM */ {0, 0, 0x00000000},
     /* VIBMODE_S_POWER1 */ {0, 3, 0xC0000000},
     /* VIBMODE_S_POWER2 */ {0, 4, 0xE0000000},
@@ -18,7 +18,7 @@ const vib_pattern dVibration_c::MS_patt[VIBMODE_S_MAX] = {
 };
 
 // Camera Shock patterns
-const vib_pattern dVibration_c::CS_patt[VIBMODE_S_MAX] = {
+DUSK_GAME_DATA const vib_pattern dVibration_c::CS_patt[VIBMODE_S_MAX] = {
     /* VIBMODE_S_CUSTOM */ {0, 0, 0x00000000},
     /* VIBMODE_S_POWER1 */ {0, 3, 0xC0000000},
     /* VIBMODE_S_POWER2 */ {0, 4, 0xE0000000},
@@ -33,7 +33,7 @@ const vib_pattern dVibration_c::CS_patt[VIBMODE_S_MAX] = {
 };
 
 // Motor Quake patterns
-const vib_pattern dVibration_c::MQ_patt[VIBMODE_Q_MAX] = {
+DUSK_GAME_DATA const vib_pattern dVibration_c::MQ_patt[VIBMODE_Q_MAX] = {
     /* VIBMODE_Q_CUSTOM */ {0, 0, 0x00000000},
     /* VIBMODE_Q_POWER1 */ {1, 32, 0x10202020},
     /* VIBMODE_Q_POWER2 */ {1, 32, 0x42104208},
@@ -47,7 +47,7 @@ const vib_pattern dVibration_c::MQ_patt[VIBMODE_Q_MAX] = {
 };
 
 // Camera Quake patterns
-const vib_pattern dVibration_c::CQ_patt[VIBMODE_Q_MAX] = {
+DUSK_GAME_DATA const vib_pattern dVibration_c::CQ_patt[VIBMODE_Q_MAX] = {
     /* VIBMODE_Q_CUSTOM */ {0, 0, 0x00000000},
     /* VIBMODE_Q_POWER1 */ {1, 32, 0x10202020},
     /* VIBMODE_Q_POWER2 */ {1, 32, 0x42104208},
@@ -60,7 +60,7 @@ const vib_pattern dVibration_c::CQ_patt[VIBMODE_Q_MAX] = {
     /* VIBMODE_Q_HORSE  */ {0, 27, 0x20201000},
 };
 
-const char* shock_names[VIBMODE_S_MAX] = {
+DUSK_GAME_DATA const char* shock_names[VIBMODE_S_MAX] = {
     "VIBMODE_S_CUSTOM",
     "VIBMODE_S_POWER1",
     "VIBMODE_S_POWER2",
@@ -74,7 +74,7 @@ const char* shock_names[VIBMODE_S_MAX] = {
     "VIBMODE_S_FOR2D",
 };
 
-const char* quake_names[VIBMODE_Q_MAX] = {
+DUSK_GAME_DATA const char* quake_names[VIBMODE_Q_MAX] = {
     "VIBMODE_Q_CUSTOM",
     "VIBMODE_Q_POWER1",
     "VIBMODE_Q_POWER2",
diff --git a/src/dusk/OSReport.cpp b/src/dusk/OSReport.cpp
index 422b88f03c..742a36cdd9 100644
--- a/src/dusk/OSReport.cpp
+++ b/src/dusk/OSReport.cpp
@@ -1,9 +1,10 @@
 #include <memory>
 
-#include "aurora/lib/logging.hpp"
+#include <borealis/log.hpp>
+#include "dusk/os.h"
 #include "os_report.h"
 
-aurora::Module Log("dusk::osReport");
+static constexpr borealis::Log Log{"dusk::osReport"};
 
 bool dusk::OSReportReallyForceEnable = false;
 
@@ -143,4 +144,4 @@ void OSAttention(const char* fmt, ...) {
     va_start(args, fmt);
     OSVAttention(fmt, args);
     va_end(args);
-}
\ No newline at end of file
+}
diff --git a/src/dusk/OSThread.cpp b/src/dusk/OSThread.cpp
index 7b97026e13..ac86a0ecce 100644
--- a/src/dusk/OSThread.cpp
+++ b/src/dusk/OSThread.cpp
@@ -509,6 +509,12 @@ BOOL OSJoinThread(OSThread* thread, void** val) {
             *(s32*)val = (s32)(intptr_t)thread->val;
         }
         thread->state = 0;
+
+        {
+            std::lock_guard mapLock(GetThreadDataMutex());
+            GetThreadDataMap().erase(thread);
+        }
+        sActiveThreadCount--;
         return 1;
     }
     return 0;
diff --git a/src/dusk/achievements.cpp b/src/dusk/achievements.cpp
index 6c4de43487..1c8f74f004 100644
--- a/src/dusk/achievements.cpp
+++ b/src/dusk/achievements.cpp
@@ -1,25 +1,26 @@
 #include "dusk/achievements.h"
-#include "dusk/io.hpp"
-#include "dusk/main.h"
-#include "d/d_com_inf_game.h"
-#include "d/d_item_data.h"
-#include "d/d_map_path_fmap.h"
-#include "d/d_stage.h"
-#include "d/d_menu_fmap.h"
 #include "JSystem/JKernel/JKRArchive.h"
-#include "d/d_meter2_info.h"
 #include "d/actor/d_a_alink.h"
-#include "d/actor/d_a_ni.h"
-#include "d/actor/d_a_npc4.h"
 #include "d/actor/d_a_b_gnd.h"
 #include "d/actor/d_a_b_ob.h"
+#include "d/actor/d_a_ni.h"
+#include "d/actor/d_a_npc4.h"
 #include "d/actor/d_a_player.h"
+#include "d/d_com_inf_game.h"
 #include "d/d_demo.h"
+#include "d/d_item_data.h"
+#include "d/d_map_path_fmap.h"
+#include "d/d_menu_fmap.h"
+#include "d/d_meter2_info.h"
+#include "d/d_stage.h"
+#include "dusk/game_mode.hpp"
+#include "dusk/io.hpp"
+#include "dusk/logging.h"
+#include "dusk/main.h"
+#include "dusk/speedrun.h"
 #include "dusk/ui/ui.hpp"
-#include "f_pc/f_pc_name.h"
 #include "f_op/f_op_actor_mng.h"
 #include "f_pc/f_pc_name.h"
-#include "dusk/logging.h"
 
 #include <filesystem>
 #include <algorithm>
@@ -1302,6 +1303,12 @@ void AchievementSystem::processEntry(Entry& e) {
 }
 
 void AchievementSystem::tick() {
+    // Until we implement an AchievementService, achievements will be unavailible in custom gamemodes
+    if (dusk::gamemode::getGameModeManager().isCurrentGameMode(dusk::gamemode::kVanillaGameModeId) == false
+        && dusk::gamemode::getGameModeManager().isCurrentGameMode(dusk::speedrun::kSpeedrunGameModeId) == false) {
+        m_signals.clear();
+        return;
+    }
     if (!m_loaded) {
         load();
     }
diff --git a/include/dusk/achievements.h b/src/dusk/achievements.h
similarity index 96%
rename from include/dusk/achievements.h
rename to src/dusk/achievements.h
index c93ea5d626..eec7fc6d5a 100644
--- a/include/dusk/achievements.h
+++ b/src/dusk/achievements.h
@@ -1,13 +1,12 @@
 #pragma once
 
+#include <nlohmann/json.hpp>
+
 #include <cstdint>
 #include <functional>
-#include <queue>
-#include <string>
 #include <string_view>
 #include <unordered_map>
 #include <vector>
-#include "nlohmann/json.hpp"
 
 namespace dusk {
 
diff --git a/src/dusk/action_bindings.cpp b/src/dusk/action_bindings.cpp
index 68b07d6c0a..2c97c2c894 100644
--- a/src/dusk/action_bindings.cpp
+++ b/src/dusk/action_bindings.cpp
@@ -1,9 +1,10 @@
 #include "dusk/action_bindings.h"
 
-#include "aurora/lib/input.hpp"
 #include "dusk/settings.h"
 #include "dusk/ui/ui.hpp"
 
+#include <aurora/lib/input.hpp>
+
 namespace dusk {
 
 static std::array<std::array<ActionBindPressData, static_cast<int>(ActionBinds::COUNT)>, PAD_CHANMAX> actionPressData{};
@@ -41,6 +42,15 @@ bool isActionBound(ActionBinds action, u32 port) {
     return getActionBindButton(action, port) != PAD_NATIVE_BUTTON_INVALID;
 }
 
+bool isActionBoundAnyPort(ActionBinds action) {
+    for (u32 port = 0; port < PAD_CHANMAX; ++port) {
+        if (isActionBound(action, port)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 void updateActionBindings() {
     for (u32 port = 0; port < PAD_CHANMAX; ++port) {
         // Move the current press to the previous frame
diff --git a/include/dusk/action_bindings.h b/src/dusk/action_bindings.h
similarity index 95%
rename from include/dusk/action_bindings.h
rename to src/dusk/action_bindings.h
index a71dac5dfe..77ce9cb815 100644
--- a/include/dusk/action_bindings.h
+++ b/src/dusk/action_bindings.h
@@ -31,6 +31,7 @@ using ActionBindsMap = std::unordered_map<ActionBinds, ActionBindData>;
 ActionBindsMap& getActionBinds();
 
 bool isActionBound(ActionBinds action, u32 port);
+bool isActionBoundAnyPort(ActionBinds action);
 
 void updateActionBindings();
 
diff --git a/src/dusk/android_frame_rate.cpp b/src/dusk/android_frame_rate.cpp
deleted file mode 100644
index bf889a9482..0000000000
--- a/src/dusk/android_frame_rate.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "dusk/android_frame_rate.hpp"
-
-#if defined(TARGET_ANDROID) || defined(__ANDROID__) || defined(ANDROID)
-#include "dusk/settings.h"
-
-#include <SDL3/SDL_system.h>
-#include <jni.h>
-
-namespace dusk::android {
-namespace {
-
-float preferred_surface_frame_rate() {
-    switch (getSettings().game.enableFrameInterpolation.getValue()) {
-    case FrameInterpMode::Off:
-        return 30.0f;
-    case FrameInterpMode::Unlimited:
-    default:
-        return 0.0f;
-    case FrameInterpMode::Capped:
-        return static_cast<float>(getSettings().video.maxFrameRate.getValue());
-    }
-}
-
-bool clear_pending_exception(JNIEnv* env) {
-    if (env == nullptr || !env->ExceptionCheck()) {
-        return false;
-    }
-    env->ExceptionClear();
-    return true;
-}
-
-}  // namespace
-
-void update_surface_frame_rate() {
-    auto* env = static_cast<JNIEnv*>(SDL_GetAndroidJNIEnv());
-    if (env == nullptr) {
-        return;
-    }
-
-    jobject activity = static_cast<jobject>(SDL_GetAndroidActivity());
-    if (activity == nullptr || clear_pending_exception(env)) {
-        if (activity != nullptr) {
-            env->DeleteLocalRef(activity);
-        }
-        return;
-    }
-
-    jclass activityClass = env->GetObjectClass(activity);
-    if (activityClass == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return;
-    }
-
-    jmethodID setPreferredFrameRate =
-        env->GetMethodID(activityClass, "setPreferredSurfaceFrameRate", "(F)V");
-    env->DeleteLocalRef(activityClass);
-    if (setPreferredFrameRate == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return;
-    }
-
-    jvalue args[1]{};
-    args[0].f = preferred_surface_frame_rate();
-    env->CallVoidMethodA(activity, setPreferredFrameRate, args);
-    env->DeleteLocalRef(activity);
-    clear_pending_exception(env);
-}
-
-}  // namespace dusk::android
-#else
-namespace dusk::android {
-void update_surface_frame_rate() {}
-}  // namespace dusk::android
-#endif
diff --git a/src/dusk/android_frame_rate.hpp b/src/dusk/android_frame_rate.hpp
deleted file mode 100644
index 03a7876633..0000000000
--- a/src/dusk/android_frame_rate.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-namespace dusk::android {
-
-void update_surface_frame_rate();
-
-}  // namespace dusk::android
diff --git a/src/dusk/app_info.hpp b/src/dusk/app_info.hpp
new file mode 100644
index 0000000000..dff72b7071
--- /dev/null
+++ b/src/dusk/app_info.hpp
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <borealis/app_info.hpp>
+
+namespace dusk {
+    /** Application identity fields for Borealis modules */
+    inline constexpr borealis::AppInfo AppInfo{
+        .orgName = "TwilitRealm",
+        .appName = "Dusklight",
+        .githubOwner = "TwilitRealm",
+        .githubRepo = "dusklight",
+        .discordApplicationId = "1495632471994405035",
+    };
+
+    /**
+     * \brief The internal application name for the game.
+     *
+     * This gets used for file paths and such, and cannot be changed!
+     */
+    constexpr auto AppName = "Dusklight";
+
+}
diff --git a/src/dusk/archive.cpp b/src/dusk/archive.cpp
new file mode 100644
index 0000000000..a749d5432b
--- /dev/null
+++ b/src/dusk/archive.cpp
@@ -0,0 +1,145 @@
+#include "archive.hpp"
+
+#include <borealis/io.hpp>
+#include <fmt/format.h>
+#include <miniz.h>
+
+#include <array>
+#include <mutex>
+#include <span>
+#include <stdexcept>
+#include <system_error>
+
+namespace dusk::archive {
+namespace {
+
+constexpr std::array ZipMagic{'P', 'K', '\x03', '\x04'};
+
+PackageFormat detect_package_format(mz_zip_archive& zip) {
+    size_t modManifests = 0;
+    for (mz_uint index = 0, count = mz_zip_reader_get_num_files(&zip); index < count; ++index) {
+        mz_zip_archive_file_stat stat{};
+        if (!mz_zip_reader_file_stat(&zip, index, &stat) ||
+            mz_zip_reader_is_file_a_directory(&zip, index))
+        {
+            continue;
+        }
+        const std::string_view name{stat.m_filename};
+        modManifests += name == "mod.json";
+    }
+    if (modManifests == 1) {
+        return PackageFormat::Mod;
+    }
+    return PackageFormat::Unknown;
+}
+
+}  // namespace
+
+struct ZipArchive::Impl {
+    ~Impl() {
+        if (open) {
+            mz_zip_reader_end(&zip);
+        }
+    }
+
+    static size_t read_zip(
+        void* opaque, mz_uint64 offset, void* buffer, const size_t size) {
+        auto& archive = *static_cast<Impl*>(opaque);
+        std::error_code error;
+        return archive.file.read_at(offset, {static_cast<std::byte*>(buffer), size}, error);
+    }
+
+    borealis::io::RandomAccessFile file;
+    mz_zip_archive zip{};
+    PackageFormat format = PackageFormat::Unknown;
+    bool open = false;
+    std::mutex mutex;
+};
+
+ZipArchive::ZipArchive(const std::filesystem::path& path) : m_impl{std::make_unique<Impl>()} {
+    auto opened = borealis::io::RandomAccessFile::open(path);
+    if (opened.status != borealis::io::Status::Ok) {
+        throw std::runtime_error(opened.message);
+    }
+    m_impl->file = std::move(opened.file);
+
+    std::array<char, ZipMagic.size()> header{};
+    std::error_code error;
+    const auto read = m_impl->file.read_at(
+        0, {reinterpret_cast<std::byte*>(header.data()), header.size()}, error);
+    if (error) {
+        throw std::runtime_error(fmt::format("Reading ZIP magic failed: {}", error.message()));
+    }
+    if (read != header.size() || header != ZipMagic) {
+        throw std::runtime_error("File does not have ZIP magic");
+    }
+
+    m_impl->zip.m_pRead = Impl::read_zip;
+    m_impl->zip.m_pIO_opaque = m_impl.get();
+    if (!mz_zip_reader_init(&m_impl->zip, m_impl->file.size(), 0)) {
+        const auto zipError = mz_zip_get_last_error(&m_impl->zip);
+        throw std::runtime_error(
+            fmt::format("Opening ZIP failed: {}", mz_zip_get_error_string(zipError)));
+    }
+    m_impl->open = true;
+    m_impl->format = detect_package_format(m_impl->zip);
+}
+
+ZipArchive::~ZipArchive() = default;
+
+ZipArchive::ZipArchive(ZipArchive&&) noexcept = default;
+ZipArchive& ZipArchive::operator=(ZipArchive&&) noexcept = default;
+
+PackageFormat ZipArchive::package_format() const noexcept {
+    return m_impl->format;
+}
+
+std::vector<uint8_t> ZipArchive::read_file(const std::string_view name) {
+    std::lock_guard lock{m_impl->mutex};
+    const std::string fileName{name};
+    size_t size = 0;
+    void* extracted = mz_zip_reader_extract_file_to_heap(&m_impl->zip, fileName.c_str(), &size, 0);
+    if (extracted == nullptr) {
+        throw std::runtime_error(fmt::format("File does not exist: {}", name));
+    }
+
+    const std::unique_ptr<void, decltype(&mz_free)> owner{extracted, &mz_free};
+    const std::span data{static_cast<const uint8_t*>(owner.get()), size};
+    std::vector<uint8_t> result;
+    result.assign(data.begin(), data.end());
+    return result;
+}
+
+std::vector<std::string> ZipArchive::file_names() {
+    std::lock_guard lock{m_impl->mutex};
+    std::vector<std::string> results;
+    for (mz_uint index = 0, count = mz_zip_reader_get_num_files(&m_impl->zip); index < count;
+        ++index)
+    {
+        mz_zip_archive_file_stat stat{};
+        if (!mz_zip_reader_file_stat(&m_impl->zip, index, &stat) ||
+            mz_zip_reader_is_file_a_directory(&m_impl->zip, index))
+        {
+            continue;
+        }
+        results.emplace_back(stat.m_filename);
+    }
+    return results;
+}
+
+size_t ZipArchive::file_size(const std::string_view name) {
+    std::lock_guard lock{m_impl->mutex};
+    const std::string fileName{name};
+    const auto index = mz_zip_reader_locate_file(&m_impl->zip, fileName.c_str(), nullptr, 0);
+    if (index < 0) {
+        throw std::runtime_error(fmt::format("Unable to locate file in ZIP: {}", name));
+    }
+
+    mz_zip_archive_file_stat stat{};
+    if (!mz_zip_reader_file_stat(&m_impl->zip, static_cast<mz_uint>(index), &stat)) {
+        throw std::runtime_error(fmt::format("Unable to inspect file in ZIP: {}", name));
+    }
+    return static_cast<size_t>(stat.m_uncomp_size);
+}
+
+}  // namespace dusk::archive
diff --git a/src/dusk/archive.hpp b/src/dusk/archive.hpp
new file mode 100644
index 0000000000..2e1003d49c
--- /dev/null
+++ b/src/dusk/archive.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk::archive {
+
+enum class PackageFormat {
+    Unknown,
+    Mod,
+    // Save,
+};
+
+class ZipArchive {
+public:
+    explicit ZipArchive(const std::filesystem::path& path);
+    ~ZipArchive();
+
+    ZipArchive(ZipArchive&&) noexcept;
+    ZipArchive& operator=(ZipArchive&&) noexcept;
+    ZipArchive(const ZipArchive&) = delete;
+    ZipArchive& operator=(const ZipArchive&) = delete;
+
+    PackageFormat package_format() const noexcept;
+    std::vector<uint8_t> read_file(std::string_view name);
+    std::vector<std::string> file_names();
+    size_t file_size(std::string_view name);
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> m_impl;
+};
+
+}  // namespace dusk::archive
diff --git a/include/dusk/audio.h b/src/dusk/audio.h
similarity index 72%
rename from include/dusk/audio.h
rename to src/dusk/audio.h
index e3dfda9f52..0f247689f6 100644
--- a/include/dusk/audio.h
+++ b/src/dusk/audio.h
@@ -1,5 +1,4 @@
-#ifndef DUSK_AUDIO_H
-#define DUSK_AUDIO_H
+#pragma once
 
 #if TARGET_PC
 #define DUSK_AUDIO_DISABLED 0
@@ -12,5 +11,3 @@
 #else
 #define DUSK_AUDIO_SKIP(...)
 #endif
-
-#endif  // DUSK_AUDIO_H
diff --git a/src/dusk/audio/DuskAudioSystem.cpp b/src/dusk/audio/DuskAudioSystem.cpp
index 3577d3c9c7..a3bfe40252 100644
--- a/src/dusk/audio/DuskAudioSystem.cpp
+++ b/src/dusk/audio/DuskAudioSystem.cpp
@@ -1,25 +1,26 @@
-#include "dusk/audio/DuskAudioSystem.h"
+#include "DuskAudioSystem.h"
+
+#include "DuskDsp.hpp"
+
+#include "JSystem/JAudio2/JASAiCtrl.h"
+#include "JSystem/JAudio2/JASAudioThread.h"
+#include "JSystem/JAudio2/JASChannel.h"
+#include "JSystem/JAudio2/JASCriticalSection.h"
+#include "JSystem/JAudio2/JASDriverIF.h"
+#include "JSystem/JAudio2/JASDSPChannel.h"
+#include "JSystem/JAudio2/JASHeapCtrl.h"
 
 #include <SDL3/SDL_init.h>
+#include <tracy/Tracy.hpp>
+
 #include <array>
 #include <cassert>
 #include <span>
 
-#include "JSystem/JAudio2/JASAiCtrl.h"
-#include "JSystem/JAudio2/JASChannel.h"
-#include "JSystem/JAudio2/JASCriticalSection.h"
-#include "JSystem/JAudio2/JASDSPChannel.h"
-#include "JSystem/JAudio2/JASHeapCtrl.h"
-
-#include "DuskDsp.hpp"
-#include "JSystem/JAudio2/JASAudioThread.h"
-#include "JSystem/JAudio2/JASDriverIF.h"
-#include "tracy/Tracy.hpp"
-
 using namespace dusk::audio;
 
 static OutputSubframe OutBuffer;
-static std::array<f32, DSP_SUBFRAME_SIZE * OutputSubframe::NUM_CHANNELS> OutInterleaveBuffer;
+static std::array<f32, DSP_SUBFRAME_SIZE * OutputSubframe::NUM_CHANNELS> OutInterleaveBufferFull;
 
 static SDL_AudioStream* PlaybackStream;
 
@@ -35,28 +36,62 @@ static void SDLCALL GetNewAudio(
 /**
  * Render an entire new frame of audio and output it to SDL3.
  * Note: "audio frames" are unrelated to video frames.
- * @return Amount of audio samples rendered.
+ * @return Amount of audio samples rendered in bytes.
  */
 static int RenderNewAudioFrame();
 
 /**
  * Render an audio subframe and output it to SDL3.
  */
-static void RenderAudioSubframe();
+static int RenderAudioSubframe();
 
-static void InitSDL3Output() {
-    SDL_Init(SDL_INIT_AUDIO);
+static size_t GetChannelCountForOutputMode(dusk::AudioOutputMode config) {
+    switch (config) {
+        default:
+        case dusk::AudioOutputMode::StereoSpeakers:
+        case dusk::AudioOutputMode::StereoHeadphones:
+            return 2;
+        case dusk::AudioOutputMode::Surround6ch:
+            return 6;
+        case dusk::AudioOutputMode::Surround8ch:
+            return 8;
+    }
+}
 
-    constexpr SDL_AudioSpec spec = {
+static bool InitSDL3Output() {
+    const auto speakerConfig = dusk::getSettings().audio.outputMode.getValue();
+    const auto desiredChannelCount = GetChannelCountForOutputMode(speakerConfig);
+    const bool hrtf = speakerConfig == dusk::AudioOutputMode::StereoHeadphones;
+
+    if (PlaybackStream && desiredChannelCount == OutChannelCount) {
+        JASCriticalSection section;
+        EnableHrtf = hrtf;
+        return false;
+    }
+
+    if (PlaybackStream) {
+        SDL_PauseAudioStreamDevice(PlaybackStream);
+        SDL_DestroyAudioStream(PlaybackStream);
+    } else {
+        SDL_Init(SDL_INIT_AUDIO);
+    }
+
+    const SDL_AudioSpec spec = {
         SDL_AUDIO_F32,
-        2,
+        static_cast<int>(desiredChannelCount),
         SampleRate,
     };
-    PlaybackStream = SDL_OpenAudioDeviceStream(
-        SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
-        &spec,
-        &GetNewAudio,
-        nullptr);
+    SDL_AudioStream* newStream =
+        SDL_OpenAudioDeviceStream(SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, &spec, &GetNewAudio, nullptr);
+
+    {
+        JASCriticalSection section;
+        EnableHrtf = hrtf;
+        OutChannelCount = desiredChannelCount;
+        PlaybackStream = newStream;
+    }
+
+    return true;
 }
 
 void dusk::audio::Initialize() {
@@ -71,6 +106,22 @@ void dusk::audio::Initialize() {
     SDL_ResumeAudioStreamDevice(PlaybackStream);
 }
 
+void dusk::audio::Reinitialize() {
+    // don't re-init unless we've initialized first (using PlaybackStream being set as proxy)
+    if (PlaybackStream && InitSDL3Output()) {
+        SDL_ResumeAudioStreamDevice(PlaybackStream);
+    }
+}
+
+void dusk::audio::Shutdown() {
+    if (PlaybackStream) {
+        SDL_DestroyAudioStream(PlaybackStream);
+        PlaybackStream = nullptr;
+    }
+
+    SDL_QuitSubSystem(SDL_INIT_AUDIO);
+}
+
 void dusk::audio::SetMasterVolume(const f32 value) {
     JASCriticalSection section;
 
@@ -112,53 +163,58 @@ int RenderNewAudioFrame() {
     ZoneScoped;
     JASCriticalSection section;
     const u32 countSubframes = JASDriver::getSubFrames();
+    int bytesWritten = 0;
 
     JASAudioThread::setDSPSyncCount(countSubframes);
 
     for (u32 i = 0; i < countSubframes; i++) {
-        RenderAudioSubframe();
+        bytesWritten += RenderAudioSubframe();
 
         JASAudioThread::snIntCount -= 1;
     }
 
-    return static_cast<u16>(countSubframes) * DSP_SUBFRAME_SIZE;
+    return bytesWritten;
 }
 
 static void InterleaveOutputData(const OutputSubframe& data, std::span<f32> target) {
-    assert(target.size() >= data.channels[0].size() * OutputSubframe::NUM_CHANNELS);
+    assert(target.size() >= data.channels[0].size() * OutChannelCount);
 
     size_t outPos = 0;
     for (size_t inPos = 0; inPos < data.channels[0].size(); inPos++) {
-        for (size_t channelIdx = 0; channelIdx < OutputSubframe::NUM_CHANNELS; channelIdx++) {
+        for (size_t channelIdx = 0; channelIdx < OutChannelCount; channelIdx++) {
             target[outPos++] = data.channels[channelIdx][inPos];
         }
     }
 }
 
-void RenderAudioSubframe() {
+int RenderAudioSubframe() {
     ZoneScoped;
     OutBuffer = {};
 
     JASDriver::updateDSP();
     DspRender(OutBuffer);
 
+    std::span<f32> OutInterleaveBuffer{OutInterleaveBufferFull.data(), static_cast<size_t>(DSP_SUBFRAME_SIZE * OutChannelCount)};
     InterleaveOutputData(OutBuffer, OutInterleaveBuffer);
 
     if (JASDriver::extMixCallback != nullptr && JASDriver::sMixMode == MIX_MODE_INTERLEAVE) {
-        static_assert(OutputSubframe::NUM_CHANNELS == 2); // This code only works with Stereo so far.
         // NOTE: In the real game, this gets called on the entire audio frame, rather than the subframe.
         // That's probably more efficient, but I didn't wanna change the code to calculate the
         // entire audio buffers at once.
         // This is only used for the movie player, and it seems to work fine with the smaller calls.
         const auto mixData = JASDriver::extMixCallback(DSP_SUBFRAME_SIZE);
         if (mixData) {
-            for (int i = 0; i < OutInterleaveBuffer.size(); i++) {
-                OutInterleaveBuffer[i] += static_cast<f32>(mixData[i]) / static_cast<f32>(0x7FFF);
+            for (int i = 0; i < DSP_SUBFRAME_SIZE; i++) {
+                const auto oi = i * OutChannelCount;
+                OutInterleaveBuffer[oi] += static_cast<f32>(mixData[i * 2]) / 32767.0f;
+                OutInterleaveBuffer[oi + 1] += static_cast<f32>(mixData[i * 2 + 1]) / 32767.0f;
             }
         }
     }
 
-    SDL_PutAudioStreamData(PlaybackStream, &OutInterleaveBuffer, sizeof(OutInterleaveBuffer));
+    auto bytesToWrite = OutInterleaveBuffer.size_bytes();
+    SDL_PutAudioStreamData(PlaybackStream, OutInterleaveBuffer.data(), bytesToWrite);
+    return bytesToWrite;
 }
 
 u32 dusk::audio::GetResetCount(int channelIdx) {
diff --git a/include/dusk/audio/DuskAudioSystem.h b/src/dusk/audio/DuskAudioSystem.h
similarity index 93%
rename from include/dusk/audio/DuskAudioSystem.h
rename to src/dusk/audio/DuskAudioSystem.h
index 780187f9d2..8a9f9634b7 100644
--- a/include/dusk/audio/DuskAudioSystem.h
+++ b/src/dusk/audio/DuskAudioSystem.h
@@ -19,6 +19,10 @@ namespace dusk::audio {
      */
     void Initialize();
 
+    void Reinitialize();
+
+    void Shutdown();
+
     void SetEnableReverb(bool value);
 
     void SetMasterVolume(f32 value);
diff --git a/src/dusk/audio/DuskDsp.cpp b/src/dusk/audio/DuskDsp.cpp
index ca4d079e92..2e3c14cad7 100644
--- a/src/dusk/audio/DuskDsp.cpp
+++ b/src/dusk/audio/DuskDsp.cpp
@@ -1,21 +1,22 @@
+#include "DuskDsp.hpp"
+
+#include "Adpcm.hpp"
+#include "DuskAudioSystem.h"
+#include "global.h"
+
+#include "dusk/logging.h"
+#include "helpers/endian.h"
+
 #include <ar.h>
 #include <dolphin/os.h>
-
-#include "DuskDsp.hpp"
+#include <freeverb/revmodel.hpp>
+#include <tracy/Tracy.hpp>
 
 #include <algorithm>
 #include <cassert>
 #include <cmath>
-#include <cstdio>
 #include <span>
-
-#include "Adpcm.hpp"
-#include "freeverb/revmodel.hpp"
-#include "dusk/audio/DuskAudioSystem.h"
-#include "dusk/endian.h"
-#include "dusk/logging.h"
-#include "global.h"
-#include "tracy/Tracy.hpp"
+#include <numbers>
 
 using namespace dusk::audio;
 
@@ -50,7 +51,7 @@ bool dusk::audio::EnableReverb = true;
 bool dusk::audio::DumpAudio = false;
 bool dusk::audio::EnableHrtf = false;
 f32 dusk::audio::HrtfGain = 0.5f;
-
+u8 dusk::audio::OutChannelCount = 0;
 
 // 3dB at 5kHz.
 static constexpr f32 HRTF_LP_K     = 0.75f;
@@ -101,28 +102,6 @@ static u32 ConvertSamplesToDataLength(const JASDsp::TChannel& channel, u32 sampl
     return (samples / channel.mSamplesPerBlock) * BlockBytes(channel);
 }
 
-/**
- * Render the audio data contributed by a single DSP channel. Reads & decodes new input samples.
- */
-static void RenderChannel(
-    JASDsp::TChannel& channel,
-    ChannelAuxData& channelAux,
-    OutputSubframe& subframe);
-
-static void RenderOutputChannel(
-    const JASDsp::TChannel& sourceChannel,
-    ChannelAuxData& aux,
-    OutputChannel outputChannel,
-    const std::span<f32> inputSamples,
-    OutputSubframe& fullOutputSubframe);
-
-/**
- * Converts a pitch value on a DSP channel to a sample rate.
- */
-constexpr static int PitchToSampleRate(u16 value) {
-    return static_cast<int>(static_cast<u64>(SampleRate) * value / 4096);
-}
-
 /**
  * Reset state for a DSP channel between independent playbacks.
  */
@@ -164,6 +143,12 @@ static void MixSubframe(DspSubframe& dst, const DspSubframe& src) {
     }
 }
 
+static void MixOutputSubframe(OutputSubframe& dst, const OutputSubframe& src) {
+    for (int i = 0; i < OutChannelCount; i++) {
+        MixSubframe(dst.channels[i], src.channels[i]);
+    }
+}
+
 enum class OscType : u16 {
     SQUARE_WAVE_PW_50        = 0,
     SAW_WAVE                 = 1,
@@ -203,16 +188,14 @@ static void GenerateEvolvingHarmonic() {
     }
 }
 
-
 static void RenderOscChannel(
     JASDsp::TChannel& channel,
     ChannelAuxData& channelAux,
-    OutputSubframe& subframe) {
+    DspSubframe& buf) {
     if (channel.mResetFlag)
         ResetChannel(channel, channelAux);
 
     const u32 pitch = channel.mPitch;
-    DspSubframe buf = {};
     const auto oscType = static_cast<OscType>(channel.mBytesPerBlock);
 
     switch (oscType) {
@@ -270,142 +253,6 @@ static void RenderOscChannel(
         DuskLog.error("RenderOscChannel: unimplemented oscillator type {}", channel.mBytesPerBlock);
         break;
     }
-
-    auto samples = std::span(buf).subspan(0, DSP_SUBFRAME_SIZE);
-    RenderOutputChannel(channel, channelAux, OutputChannel::LEFT,  samples, subframe);
-    RenderOutputChannel(channel, channelAux, OutputChannel::RIGHT, samples, subframe);
-}
-
-
-void dusk::audio::DspRender(OutputSubframe& subframe) {
-    ZoneScoped;
-    if (DumpAudio != sDumpWasActive) {
-        sDumpWasActive = DumpAudio;
-        if (DumpAudio) {
-            OpenChannelDumpFiles();
-        } else {
-            CloseChannelDumpFiles();
-        }
-    }
-
-    GenerateEvolvingHarmonic();
-
-    std::span channels(JASDsp::CH_BUF, DSP_CHANNELS);
-
-    DspSubframe reverbInputL = {};
-    DspSubframe reverbInputR = {};
-    bool anyReverbInput = false;
-
-    DspSubframe surroundBus = {};
-    bool anySurroundInput = false;
-
-    for (int i = 0; i < channels.size(); i++) {
-        auto& channel = channels[i];
-        auto& channelAux = ChannelAux[i];
-
-        if (!channel.mIsActive) {
-            continue;
-        }
-        else if (channel.mPauseFlag) {
-            // Not really sure what the practical difference between pause and
-            // deactivation is. Either avoids clearing state or allows the DSP to avoid popping?
-            continue;
-        }
-        else if (channel.mForcedStop) {
-            channel.mIsFinished = true;
-            continue;
-        }
-
-        OutputSubframe channelSubframe = {};
-        if (channel.mWaveAramAddress == 0) {
-            RenderOscChannel(channel, channelAux, channelSubframe);
-        } else {
-            ValidateChannel(channel);
-            RenderChannel(channel, channelAux, channelSubframe);
-        }
-
-        if (EnableReverb) {
-            // scale the input to the reverb rather than using wet/dry on the output.
-            // this way the reverb's internal buffers accumulate energy proportional to mAutoMixerFxMix,
-            // so any tail always decays at the correct level regardless of mAutoMixerFxMix changes
-            // prevents transients when the next sound starts playing with a different reverb level
-            // 600.0f was pulled out of my ass and just sounds good enough for console
-            f32 inputGain = (channel.mAutoMixerFxMix >> 8) / 600.0f;
-            if (inputGain > 0) {
-                anyReverbInput = true;
-                for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
-                    reverbInputL[j] += channelSubframe.channels[0][j] * inputGain;
-                    reverbInputR[j] += channelSubframe.channels[1][j] * inputGain;
-                }
-            }
-        }
-
-        if (EnableHrtf && channel.mAutoMixerBeenSet) {
-            f32 dolby = (channel.mAutoMixerPanDolby & 0xFF) / 127.0f;
-            if (dolby > 0.0f) {
-                anySurroundInput = true;
-                f32 extract = dolby * HRTF_EXTRACT_MAX;
-                f32 frontScale = 1.0f - extract;
-                for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
-                    f32 mono = (channelSubframe.channels[0][j] + channelSubframe.channels[1][j]) * 0.5f;
-                    surroundBus[j] += mono * extract;
-                    channelSubframe.channels[0][j] *= frontScale;
-                    channelSubframe.channels[1][j] *= frontScale;
-                }
-            }
-        }
-
-        if (DumpAudio && sChannelDumpFiles[i]) {
-            f32 interleaved[DSP_SUBFRAME_SIZE * 2];
-            for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
-                interleaved[j * 2 + 0] = channelSubframe.channels[0][j];
-                interleaved[j * 2 + 1] = channelSubframe.channels[1][j];
-            }
-            fwrite(interleaved, sizeof(f32), DSP_SUBFRAME_SIZE * 2, sChannelDumpFiles[i]);
-        }
-
-        for (int o = 0; o < subframe.channels.size(); o++) {
-            MixSubframe(subframe.channels[o], channelSubframe.channels[o]);
-        }
-    }
-
-    if (EnableReverb && (anyReverbInput || ReverbHasTail)) {
-        // Equivalent to -80 dBFS: rms = 1e-4, rms^2 = 1e-8, sumSq = 2 * N * 1e-8
-        constexpr f32 REVERB_ENERGY_EPSILON = 2.0f * DSP_SUBFRAME_SIZE * 1e-8f;
-        f32 wetEnergy = SharedReverb.processmix(
-            reverbInputL.data(), reverbInputR.data(),
-            subframe.channels[0].data(), subframe.channels[1].data(),
-            DSP_SUBFRAME_SIZE, 1, 1.0f
-        );
-        ReverbHasTail = wetEnergy >= REVERB_ENERGY_EPSILON;
-    }
-
-    if (EnableHrtf && anySurroundInput) {
-        // Two-pole LPF: -12 dB/oct above 3 kHz
-        for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
-            sHrtfLp1 = (1.0f - HRTF_LP_K) * sHrtfLp1 + HRTF_LP_K * surroundBus[j];
-            sHrtfLp2 = (1.0f - HRTF_LP_K) * sHrtfLp2 + HRTF_LP_K * sHrtfLp1;
-            surroundBus[j] = sHrtfLp2;
-        }
-
-        // Mix into L and R
-        // L gets the filtered signal directly; R gets it allpass for mild decorrelation
-        for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
-            f32 s = surroundBus[j];
-
-            subframe.channels[0][j] += s * HrtfGain;
-
-            f32 r = -HRTF_ALLPASS_G * s + sHrtfApIn1 + HRTF_ALLPASS_G * sHrtfApOut1;
-            sHrtfApIn1  = s;
-            sHrtfApOut1 = r;
-            subframe.channels[1][j] += r * HrtfGain;
-        }
-    }
-
-    for (auto& channel : subframe.channels) {
-        ApplyVolume(channel, channel, PrevMasterVolume, MasterVolume);
-    }
-    PrevMasterVolume = MasterVolume;
 }
 
 /**
@@ -457,10 +304,7 @@ static int ReadChannelSamplesChunk(
 
     auto aramBase = static_cast<u8*>(ARGetStorageAddress()) + channel.mWaveAramAddress;
 
-    // Streaming logic directly modifies mSamplesLeft.
-    // So we use that as our tracking of where we are.
-    auto curSamplePosition = channel.mEndSample - channel.mSamplesLeft;
-
+    auto curSamplePosition = channel.mSamplePosition;
     u32 skipSamples = curSamplePosition % channel.mSamplesPerBlock;
     if (skipSamples != 0) {
         // We need to start reading in the middle of a block. This can happen thanks to loops.
@@ -542,135 +386,19 @@ static void FillDecodeBuf(JASDsp::TChannel& channel, ChannelAuxData& aux, int ne
 }
 
 /**
- * Get the expected BusConnect value needed to define the given output channel in a DSP channel.
- */
-constexpr u16 GetBusConnect(const OutputChannel channel) {
-    switch (channel) {
-    // TODO: This is a guess for now.
-    case OutputChannel::LEFT:
-        return 0x0D00;
-    case OutputChannel::RIGHT:
-        return 0x0D60;
-    default:
-        CRASH("Invalid output channel!");
-    }
-}
-
-/**
- * For a DSP channel the JASDsp::OutputChannelConfig value targeting the given output channel.
- * Returns null if the DSP channel does not output to this output channel.
- */
-static const JASDsp::OutputChannelConfig* GetOutputConfig(
-    const JASDsp::TChannel& sourceChannel,
-    OutputChannel channel) {
-
-    auto busConnect = GetBusConnect(channel);
-    for (const auto& mOutputChannel : sourceChannel.mOutputChannels) {
-        auto config = &mOutputChannel;
-        if (config->mBusConnect == busConnect) {
-            return config;
-        }
-    }
-
-    return nullptr;
-}
-
-struct VolumeValue {
-    f32 Target;
-    f32 Init;
-};
-
-/**
- * Get the volume that the given DSP channel should render to the given output channel at.
- */
-static VolumeValue GetVolumeForOutputChannel(
-    const JASDsp::TChannel& sourceChannel,
-    OutputChannel outputChannel) {
-
-    u16 volume;
-    u16 initVolume;
-    f32 panValue = 1;
-    if (sourceChannel.mAutoMixerBeenSet) {
-        volume = sourceChannel.mAutoMixerVolume;
-        initVolume = sourceChannel.mAutoMixerInitVolume;
-
-        auto autoMixerPan = static_cast<f32>(sourceChannel.mAutoMixerPanDolby >> 8) / 127;
-
-        switch (outputChannel) {
-            case OutputChannel::LEFT:
-                panValue = 1 - autoMixerPan;
-                break;
-            case OutputChannel::RIGHT:
-                panValue = autoMixerPan;
-                break;
-            default:
-                CRASH("Unhandled output channel: OutputChannel");
-        }
-
-    } else {
-        auto config = GetOutputConfig(sourceChannel, outputChannel);
-        if (config == nullptr) {
-            return {0, 0};
-        }
-
-        volume = config->mTargetVolume;
-        initVolume = config->mCurrentVolume;
-    }
-
-    // TODO: interpolate to avoid popping.
-    f32 targetRatio = VolumeFromU16(volume);
-    targetRatio *= panValue;
-
-    f32 initRatio = VolumeFromU16(initVolume);
-    initRatio *= panValue;
-
-    return {targetRatio, initRatio};
-}
-
-/**
- * Given decoded & resampled input samples, render a DSP channel to a given output channel.
- */
-static void RenderOutputChannel(
-    const JASDsp::TChannel& sourceChannel,
-    ChannelAuxData& aux,
-    OutputChannel outputChannel,
-    const std::span<f32> inputSamples,
-    OutputSubframe& fullOutputSubframe) {
-
-    auto& outputSubframe = fullOutputSubframe[outputChannel];
-    assert(inputSamples.size() <= outputSubframe.size());
-
-    auto volume = GetVolumeForOutputChannel(sourceChannel, outputChannel);
-
-    f32 targetVolume = volume.Target;
-    auto& prevVolume = aux.PrevVolume(outputChannel);
-    if (std::isnan(prevVolume)) {
-        // Initialize previous volume to new volume on first render.
-        prevVolume = volume.Init;
-    }
-
-    if (prevVolume == 0 && targetVolume == 0) {
-        return;
-    }
-
-    ApplyVolume(outputSubframe, inputSamples, prevVolume, targetVolume);
-    prevVolume = targetVolume;
-}
-
-/**
- * Fetch, decode, resample, output
+ * Render the audio data contributed by a single DSP channel. Reads & decodes new input samples.
  */
 static void RenderChannel(
     JASDsp::TChannel& channel,
     ChannelAuxData& channelAux,
-    OutputSubframe& subframe) {
+    DspSubframe& buf) {
 
     if (channel.mResetFlag) {
         ResetChannel(channel, channelAux);
     }
 
     // how many input samples we step per output sample, aka the resampling ratio
-    f32 step = (f32)PitchToSampleRate(channel.mPitch) / SampleRate;
+    auto step = static_cast<f32>(channel.mPitch) / 4096.0f;
 
     // how many input samples to resample to DSP_SUBFRAME_SIZE output samples
     int needed = static_cast<int>(channelAux.resamplePos + DSP_SUBFRAME_SIZE * step) + 2;
@@ -682,7 +410,6 @@ static void RenderChannel(
         channel.mIsFinished = true;
     }
 
-    DspSubframe audioLoadBuffer = {};
     f32 pos = channelAux.resamplePos;
     s16 prev = channelAux.resamplePrev;
     s16 next = channelAux.decodeBufCount > 0 ? channelAux.decodeBuf[0] : prev;
@@ -690,7 +417,7 @@ static void RenderChannel(
 
     // linear resampling and f32 conversion
     for (int i = 0; i < DSP_SUBFRAME_SIZE; i++) {
-        audioLoadBuffer[i] = (prev + pos * (next - prev)) / 32768.0f;
+        buf[i] = (prev + pos * (next - prev)) / 32768.0f;
         pos += step;
         while (pos >= 1.0f) {
             pos -= 1.0f;
@@ -708,7 +435,7 @@ static void RenderChannel(
 
     // IIR part 1, low-pass: out[n] = (in[n] - in[n-1]) * (coeff/128) + out[n-1]
     if (s16 coeff = channel.iir_filter_params[4]; coeff != 0) {
-        for (f32& sample : audioLoadBuffer) {
+        for (f32& sample : buf) {
             f32 out = std::clamp(
                 (sample - channelAux.prev_lp_in) * ((f32)coeff / 128.0f) + channelAux.prev_lp_out, -1.0f, 1.0f
             );
@@ -720,7 +447,7 @@ static void RenderChannel(
 
     // IIR part 2, biquad: out[n] = (b1*in[n-1] + b2*in[n-2] + a1*out[n-1] + a2*out[n-2]) / 32768
     if ((channel.mFilterMode & 0x20) != 0) {
-        for (f32& sample : audioLoadBuffer) {
+        for (f32& sample : buf) {
             f32 out = std::clamp((
                 channel.iir_filter_params[0] * channelAux.biq_in1  + // b1
                 channel.iir_filter_params[1] * channelAux.biq_in2  + // b2
@@ -743,28 +470,18 @@ static void RenderChannel(
     }
 
     channelAux.decodeBufCount = std::max(0, remainingDecodeBuf);
-
-    auto hasReadSamples = std::span(audioLoadBuffer).subspan(0, DSP_SUBFRAME_SIZE);
-
-    static_assert(OutputSubframe::NUM_CHANNELS == 2, "Keep RenderChannel in sync!");
-
-    RenderOutputChannel(channel, channelAux, OutputChannel::LEFT, hasReadSamples, subframe);
-    RenderOutputChannel(channel, channelAux, OutputChannel::RIGHT, hasReadSamples, subframe);
 }
 
-void dusk::audio::DspInit() {
-    SharedReverb.setwet(1.0f);
-    SharedReverb.setdry(0.0f);
-    SharedReverb.setroomsize(0.5f);
-    SharedReverb.setdamp(0.7f);
-    SharedReverb.setwidth(1.0f);
-    SharedReverb.setmode(0.0f);
-    SharedReverb.mute();
-}
+struct VolumeValue {
+    f32 Target;
+    f32 Init;
+};
 
-void dusk::audio::ApplyVolume(
+using VolumeArray = std::array<VolumeValue, OutputSubframe::NUM_CHANNELS>;
+
+static void ApplyVolume(
     std::span<f32> dst,
-    const std::span<f32> src,
+    std::span<const f32> src,
     const f32 startVolume,
     const f32 endVolume) {
     assert(dst.size() >= src.size());
@@ -780,3 +497,391 @@ void dusk::audio::ApplyVolume(
         }
     }
 }
+
+struct SpeakerPlacement {
+    OutputChannel channel;
+    f32 angle;
+};
+
+struct SpeakerPair {
+    OutputChannel first;
+    OutputChannel second;
+    f32 lo;
+    f32 span;
+};
+
+template <std::size_t N>
+constexpr auto BuildSpeakerPairs(const std::array<SpeakerPlacement, N>& config) {
+    std::array<SpeakerPair, N> pairs = {};
+    constexpr f32 kDegToRad = std::numbers::pi_v<f32> / 180.0f;
+
+    for (std::size_t i = 0; i < N; i++) {
+        std::size_t j = (i + 1) % N;
+        float lo = config[i].angle;
+        float hi = config[j].angle;
+        float span = hi - lo;
+        if (span < 0) span += 360.0f;
+
+        pairs[i] = {config[i].channel, config[j].channel, lo * kDegToRad, span * kDegToRad};
+    }
+
+    return pairs;
+}
+
+constexpr auto Placement6ch = std::to_array<SpeakerPlacement>({
+    // the "rear" channels are actually surround left/right,
+    // changed to match SDL order
+    {OutputChannel::FRONT_RIGHT, -30},
+    {OutputChannel::FRONT_CENTER, 0},
+    {OutputChannel::FRONT_LEFT, 30},
+    {OutputChannel::REAR_LEFT, 120},
+    {OutputChannel::REAR_RIGHT, -120},
+});
+
+constexpr auto Placement8ch = std::to_array<SpeakerPlacement>({
+    {OutputChannel::SURROUND_RIGHT, -90},
+    {OutputChannel::FRONT_RIGHT, -30},
+    {OutputChannel::FRONT_CENTER, 0},
+    {OutputChannel::FRONT_LEFT, 30},
+    {OutputChannel::SURROUND_LEFT, 90},
+    {OutputChannel::REAR_LEFT, 150},
+    {OutputChannel::REAR_RIGHT, -150},
+});
+
+constexpr auto Pairs6ch = BuildSpeakerPairs(Placement6ch);
+constexpr auto Pairs8ch = BuildSpeakerPairs(Placement8ch);
+
+static void CalcStereoChannelVolumes(
+    const JASDsp::TChannel& voice,
+    VolumeArray& volumes)
+{
+    const auto volume = VolumeFromU16(voice.mAutoMixerVolume);
+    const auto initVolume = VolumeFromU16(voice.mAutoMixerInitVolume);
+
+    const auto right = static_cast<f32>(voice.mAutoMixerPanDolby >> 8) / 127.0f;
+    const auto left = 1.0f - right;
+
+    volumes[0] = {left * volume, left * initVolume};
+    volumes[1] = {right * volume, right * initVolume};
+}
+
+static void CalcSurroundChannelVolumes(
+    const JASDsp::TChannel& voice,
+    VolumeArray& volumes)
+{
+    constexpr f32 kTurn = 2.0f * std::numbers::pi_v<f32>;
+    
+    const auto omniGain = 1.0f / static_cast<f32>(OutChannelCount - 1);
+    const auto pan = static_cast<f32>(voice.mAutoMixerPanDolby >> 8) / 63.5f - 1.0f;
+    const auto dolby = static_cast<f32>(voice.mAutoMixerPanDolby & 0xFF) / 63.5f - 1.0f;
+    const auto focus = std::min(std::sqrt(pan * pan + dolby * dolby), 1.0f);
+
+    f32 angle = std::atan2(-pan, -dolby);
+    angle = std::fmod(angle, kTurn);
+    if (angle < 0) angle += kTurn;
+
+    std::array<f32, OutputSubframe::NUM_CHANNELS> gains = {};
+    gains.fill(omniGain * (1.0f - focus));
+
+    using Pairs = std::span<const SpeakerPair>;
+    const auto pairs = OutChannelCount == 6 ? Pairs{Pairs6ch} : Pairs{Pairs8ch};
+
+    for (const auto& pair : pairs) {
+        const auto offset = std::fmod(angle - pair.lo + kTurn, kTurn);
+
+        if (offset <= pair.span) {
+            const auto first = static_cast<size_t>(pair.first);
+            const auto second = static_cast<size_t>(pair.second);
+            const auto t = std::clamp(offset / pair.span, 0.0f, 1.0f);
+
+            const auto firstGain = std::cos(t * std::numbers::pi_v<f32> / 2.0f);
+            const auto secondGain =  std::sin(t * std::numbers::pi_v<f32> / 2.0f);
+
+            gains[first] += focus * firstGain;
+            gains[second] += focus * secondGain;
+
+            break;
+        }
+    }
+
+    const auto volume = VolumeFromU16(voice.mAutoMixerVolume);
+    const auto initVolume = VolumeFromU16(voice.mAutoMixerInitVolume);
+
+    for (size_t i = 0; i < OutChannelCount; i++) {
+        volumes[i].Target = volume * gains[i];
+        volumes[i].Init = initVolume * gains[i];
+    }
+}
+
+static void ApplyPanning(
+    const JASDsp::TChannel& voice,
+    ChannelAuxData& aux,
+    const DspSubframe& input,
+    OutputSubframe& output)
+{
+    VolumeArray volumes = {};
+
+    if (voice.mAutoMixerBeenSet) {
+        if (OutChannelCount > 2) {
+            CalcSurroundChannelVolumes(voice, volumes);
+        } else {
+            CalcStereoChannelVolumes(voice, volumes);
+        }
+    } else {
+        for (const auto& outChannel : voice.mOutputChannels) {
+            std::optional<OutputChannel> ch;
+
+            switch (outChannel.mBusConnect) {
+                case 0x0D00:
+                    ch = OutputChannel::FRONT_LEFT;
+                    break;
+                case 0x0D60:
+                    ch = OutputChannel::FRONT_RIGHT;
+                    break;
+                default:
+                    break;
+            }
+
+            if (ch) {
+                auto& v = volumes[static_cast<size_t>(*ch)];
+                v.Target = VolumeFromU16(outChannel.mTargetVolume);
+                v.Init = VolumeFromU16(outChannel.mCurrentVolume);
+            }
+        }
+    }
+
+    for (size_t i = 0; i < OutChannelCount; i++) {
+        const auto ch = static_cast<OutputChannel>(i);
+        if (ch == OutputChannel::LFE) {
+            continue;
+        }
+
+        const auto& volume = volumes[i];
+
+        const f32 targetVolume = volume.Target;
+        auto& prevVolume = aux.PrevVolume(ch);
+
+        if (std::isnan(prevVolume)) {
+            // Initialize previous volume to new volume on first render.
+            prevVolume = volume.Init;
+        }
+
+        if (prevVolume == 0 && targetVolume == 0) {
+            continue;
+        }
+
+        ApplyVolume(output[ch], input, prevVolume, targetVolume);
+        prevVolume = targetVolume;
+    }
+}
+
+static void DownmixSurroundToStereo(
+    const OutputSubframe& input,
+    OutputSubframe& output)
+{
+    auto& left = output.channels[0];
+    auto& right = output.channels[1];
+    for (int i = 0; i < DSP_SUBFRAME_SIZE; i++) {
+        const auto fc = input.channels[2][i] * 0.5f;
+        left[i] = input.channels[0][i] + fc + input.channels[4][i];
+        right[i] = input.channels[1][i] + fc + input.channels[5][i];
+        if (OutChannelCount > 6) {
+            left[i] += input.channels[6][i];
+            right[i] += input.channels[7][i];
+            left[i] /= 3.5f;
+            right[i] /= 3.5f;
+        } else {
+            left[i] /= 2.5f;
+            right[i] /= 2.5f;
+        }
+    }
+}
+
+static void UpmixStereoToSurroundInplace(OutputSubframe& buf) {
+    // pseudoinverse of downmix matrix
+    const auto w = OutChannelCount > 6 ? 1.0f / 12.0f : 1.0f / 8.0f; 
+    for (int i = 0; i < DSP_SUBFRAME_SIZE; i++) {
+        const auto le = buf.channels[0][i] * (1.0f + w) + buf.channels[1][i] * -w;
+        const auto re = buf.channels[1][i] * (1.0f + w) + buf.channels[0][i] * -w;
+        const auto c = buf.channels[0][i] * 0.5f + buf.channels[1][i] * 0.5f;
+        /* FL  */ buf.channels[0][i] = le;
+        /* FR  */ buf.channels[1][i] = re;
+        /* FC  */ buf.channels[2][i] = c;
+        /* LFE */ buf.channels[3][i] = 0.0f;
+        /* BL  */ buf.channels[4][i] = le;
+        /* BR  */ buf.channels[5][i] = re;
+        if (OutChannelCount > 6) {
+            /* SL */ buf.channels[6][i] = le;
+            /* SR */ buf.channels[7][i] = re;
+        }
+    }
+}
+
+static void AccumulateReverbInput(
+    DspSubframe& dstL, DspSubframe& dstR,
+    const DspSubframe& srcL, const DspSubframe& srcR,
+    f32 gain)
+{
+    for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+        dstL[j] += srcL[j] * gain;
+        dstR[j] += srcR[j] * gain;
+    }
+}
+
+void dusk::audio::DspInit() {
+    SharedReverb.setwet(1.0f);
+    SharedReverb.setdry(0.0f);
+    SharedReverb.setroomsize(0.5f);
+    SharedReverb.setdamp(0.7f);
+    SharedReverb.setwidth(1.0f);
+    SharedReverb.setmode(0.0f);
+    SharedReverb.mute();
+}
+
+void dusk::audio::DspRender(OutputSubframe& subframe) {
+    ZoneScoped;
+    if (DumpAudio != sDumpWasActive) {
+        sDumpWasActive = DumpAudio;
+        if (DumpAudio) {
+            OpenChannelDumpFiles();
+        } else {
+            CloseChannelDumpFiles();
+        }
+    }
+
+    GenerateEvolvingHarmonic();
+
+    std::span voices(JASDsp::CH_BUF, DSP_CHANNELS);
+
+    DspSubframe reverbInputL = {};
+    DspSubframe reverbInputR = {};
+    bool anyReverbInput = false;
+
+    DspSubframe surroundBus = {};
+    bool anySurroundInput = false;
+
+    for (int i = 0; i < voices.size(); i++) {
+        auto& voice = voices[i];
+        auto& aux = ChannelAux[i];
+
+        if (!voice.mIsActive) {
+            continue;
+        }
+        else if (voice.mPauseFlag) {
+            // Not really sure what the practical difference between pause and
+            // deactivation is. Either avoids clearing state or allows the DSP to avoid popping?
+            continue;
+        }
+        else if (voice.mForcedStop) {
+            voice.mIsFinished = true;
+            continue;
+        }
+
+        DspSubframe monoBuf = {};
+        if (voice.mWaveAramAddress == 0) {
+            RenderOscChannel(voice, aux, monoBuf);
+        } else {
+            ValidateChannel(voice);
+            RenderChannel(voice, aux, monoBuf);
+        }
+
+        OutputSubframe buf = {};
+        ApplyPanning(voice, aux, monoBuf, buf);
+
+        if (EnableReverb) {
+            // scale the input to the reverb rather than using wet/dry on the output.
+            // this way the reverb's internal buffers accumulate energy proportional to mAutoMixerFxMix,
+            // so any tail always decays at the correct level regardless of mAutoMixerFxMix changes
+            // prevents transients when the next sound starts playing with a different reverb level
+            // 600.0f was pulled out of my ass and just sounds good enough for console
+            f32 inputGain = (voice.mAutoMixerFxMix >> 8) / 600.0f;
+            if (inputGain > 0) {
+                anyReverbInput = true;
+                if (OutChannelCount > 2) {
+                    OutputSubframe downmix;
+                    DownmixSurroundToStereo(buf, downmix);
+                    AccumulateReverbInput(reverbInputL, reverbInputR, downmix.channels[0], downmix.channels[1], inputGain);
+                } else {
+                    AccumulateReverbInput(reverbInputL, reverbInputR, buf.channels[0], buf.channels[1], inputGain);
+                }
+            }
+        }
+
+        if (EnableHrtf && voice.mAutoMixerBeenSet) {
+            f32 dolby = (voice.mAutoMixerPanDolby & 0xFF) / 127.0f;
+            if (dolby > 0.0f) {
+                anySurroundInput = true;
+                f32 extract = dolby * HRTF_EXTRACT_MAX;
+                f32 frontScale = 1.0f - extract;
+                for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+                    f32 mono = (buf.channels[0][j] + buf.channels[1][j]) * 0.5f;
+                    surroundBus[j] += mono * extract;
+                    buf.channels[0][j] *= frontScale;
+                    buf.channels[1][j] *= frontScale;
+                }
+            }
+        }
+
+        if (DumpAudio && sChannelDumpFiles[i]) {
+            f32 interleaved[DSP_SUBFRAME_SIZE * 2];
+            for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+                interleaved[j * 2 + 0] = buf.channels[0][j];
+                interleaved[j * 2 + 1] = buf.channels[1][j];
+            }
+            fwrite(interleaved, sizeof(f32), DSP_SUBFRAME_SIZE * 2, sChannelDumpFiles[i]);
+        }
+
+        MixOutputSubframe(subframe, buf);
+    }
+
+    if (EnableReverb && (anyReverbInput || ReverbHasTail)) {
+        // Equivalent to -80 dBFS: rms = 1e-4, rms^2 = 1e-8, sumSq = 2 * N * 1e-8
+        constexpr f32 REVERB_ENERGY_EPSILON = 2.0f * DSP_SUBFRAME_SIZE * 1e-8f;
+        f32 wetEnergy = 0.0f;
+        if (OutChannelCount > 2) {
+            OutputSubframe reverbOut;
+            wetEnergy = SharedReverb.processreplace(
+                reverbInputL.data(), reverbInputR.data(),
+                reverbOut.channels[0].data(), reverbOut.channels[1].data(),
+                DSP_SUBFRAME_SIZE, 1, 1.0f
+            );
+            UpmixStereoToSurroundInplace(reverbOut);
+            MixOutputSubframe(subframe, reverbOut);
+        } else {
+            wetEnergy = SharedReverb.processmix(
+                reverbInputL.data(), reverbInputR.data(),
+                subframe.channels[0].data(), subframe.channels[1].data(),
+                DSP_SUBFRAME_SIZE, 1, 1.0f
+            );
+        }
+        ReverbHasTail = wetEnergy >= REVERB_ENERGY_EPSILON;
+    }
+
+    if (EnableHrtf && anySurroundInput) {
+        // Two-pole LPF: -12 dB/oct above 3 kHz
+        for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+            sHrtfLp1 = (1.0f - HRTF_LP_K) * sHrtfLp1 + HRTF_LP_K * surroundBus[j];
+            sHrtfLp2 = (1.0f - HRTF_LP_K) * sHrtfLp2 + HRTF_LP_K * sHrtfLp1;
+            surroundBus[j] = sHrtfLp2;
+        }
+
+        // Mix into L and R
+        // L gets the filtered signal directly; R gets it allpass for mild decorrelation
+        for (int j = 0; j < DSP_SUBFRAME_SIZE; j++) {
+            f32 s = surroundBus[j];
+
+            subframe.channels[0][j] += s * HrtfGain;
+
+            f32 r = -HRTF_ALLPASS_G * s + sHrtfApIn1 + HRTF_ALLPASS_G * sHrtfApOut1;
+            sHrtfApIn1  = s;
+            sHrtfApOut1 = r;
+            subframe.channels[1][j] += r * HrtfGain;
+        }
+    }
+
+    for (int i = 0; i < OutChannelCount; i++) {
+        auto& channel = subframe.channels[i];
+        ApplyVolume(channel, channel, PrevMasterVolume, MasterVolume);
+    }
+    PrevMasterVolume = MasterVolume;
+}
diff --git a/src/dusk/audio/DuskDsp.hpp b/src/dusk/audio/DuskDsp.hpp
index cfcbfe3f46..bef422b956 100644
--- a/src/dusk/audio/DuskDsp.hpp
+++ b/src/dusk/audio/DuskDsp.hpp
@@ -1,22 +1,27 @@
 #pragma once
+// ReSharper disable once CppUnusedIncludeDirective
+#include "global.h"
 
 #include "JSystem/JAudio2/JASDSPInterface.h"
 
+#include <SDL3/SDL_audio.h>
+
 #include <array>
 #include <cassert>
 
-#include "SDL3/SDL_audio.h"
-#include <span>
-
-// ReSharper disable once CppUnusedIncludeDirective
-#include "global.h"
-
 namespace dusk::audio {
     constexpr int SampleRate = 32000;
 
     enum class OutputChannel : u8 {
-        LEFT,
-        RIGHT,
+        // same as SDL channel layout for 7.1
+        FRONT_LEFT,
+        FRONT_RIGHT,
+        FRONT_CENTER,
+        LFE,
+        REAR_LEFT,
+        REAR_RIGHT,
+        SURROUND_LEFT,
+        SURROUND_RIGHT,
         OutputChannel_MAX
     };
 
@@ -123,16 +128,11 @@ namespace dusk::audio {
         return channel.mBytesPerBlock;
     }
 
-    /**
-     * Apply a volume level to audio data.
-     * Interpolates across the two provided volume levels to avoid clicking.
-     */
-    void ApplyVolume(std::span<f32> dst, std::span<f32> src, f32 startVolume, f32 endVolume);
-
     extern f32 MasterVolume;
     extern f32 PrevMasterVolume;
     extern bool EnableReverb;
     extern bool DumpAudio;
     extern bool EnableHrtf;
     extern f32 HrtfGain;
+    extern u8 OutChannelCount;
 }
diff --git a/src/dusk/audio/JASCriticalSection.cpp b/src/dusk/audio/JASCriticalSection.cpp
index 9baf2d9bac..73a2671630 100644
--- a/src/dusk/audio/JASCriticalSection.cpp
+++ b/src/dusk/audio/JASCriticalSection.cpp
@@ -1,8 +1,8 @@
 #include "JSystem/JAudio2/JASCriticalSection.h"
 
-#include <mutex>
+#include <tracy/Tracy.hpp>
 
-#include "tracy/Tracy.hpp"
+#include <mutex>
 
 static TracyLockable(std::recursive_mutex, gAudioThreadMutex);
 
diff --git a/src/dusk/autosave.cpp b/src/dusk/autosave.cpp
index 57488a27a1..e53395d9b6 100644
--- a/src/dusk/autosave.cpp
+++ b/src/dusk/autosave.cpp
@@ -1,6 +1,12 @@
 #include "dusk/autosave.h"
+
 #include "dusk/ui/ui.hpp"
 #include "imgui/ImGuiConsole.hpp"
+#include "mods/svc/save.hpp"
+
+#include "d/actor/d_a_alink.h"
+#include "m_Do/m_Do_MemCard.h"
+#include "m_Do/m_Do_MemCardRWmng.h"
 
 bool shouldAutoSave = false;
 u8 mSaveBuffer[QUEST_LOG_SIZE * 3];
@@ -105,6 +111,9 @@ void waitingForWrite() {
 }
 
 void endAutoSave() {
+    const int slot = dComIfGs_getDataNum();
+    dusk::mods::svc::save_slot_written(slot, mSaveBuffer + slot * QUEST_LOG_SIZE);
+
     dusk::ui::push_toast({
         .type = "autosave",
         .duration = std::chrono::milliseconds(1500),
@@ -114,4 +123,4 @@ void endAutoSave() {
 
 void toggleAutoSave(bool enabled) {
     shouldAutoSave = enabled;
-}
\ No newline at end of file
+}
diff --git a/include/dusk/autosave.h b/src/dusk/autosave.h
similarity index 57%
rename from include/dusk/autosave.h
rename to src/dusk/autosave.h
index c32cd1e22b..d9e83b442a 100644
--- a/include/dusk/autosave.h
+++ b/src/dusk/autosave.h
@@ -1,12 +1,5 @@
 #pragma once
 
-#ifndef AUTOSAVE_H
-#define AUTOSAVE_H
-
-#include <m_Do/m_Do_MemCardRWmng.h>
-#include <m_Do/m_Do_MemCard.h>
-#include <d/actor/d_a_alink.h>
-
 void noAutoSave();
 void triggerAutoSave();
 void updateAutoSave();
@@ -15,5 +8,3 @@ void autoSaving();
 void waitingForWrite();
 void endAutoSave();
 void toggleAutoSave(bool enabled);
-
-#endif
\ No newline at end of file
diff --git a/src/dusk/camera_operators.hpp b/src/dusk/camera_operators.hpp
new file mode 100644
index 0000000000..c4ba650dfd
--- /dev/null
+++ b/src/dusk/camera_operators.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+class dCamera_c;
+
+namespace dusk::mods {
+
+bool camera_run_operators(dCamera_c* camera);
+
+}  // namespace dusk::mods
diff --git a/src/dusk/commands.cpp b/src/dusk/commands.cpp
new file mode 100644
index 0000000000..b4267700da
--- /dev/null
+++ b/src/dusk/commands.cpp
@@ -0,0 +1,882 @@
+#include "commands.hpp"
+
+#include "game_clock.h"
+
+#include "c/c_damagereaction.h"
+#include "d/actor/d_a_alink.h"
+#include "d/d_camera.h"
+#include "d/d_com_inf_actor.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_kankyo.h"
+#include "d/d_stage.h"
+#include "f_op/f_op_actor_mng.h"
+#include "f_pc/f_pc_layer.h"
+#include "f_pc/f_pc_layer_iter.h"
+#include "f_pc/f_pc_manager.h"
+#include "f_pc/f_pc_node.h"
+
+#include "JSystem/JUtility/JUTGamePad.h"
+#include "SSystem/SComponent/c_math.h"
+#include "SSystem/SComponent/c_sxyz.h"
+#include "SSystem/SComponent/c_xyz.h"
+
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk {
+namespace {
+
+static constexpr int kMaxHistory = 64;
+
+static std::vector<std::string> SplitArgs(std::string_view input) {
+    std::vector<std::string> args;
+    std::string cur;
+    for (char c : input) {
+        if (c == ' ' || c == '\t') {
+            if (!cur.empty()) {
+                args.push_back(std::move(cur));
+                cur.clear();
+            }
+        } else {
+            cur += c;
+        }
+    }
+    if (!cur.empty()) {
+        args.push_back(std::move(cur));
+    }
+    return args;
+}
+
+static std::optional<long> ParseLong(const std::string& s) {
+    if (s.empty()) {
+        return std::nullopt;
+    }
+    char* end = nullptr;
+    const long v = std::strtol(s.c_str(), &end, 0);
+    return (end != s.c_str() && *end == '\0') ? std::optional<long>{v} : std::nullopt;
+}
+
+static std::optional<float> ParseFloat(const std::string& s) {
+    if (s.empty()) {
+        return std::nullopt;
+    }
+    char* end = nullptr;
+    const float v = std::strtof(s.c_str(), &end);
+    return (end != s.c_str() && *end == '\0') ? std::optional<float>{v} : std::nullopt;
+}
+
+static const char* ActorShortName(s16 profname) {
+    const char* n = dStage_getName(profname, -1);
+    return n ? n : "?";
+}
+
+// Resolves @found / @link / @<id> to a process pointer, outputting an error on failure
+static base_process_class* ParseProcArg(
+    const std::string& s, unsigned int foundProcId, const CommandOutput& output) {
+    if (s.empty() || s[0] != '@') {
+        output("Error: proc reference must start with @");
+        return nullptr;
+    }
+    const std::string inner = s.substr(1);
+    unsigned int id;
+    if (inner == "found") {
+        if (foundProcId == 0) {
+            output("Error: @found is not set");
+            return nullptr;
+        }
+        id = foundProcId;
+    } else if (inner == "link") {
+        auto* player = dComIfGp_getPlayer(0);
+        if (player == nullptr) {
+            output("Error: player not available");
+            return nullptr;
+        }
+        id = (unsigned int)fpcM_GetID(player);
+    } else {
+        const auto v = ParseLong(inner);
+        if (!v) {
+            output("Error: invalid proc ID");
+            return nullptr;
+        }
+        id = (unsigned int)*v;
+    }
+    auto* proc = fpcM_SearchByID(id);
+    if (proc == nullptr) {
+        output(fmt::format(FMT_STRING("Error: proc {} not found"), id));
+        return nullptr;
+    }
+    return proc;
+}
+
+// Like ParseProcArg but ensures the proc is an actor
+static fopAc_ac_c* ParseActorArg(
+    const std::string& s, unsigned int foundProcId, const CommandOutput& output) {
+    auto* proc = ParseProcArg(s, foundProcId, output);
+    if (proc == nullptr) {
+        return nullptr;
+    }
+    if (!fopAcM_IsActor(proc)) {
+        output("Error: proc is not an actor");
+        return nullptr;
+    }
+    return static_cast<fopAc_ac_c*>(proc);
+}
+
+static std::optional<s16> ParseActorId(const std::string& s) {
+    if (const auto v = ParseLong(s)) {
+        return (s16)*v;
+    }
+    const auto* entry = dStage_searchNameCI(s.c_str());
+    return entry ? std::optional<s16>{entry->procname} : std::nullopt;
+}
+
+static std::optional<cXyz> ParseXYZ(const std::vector<std::string>& args, size_t i) {
+    const auto x = ParseFloat(args[i]), y = ParseFloat(args[i + 1]), z = ParseFloat(args[i + 2]);
+    return (x && y && z) ? std::optional<cXyz>{cXyz(*x, *y, *z)} : std::nullopt;
+}
+
+static bool TryAngle(
+    s16& out, const std::vector<std::string>& args, size_t i, const CommandOutput& output) {
+    if (args.size() <= i) {
+        return true;
+    }
+    const auto a = ParseLong(args[i]);
+    if (!a) {
+        output("Error: invalid angle");
+        return false;
+    }
+    out = (s16)*a;
+    return true;
+}
+
+static std::string actorLine(const base_process_class* proc) {
+    const auto* ac = static_cast<const fopAc_ac_c*>(proc);
+    return fmt::format(FMT_STRING("procId={} 0x{:04X} ({}) @ ({:.2f}, {:.2f}, {:.2f}) room={}"),
+        (unsigned int)proc->id, (unsigned int)(u16)proc->profname, ActorShortName(proc->profname),
+        ac->current.pos.x, ac->current.pos.y, ac->current.pos.z, (int)ac->current.roomNo);
+}
+
+static void recurseLayer(void* p, int (*callback)(void*, void*), void* ctx) {
+    auto* proc = static_cast<base_process_class*>(p);
+    if (fpcBs_Is_JustOfType(g_fpcNd_type, proc->subtype)) {
+        fpcLyIt_OnlyHere(&static_cast<process_node_class*>(p)->layer, callback, ctx);
+    }
+}
+
+struct ListContext {
+    s16 targetId;
+    std::vector<std::string>* output;
+};
+struct FindContext {
+    s16 targetId;
+    std::vector<base_process_class*> matches;
+};
+
+static int ListActorCallback(void* p, void* ctx) {
+    auto* proc = static_cast<base_process_class*>(p);
+    auto* context = static_cast<ListContext*>(ctx);
+    if (fopAcM_IsActor(proc) && (context->targetId < 0 || proc->profname == context->targetId)) {
+        context->output->push_back("  " + actorLine(proc));
+    }
+    recurseLayer(p, ListActorCallback, ctx);
+    return 1;
+}
+
+static int FindActorCallback(void* p, void* ctx) {
+    auto* proc = static_cast<base_process_class*>(p);
+    auto* context = static_cast<FindContext*>(ctx);
+    if (fopAcM_IsActor(proc) && proc->profname == context->targetId) {
+        context->matches.push_back(proc);
+    }
+    recurseLayer(p, FindActorCallback, ctx);
+    return 1;
+}
+
+struct CameraFlyState {
+    bool active    = false;
+    cXyz startEye;
+    cXyz startCenter;
+    cXyz endEye;
+    cXyz endCenter;
+    float duration = 0.0f;
+    float elapsed  = 0.0f;
+};
+CameraFlyState s_cameraFly;
+
+static dCamera_c* getCamera() { return dCam_getBody(); }
+
+static cXyz anglesToDir(s16 h, s16 v) {
+    return cXyz(cM_scos(v) * cM_ssin(h), cM_ssin(v), cM_scos(v) * cM_scos(h));
+}
+
+static void cameraToAngles(dCamera_c* cam, s16& h, s16& v) {
+    const cXyz eye = cam->iEye();
+    const cXyz ctr = cam->iCenter();
+    const float dx = ctr.x - eye.x;
+    const float dy = ctr.y - eye.y;
+    const float dz = ctr.z - eye.z;
+    const float hDist = sqrtf(dx * dx + dz * dz);
+    h = cM_atan2s(dx, dz);
+    v = cM_atan2s(dy, hDist);
+}
+
+static float smoothstep(float t) {
+    t = std::clamp(t, 0.0f, 1.0f);
+    return t * t * (3.0f - 2.0f * t);
+}
+
+static constexpr float kCamTargetDist = 100.0f;
+
+}  // namespace
+
+bool isCameraDetached() { return s_cameraFly.active; }
+
+void processCameraCommands() {
+    if (!s_cameraFly.active) { return; }
+    dCamera_c* cam = getCamera();
+    if (cam == nullptr) { s_cameraFly.active = false; return; }
+
+    cXyz eye, center;
+
+    if (s_cameraFly.duration <= 0.0f) {
+        eye    = s_cameraFly.endEye;
+        center = s_cameraFly.endCenter;
+    } else {
+        s_cameraFly.elapsed += dusk::game_clock::kSimPeriod;
+        const float t = smoothstep(s_cameraFly.elapsed / s_cameraFly.duration);
+        eye    = s_cameraFly.startEye    + (s_cameraFly.endEye    - s_cameraFly.startEye)    * t;
+        center = s_cameraFly.startCenter + (s_cameraFly.endCenter - s_cameraFly.startCenter) * t;
+
+        if (s_cameraFly.elapsed >= s_cameraFly.duration) {
+            eye    = s_cameraFly.endEye;
+            center = s_cameraFly.endCenter;
+            s_cameraFly.startEye    = s_cameraFly.endEye;
+            s_cameraFly.startCenter = s_cameraFly.endCenter;
+            s_cameraFly.duration    = 0.0f;
+        }
+    }
+
+    cam->Reset(center, eye);
+    cam->mDebugFlyCam.initialized = false;
+}
+
+void runCommand(std::string_view cmdLine, CommandState& state, const CommandOutput& output) {
+    if (state.echoEnabled) {
+        output(fmt::format(FMT_STRING("> {}"), cmdLine));
+    }
+
+    if (!cmdLine.empty()) {
+        if (state.history.empty() || state.history.back() != cmdLine) {
+            state.history.push_back(std::string(cmdLine));
+            if ((int)state.history.size() > kMaxHistory) {
+                state.history.erase(state.history.begin());
+            }
+        }
+    }
+
+    auto args = SplitArgs(cmdLine);
+    if (args.empty()) {
+        return;
+    }
+    const auto& cmd = args[0];
+
+    auto requirePlayer = [&]() -> daAlink_c* {
+        auto* p = (daAlink_c*)dComIfGp_getPlayer(0);
+        if (p == nullptr) {
+            output("Error: player not available");
+        }
+        return p;
+    };
+
+    if (cmd == "tp") {
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+
+        if (args.size() >= 2 && args[1].starts_with('@')) {
+            auto* ac = ParseActorArg(args[1], state.foundProcId, output);
+            if (ac == nullptr) {
+                return;
+            }
+
+            if (args.size() >= 3 && args[2].starts_with('@')) {
+                auto* destAc = ParseActorArg(args[2], state.foundProcId, output);
+                if (destAc == nullptr) {
+                    return;
+                }
+                const cXyz destPos = destAc->current.pos;
+                ac->current.pos = destPos;
+                output(fmt::format(FMT_STRING("Moved actor {} to ({:.2f}, {:.2f}, {:.2f})"), ac->id,
+                    destPos.x, destPos.y, destPos.z));
+                return;
+            }
+
+            if (args.size() >= 5) {
+                const auto pos = ParseXYZ(args, 2);
+                if (!pos) {
+                    output("Error: invalid coordinates");
+                    return;
+                }
+                ac->current.pos = *pos;
+                if (!TryAngle(ac->shape_angle.y, args, 5, output)) {
+                    return;
+                }
+                output(fmt::format(FMT_STRING("Moved actor {} to ({:.2f}, {:.2f}, {:.2f})"), ac->id,
+                    pos->x, pos->y, pos->z));
+                return;
+            }
+
+            player->current.pos = ac->current.pos;
+            output(fmt::format(FMT_STRING("Teleported to actor {} ({:.2f}, {:.2f}, {:.2f})"),
+                ac->id, ac->current.pos.x, ac->current.pos.y, ac->current.pos.z));
+            return;
+        }
+
+        if (args.size() < 4) {
+            output("Usage: tp <x> <y> <z> [angle]  |  tp @<procId> [<x> <y> <z> [angle] | @link]");
+            return;
+        }
+        const auto pos = ParseXYZ(args, 1);
+        if (!pos) {
+            output("Error: invalid coordinates");
+            return;
+        }
+        player->current.pos = *pos;
+        if (!TryAngle(player->shape_angle.y, args, 4, output)) {
+            return;
+        }
+        output(fmt::format(
+            FMT_STRING("Teleported to ({:.2f}, {:.2f}, {:.2f})"), pos->x, pos->y, pos->z));
+        return;
+    }
+
+    if (cmd == "spawn") {
+        if (args.size() < 2) {
+            output("Usage: spawn <actorId> [params] [x y z] [angle]");
+            return;
+        }
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+
+        const auto actorId = ParseActorId(args[1]);
+        if (!actorId) {
+            output("Error: unknown actor ID or name");
+            return;
+        }
+
+        long paramsL = -1;
+        if (args.size() >= 3) {
+            const auto p = ParseLong(args[2]);
+            if (!p) {
+                output("Error: invalid params");
+                return;
+            }
+            paramsL = *p;
+        }
+
+        cXyz pos = player->current.pos;
+        if (args.size() >= 6) {
+            const auto spawnPos = ParseXYZ(args, 3);
+            if (!spawnPos) {
+                output("Error: invalid spawn coordinates");
+                return;
+            }
+            pos = *spawnPos;
+        }
+
+        s16 angleY = 0;
+        if (!TryAngle(angleY, args, 6, output)) {
+            return;
+        }
+        csXyz angle;
+        angle.set(0, angleY, 0);
+        cXyz scale(1.0f, 1.0f, 1.0f);
+
+        layer_class* savedLayer = fpcLy_CurrentLayer();
+        base_process_class* playScene = fpcM_SearchByName(fpcNm_PLAY_SCENE_e);
+        if (playScene != nullptr) {
+            fpcLy_SetCurrentLayer(&((process_node_class*)playScene)->layer);
+        }
+        unsigned int result = fopAcM_create(
+            *actorId, (u32)paramsL, &pos, player->current.roomNo, &angle, &scale, (s8)-1);
+        fpcLy_SetCurrentLayer(savedLayer);
+
+        output(result != 0 ? fmt::format(FMT_STRING("Spawned actorId=0x{:04X} procId={}"),
+                                 (unsigned int)(u16)*actorId, result) :
+                             fmt::format(FMT_STRING("Failed to spawn actorId=0x{:04X}"),
+                                 (unsigned int)(u16)*actorId));
+        return;
+    }
+
+    if (cmd == "reset") {
+        JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
+        output("Soft reset triggered");
+        return;
+    }
+
+    if (cmd == "warp") {
+        if (args.size() < 4) {
+            output("Usage: warp <stageName> <point> <roomNo> [layer=-1]");
+            output("  e.g.  warp F_SP121 0 0");
+            return;
+        }
+        const auto pointL = ParseLong(args[2]), roomL = ParseLong(args[3]);
+        if (!pointL || !roomL) {
+            output("Error: invalid point or room number");
+            return;
+        }
+        long layerL = -1;
+        if (args.size() >= 5) {
+            const auto l = ParseLong(args[4]);
+            if (!l) {
+                output("Error: invalid layer");
+                return;
+            }
+            layerL = *l;
+        }
+        state.lastWarpStage = args[1];
+        dComIfGp_setNextStage(state.lastWarpStage.c_str(), (s16)*pointL, (s8)*roomL, (s8)layerL);
+        output(fmt::format(FMT_STRING("Warping to {} point={} room={} layer={}"), args[1],
+            (int)(s16)*pointL, (int)(s8)*roomL, (int)(s8)layerL));
+        return;
+    }
+
+    if (cmd == "list") {
+        s16 targetId = -1;
+        if (args.size() >= 2) {
+            const auto id = ParseActorId(args[1]);
+            if (!id) {
+                output("Error: unknown actor ID or name");
+                return;
+            }
+            targetId = *id;
+        }
+        std::vector<std::string> results;
+        ListContext ctx{targetId, &results};
+        fpcLyIt_OnlyHere(fpcLy_RootLayer(), ListActorCallback, &ctx);
+        output(results.empty() ? "No matching actors found" :
+                                 fmt::format(FMT_STRING("Found {} actor(s):"), results.size()));
+        for (const auto& r : results) {
+            output(r);
+        }
+        return;
+    }
+
+    if (cmd == "killall") {
+        if (args.size() < 2) {
+            output("Usage: killall <actorId|name>");
+            return;
+        }
+        const auto targetId = ParseActorId(args[1]);
+        if (!targetId) {
+            output("Error: unknown actor ID or name");
+            return;
+        }
+        FindContext ctx{*targetId, {}};
+        fpcLyIt_OnlyHere(fpcLy_RootLayer(), FindActorCallback, &ctx);
+        for (auto* proc : ctx.matches) {
+            fpcM_Delete(proc);
+        }
+        output(fmt::format(FMT_STRING("Deleted {} actor(s) of type {} ({})"),
+            (int)ctx.matches.size(), (unsigned int)(u16)*targetId, ActorShortName(*targetId)));
+        return;
+    }
+
+    if (cmd == "heal") {
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+        const u16 maxLife = dComIfGs_getMaxLife() / 5 * 4;
+        u16 newLife = maxLife;
+        if (args.size() >= 2) {
+            const auto amount = ParseLong(args[1]);
+            if (!amount) {
+                output("Error: invalid amount");
+                return;
+            }
+            newLife =
+                (u16)std::max(0L, std::min((long)maxLife, (long)dComIfGs_getLife() + *amount));
+        }
+        dComIfGs_setLife(newLife);
+        output(fmt::format(FMT_STRING("Health: {}/{}"), (int)newLife, (int)maxLife));
+        return;
+    }
+
+    if (cmd == "kill") {
+        if (args.size() >= 2) {
+            auto* proc = ParseProcArg(args[1], state.foundProcId, output);
+            if (proc == nullptr) {
+                return;
+            }
+            fpcM_Delete(proc);
+            output(fmt::format(FMT_STRING("Deleted proc {}"), proc->id));
+        } else {
+            auto* player = requirePlayer();
+            if (player == nullptr) {
+                return;
+            }
+            dComIfGs_setLife(0);
+            output("Set Link's health to 0");
+        }
+        return;
+    }
+
+    if (cmd == "freeze" || cmd == "unfreeze") {
+        const bool doFreeze = (cmd == "freeze");
+        if (args.size() < 2) {
+            g_dComIfAc_gameInfo.mPause = doFreeze;
+            output(doFreeze ? "Global freeze on" : "Global freeze off");
+            return;
+        }
+        auto* ac = ParseActorArg(args[1], state.foundProcId, output);
+        if (ac == nullptr) {
+            return;
+        }
+        if (doFreeze) {
+            fpcM_PauseEnable(ac, 1);
+            output(fmt::format(FMT_STRING("Froze actor {}"), (unsigned int)ac->id));
+        } else {
+            fpcM_PauseDisable(ac, 1);
+            output(fmt::format(FMT_STRING("Unfroze actor {}"), (unsigned int)ac->id));
+        }
+        return;
+    }
+
+    if (cmd == "rate") {
+        if (args.size() >= 2) {
+            const auto hz = ParseLong(args[1]);
+            if (!hz || *hz <= 0) {
+                output("Error: rate must be a positive integer");
+                return;
+            }
+            dusk::game_clock::set_sim_rate((float)*hz);
+        }
+        output(fmt::format(FMT_STRING("Sim rate: {:.0f} hz"), dusk::game_clock::get_sim_rate()));
+        return;
+    }
+
+    if (cmd == "ebf") {
+        if (args.size() >= 2) {
+            const auto val = ParseLong(args[1]);
+            if (!val || *val < 0 || *val > 255) {
+                output("Error: value must be 0-255");
+                return;
+            }
+            cDmr_SkipInfo = (u8)*val;
+        }
+        output(fmt::format(FMT_STRING("EBF = {}"), (int)cDmr_SkipInfo));
+        return;
+    }
+
+    if (cmd == "time") {
+        if (args.size() >= 2) {
+            const auto t = ParseFloat(args[1]);
+            if (!t || *t < 0.0f || *t > 360.0f) {
+                output("Error: time must be a float between 0 and 360");
+                return;
+            }
+            dKy_instant_timechg(*t);
+        }
+        output(fmt::format(FMT_STRING("Time: {:.2f} ({}:{:02d})"), dComIfGs_getTime(),
+            dKy_getdaytime_hour(), dKy_getdaytime_minute()));
+        return;
+    }
+
+    if (cmd == "rupees") {
+        const u16 maxRupees = dComIfGs_getRupeeMax();
+        if (args.size() >= 2) {
+            const auto amount = ParseLong(args[1]);
+            if (!amount) {
+                output("Error: invalid amount");
+                return;
+            }
+            dComIfGs_setRupee((u16)std::max(0L, std::min((long)maxRupees, *amount)));
+        }
+        output(fmt::format(FMT_STRING("Rupees: {}/{}"), (int)dComIfGs_getRupee(), (int)maxRupees));
+        return;
+    }
+
+    if (cmd == "find") {
+        if (args.size() < 2) {
+            if (state.foundProcId == 0) {
+                output("@found is not set");
+                return;
+            }
+            auto* proc = fpcM_SearchByID(state.foundProcId);
+            output(proc != nullptr && fopAcM_IsActor(proc) ?
+                       "@found = " + actorLine(proc) :
+                       fmt::format(FMT_STRING("@found = {} (no longer exists)"),
+                           (unsigned int)state.foundProcId));
+            return;
+        }
+
+        const auto targetId = ParseActorId(args[1]);
+        if (!targetId) {
+            output("Error: unknown actor ID or name");
+            return;
+        }
+
+        int targetN = 1;
+        if (args.size() >= 3) {
+            const auto n = ParseLong(args[2]);
+            if (!n || *n < 1) {
+                output("Error: index must be >= 1");
+                return;
+            }
+            targetN = (int)*n;
+        }
+
+        FindContext ctx{*targetId, {}};
+        fpcLyIt_OnlyHere(fpcLy_RootLayer(), FindActorCallback, &ctx);
+
+        if (ctx.matches.empty()) {
+            output(fmt::format(FMT_STRING("No actors found for '{}'"), args[1]));
+            return;
+        }
+
+        std::sort(ctx.matches.begin(), ctx.matches.end(),
+            [](const base_process_class* a, const base_process_class* b) { return a->id < b->id; });
+
+        if (targetN > (int)ctx.matches.size()) {
+            output(fmt::format(
+                FMT_STRING("Error: only {} actor(s) of that type exist"), (int)ctx.matches.size()));
+            return;
+        }
+
+        auto* picked = ctx.matches[(size_t)(targetN - 1)];
+        state.foundProcId = picked->id;
+        output(fmt::format(
+            FMT_STRING("@found [{}/{}] {}"), targetN, (int)ctx.matches.size(), actorLine(picked)));
+        return;
+    }
+
+    if (cmd == "camera") {
+        const std::string sub = args.size() >= 2 ? args[1] : "";
+
+        if (sub == "attach") {
+            s_cameraFly.active = false;
+            output("Camera attached");
+            return;
+        }
+
+        auto* cam = getCamera();
+        if (cam == nullptr) { output("Error: camera not available"); return; }
+
+        if (sub == "detach") {
+            s_cameraFly.active      = true;
+            s_cameraFly.duration    = 0.0f;
+            s_cameraFly.startEye    = s_cameraFly.endEye    = cam->iEye();
+            s_cameraFly.startCenter = s_cameraFly.endCenter = cam->iCenter();
+            output("Camera detached");
+            return;
+        }
+
+        if (sub == "tp") {
+            // camera tp @<ref>
+            if (args.size() >= 3 && !args[2].empty() && args[2][0] == '@') {
+                auto* ac = ParseActorArg(args[2], state.foundProcId, output);
+                if (ac == nullptr) { return; }
+                const cXyz actorPos = ac->current.pos;
+                const cXyz dir = anglesToDir(ac->shape_angle.y, 0);
+                const cXyz newEye    = cXyz(actorPos.x - dir.x * kCamTargetDist,
+                                            actorPos.y - dir.y * kCamTargetDist + 50.0f,
+                                            actorPos.z - dir.z * kCamTargetDist);
+                s_cameraFly.active = true; s_cameraFly.duration = 0.0f;
+                s_cameraFly.startEye = s_cameraFly.endEye = newEye;
+                s_cameraFly.startCenter = s_cameraFly.endCenter = actorPos;
+                    output(fmt::format(FMT_STRING("Camera moved to actor {}"), ac->id));
+                return;
+            }
+            // camera tp x y z [h] [v]
+            if (args.size() < 5) {
+                output("Usage: camera tp <x> <y> <z> [h_angle] [v_angle]  |  camera tp @<ref>");
+                return;
+            }
+            const auto pos = ParseXYZ(args, 2);
+            if (!pos) { output("Error: invalid coordinates"); return; }
+            s16 h = 0, v = 0;
+            cameraToAngles(cam, h, v);
+            if (args.size() >= 6) {
+                const auto hv = ParseLong(args[5]);
+                if (!hv) { output("Error: invalid h_angle"); return; }
+                h = (s16)*hv;
+            }
+            if (args.size() >= 7) {
+                const auto vv = ParseLong(args[6]);
+                if (!vv) { output("Error: invalid v_angle"); return; }
+                v = (s16)*vv;
+            }
+            const cXyz dir = anglesToDir(h, v);
+            const cXyz center = cXyz(pos->x + dir.x * kCamTargetDist,
+                                     pos->y + dir.y * kCamTargetDist,
+                                     pos->z + dir.z * kCamTargetDist);
+            s_cameraFly.active = true; s_cameraFly.duration = 0.0f;
+            s_cameraFly.startEye = s_cameraFly.endEye = *pos;
+            s_cameraFly.startCenter = s_cameraFly.endCenter = center;
+            output(fmt::format(FMT_STRING("Camera teleported to ({:.2f}, {:.2f}, {:.2f})"),
+                pos->x, pos->y, pos->z));
+            return;
+        }
+
+        if (sub == "pos") {
+            s16 h = 0, v = 0;
+            cameraToAngles(cam, h, v);
+            const cXyz eye = cam->iEye();
+            output(fmt::format(FMT_STRING("Camera: ({:.2f}, {:.2f}, {:.2f}) h={} v={}"),
+                eye.x, eye.y, eye.z, (int)h, (int)v));
+            return;
+        }
+
+        if (sub == "fly") {
+            // camera fly <time> <x> <y> <z> [h] [v]  |  camera fly <time> @<ref>
+            if (args.size() < 4) {
+                output("Usage: camera fly <time> <x> <y> <z> [h_angle] [v_angle]  |  camera fly <time> @<ref>");
+                return;
+            }
+            const auto t = ParseFloat(args[2]);
+            if (!t || *t <= 0) { output("Error: invalid time"); return; }
+            const float flyTime = *t;
+
+            cXyz targetPos;
+            s16 h = 0, v = 0;
+
+            if (!args[3].empty() && args[3][0] == '@') {
+                auto* ac = ParseActorArg(args[3], state.foundProcId, output);
+                if (ac == nullptr) { return; }
+                targetPos = ac->current.pos;
+                h = ac->shape_angle.y;
+                v = 0;
+            } else {
+                if (args.size() < 6) {
+                    output("Usage: camera fly <time> <x> <y> <z> [h_angle] [v_angle]  |  camera fly <time> @<ref>");
+                    return;
+                }
+                const auto pos = ParseXYZ(args, 3);
+                if (!pos) { output("Error: invalid coordinates"); return; }
+                targetPos = *pos;
+                cameraToAngles(cam, h, v);
+                if (args.size() >= 7) {
+                    const auto hv = ParseLong(args[6]); if (!hv) { output("Error: invalid h_angle"); return; } h = (s16)*hv;
+                }
+                if (args.size() >= 8) {
+                    const auto vv = ParseLong(args[7]); if (!vv) { output("Error: invalid v_angle"); return; } v = (s16)*vv;
+                }
+            }
+
+            const cXyz dir = anglesToDir(h, v);
+            const cXyz endCenter = cXyz(targetPos.x + dir.x * kCamTargetDist,
+                                        targetPos.y + dir.y * kCamTargetDist,
+                                        targetPos.z + dir.z * kCamTargetDist);
+
+            s_cameraFly.active      = true;
+            s_cameraFly.startEye    = cam->iEye();
+            s_cameraFly.startCenter = cam->iCenter();
+            s_cameraFly.endEye      = targetPos;
+            s_cameraFly.endCenter   = endCenter;
+            s_cameraFly.duration    = flyTime;
+            s_cameraFly.elapsed     = 0.0f;
+            output(fmt::format(FMT_STRING("Camera flying to ({:.2f}, {:.2f}, {:.2f}) over {:.1f}s"),
+                targetPos.x, targetPos.y, targetPos.z, flyTime));
+            return;
+        }
+
+        output("Usage: camera detach | attach | tp ... | fly ... | pos");
+        return;
+    }
+
+    if (cmd == "echo") {
+        if (args.size() >= 2 && args[1] == "off") {
+            state.echoEnabled = false;
+            output("Echo disabled");
+        } else if (args.size() >= 2 && args[1] == "on") {
+            state.echoEnabled = true;
+            output("Echo enabled");
+        } else {
+            output(state.echoEnabled ? "Echo: on" : "Echo: off");
+        }
+        return;
+    }
+
+    if (cmd == "transform") {
+        auto* player = requirePlayer();
+        if (player == nullptr) { return; }
+        player->procCoMetamorphoseInit();
+        output("Transforming");
+        return;
+    }
+
+    if (cmd == "angle") {
+        auto* player = requirePlayer();
+        if (player == nullptr) { return; }
+        if (args.size() >= 2) {
+            const auto a = ParseLong(args[1]);
+            if (!a) { output("Error: invalid angle"); return; }
+            player->shape_angle.y = (s16)*a;
+            output(fmt::format(FMT_STRING("Angle set to {}"), (int)(s16)*a));
+        } else {
+            output(fmt::format(FMT_STRING("Angle: {}"), (int)player->shape_angle.y));
+        }
+        return;
+    }
+
+    if (cmd == "pos") {
+        auto* player = requirePlayer();
+        if (player == nullptr) {
+            return;
+        }
+        output(fmt::format(FMT_STRING("pos: {:.4f} {:.4f} {:.4f}"), player->current.pos.x,
+            player->current.pos.y, player->current.pos.z));
+        output(
+            fmt::format(FMT_STRING("stage: {}  room: {}  entry: {}"), dComIfGp_getStartStageName(),
+                (int)player->current.roomNo, (int)dComIfGp_getStartStagePoint()));
+        return;
+    }
+
+    if (cmd == "help") {
+        output("@<ref>  =  @<procId> | @found | @link");
+        output("");
+        output("angle [value]                               Get or set Link's facing angle");
+        output("camera detach | attach                      Detach or reattach camera");
+        output("camera pos                                  Print camera position and angles");
+        output("camera tp <x> <y> <z> [h] [v]               Teleport camera (h/v are s16 angles)");
+        output("camera tp @<ref>                            Teleport camera to actor");
+        output("camera fly <t> <x> <y> <z> [h] [v]          Fly camera over t seconds (h/v are s16 angles)");
+        output("camera fly <t> @<ref>                       Fly camera to actor");
+        output("ebf [0-255]                                 Get or set cDmr_SkipInfo");
+        output("echo on | off                               Enable or disable command echo");
+        output("find <id|name> [n=1]                        Store nth actor as @found");
+        output("freeze [@<ref>]                             Freeze globally, or freeze actor");
+        output("heal [amount]                               Heal to max, or by relative amount");
+        output("kill                                        Set Link health to 0");
+        output("kill @<ref>                                 Delete proc");
+        output("killall <id|name>                           Delete all actors of a type");
+        output("list [id|name]                              List actors in scene");
+        output("pos                                         Print player position and stage");
+        output("rate [hz]                                   Get or set sim rate (1-480, default 30)");
+        output("reset                                       Soft reset");
+        output("rupees [amount]                             Get or set rupee count");
+        output("spawn <id|name> [params] [x y z] [angle]    Spawn actor");
+        output("time [0-360]                                Get or set time of day");
+        output("tp <x> <y> <z> [angle]                      Teleport Link to coords");
+        output("tp @<ref>                                   Teleport Link to actor");
+        output("tp @<ref> <x> <y> <z> [angle]               Move actor to coords");
+        output("tp @<ref> @<ref>                            Move actor to actor");
+        output("transform                                   Force transform");
+        output("unfreeze [@<ref>]                           Unfreeze globally, or unfreeze actor");
+        output("warp <stage> <point> <room> [layer]         Warp to stage");
+        return;
+    }
+
+    output(fmt::format(FMT_STRING("Unknown command '{}' (try 'help')"), cmd));
+}
+
+}  // namespace dusk
diff --git a/src/dusk/commands.hpp b/src/dusk/commands.hpp
new file mode 100644
index 0000000000..6c742522a5
--- /dev/null
+++ b/src/dusk/commands.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk {
+
+using CommandOutput = std::function<void(std::string)>;
+
+struct CommandState {
+    std::vector<std::string> history;
+    unsigned int foundProcId = 0;
+    std::string lastWarpStage;
+    bool echoEnabled = true;
+};
+
+// Execute a single command line. Calls output() for every line of response.
+// Manages history internally; callers need only hold a CommandState.
+void runCommand(std::string_view cmdLine, CommandState& state, const CommandOutput& output);
+
+// Per-sim-tick update for camera fly animation.
+void processCameraCommands();
+
+// Returns true when the dev camera is detached (suppresses the game's camera update).
+bool isCameraDetached();
+
+}  // namespace dusk
diff --git a/src/dusk/config.cpp b/src/dusk/config.cpp
index a2b79eaac5..1749e964d7 100644
--- a/src/dusk/config.cpp
+++ b/src/dusk/config.cpp
@@ -1,12 +1,16 @@
 #include "dusk/config.hpp"
-#include "absl/container/flat_hash_map.h"
-#include "fmt/format.h"
-#include "nlohmann/json.hpp"
 
-#include "aurora/lib/logging.hpp"
+#include "dusk/action_bindings.h"
 #include "dusk/io.hpp"
+#include "dusk/logging.h"
+#include "dusk/main.h"
 #include "dusk/settings.h"
 
+#include <absl/container/flat_hash_map.h>
+#include <borealis/io.hpp>
+#include <fmt/format.h>
+#include <nlohmann/json.hpp>
+
 #include <algorithm>
 #include <cmath>
 #include <filesystem>
@@ -18,17 +22,13 @@
 #include <utility>
 #include <vector>
 
-#include "dusk/action_bindings.h"
-#include "dusk/logging.h"
-#include "dusk/main.h"
-
 namespace dusk::config {
 namespace {
 constexpr auto ConfigFileName = "config.json";
 
 using json = nlohmann::json;
 
-aurora::Module DuskConfigLog("dusk::config");
+constexpr borealis::Log DuskConfigLog{"dusk::config"};
 
 absl::flat_hash_map<std::string, ConfigVarBase*> RegisteredConfigVars;
 absl::flat_hash_map<std::string, nlohmann::json> UnregisteredConfigVars;
@@ -316,6 +316,7 @@ template class ConfigImpl<BloomMode>;
 template class ConfigImpl<DepthOfFieldMode>;
 template class ConfigImpl<DiscVerificationState>;
 template class ConfigImpl<GameLanguage>;
+template class ConfigImpl<AudioOutputMode>;
 
 template <>
 void ConfigImpl<FrameInterpMode>::loadFromJson(
@@ -464,7 +465,7 @@ void load_from_user_preferences() {
     if (configJsonPath.empty()) {
         return;
     }
-    const auto configPathString = io::fs_path_to_string(configJsonPath);
+    const auto configPathString = borealis::io::fs_path_to_string(configJsonPath);
     load_from_file_name(configPathString.c_str());
 }
 
@@ -532,7 +533,7 @@ void save() {
     if (configJsonPath.empty()) {
         return;
     }
-    const auto configPathString = io::fs_path_to_string(configJsonPath);
+    const auto configPathString = borealis::io::fs_path_to_string(configJsonPath);
 
     DuskConfigLog.info("Saving config to '{}'", configPathString);
 
@@ -639,4 +640,4 @@ void shutdown() {
     s_activeChangeNotifications.clear();
 }
 
-}  // namespace dusk::config
\ No newline at end of file
+}  // namespace dusk::config
diff --git a/include/dusk/config.hpp b/src/dusk/config.hpp
similarity index 99%
rename from include/dusk/config.hpp
rename to src/dusk/config.hpp
index 6d36dff1f3..53591437db 100644
--- a/include/dusk/config.hpp
+++ b/src/dusk/config.hpp
@@ -1,5 +1,4 @@
-#ifndef DUSK_CONFIG_HPP
-#define DUSK_CONFIG_HPP
+#pragma once
 
 #include <concepts>
 #include <functional>
@@ -193,5 +192,3 @@ const ConfigImplBase* GetConfigImpl() {
 }
 
 }  // namespace dusk::config
-
-#endif
diff --git a/include/dusk/config_var.hpp b/src/dusk/config_var.hpp
similarity index 99%
rename from include/dusk/config_var.hpp
rename to src/dusk/config_var.hpp
index 52e62172cb..c4d3ac1d6b 100644
--- a/include/dusk/config_var.hpp
+++ b/src/dusk/config_var.hpp
@@ -1,5 +1,4 @@
-#ifndef DUSK_CONFIG_VAR_HPP
-#define DUSK_CONFIG_VAR_HPP
+#pragma once
 
 #include "dolphin/types.h"
 #include <concepts>
@@ -386,5 +385,3 @@ private:
 using ActionBindConfigVar = ConfigVar<int>;
 
 }
-
-#endif  // DUSK_CONFIG_VAR_HPP
diff --git a/src/dusk/crash_handler.cpp b/src/dusk/crash_handler.cpp
deleted file mode 100644
index b520a6ff29..0000000000
--- a/src/dusk/crash_handler.cpp
+++ /dev/null
@@ -1,965 +0,0 @@
-#if !defined(_WIN32) && !defined(_GNU_SOURCE)
-#define _GNU_SOURCE
-#endif
-
-#include "dusk/crash_handler.h"
-
-#include "dusk/logging.h"
-#include "version.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <exception>
-
-#if defined(_WIN32)
-
-#include <windows.h>
-
-#include <io.h>
-
-#if defined(DUSK_CRASH_DBGHELP)
-#include <dbghelp.h>
-#endif
-
-#else
-
-#include <csignal>
-#include <cstdlib>
-#include <dlfcn.h>
-#include <sys/ucontext.h>
-#include <unistd.h>
-#include <unwind.h>
-
-#if defined(__APPLE__)
-#include <mach-o/dyld.h>
-#include <mach-o/loader.h>
-#include <TargetConditionals.h>
-#else
-#include <elf.h>
-#include <link.h>
-#ifndef NT_GNU_BUILD_ID
-#define NT_GNU_BUILD_ID 3
-#endif
-#endif
-
-#endif
-
-#ifndef DUSK_ARCH
-#define DUSK_ARCH "unknown"
-#endif
-
-namespace dusk::crash_handler {
-namespace {
-
-constexpr int kStderrFd = 2;
-constexpr int kMaxFrames = 128;
-constexpr char kHexDigits[] = "0123456789abcdef";
-
-struct CrashContext {
-    uintptr_t moduleBase = 0;
-    char modulePath[1024] = {};
-    uint8_t buildId[64] = {};
-    unsigned buildIdLen = 0;
-    unsigned pdbAge = 0;
-};
-CrashContext g_ctx;
-
-struct ModuleInfo {
-    uintptr_t base = 0;
-    uintptr_t size = 0;
-    char path[1024] = {};
-    uint8_t buildId[64] = {};
-    unsigned buildIdLen = 0;
-    unsigned pdbAge = 0;
-};
-
-void rawWrite(int fd, const char* data, size_t len) {
-    if (fd < 0) {
-        return;
-    }
-#if defined(_WIN32)
-    _write(fd, data, static_cast<unsigned int>(len));
-#else
-    while (len > 0) {
-        const ssize_t written = ::write(fd, data, len);
-        if (written <= 0) {
-            return;
-        }
-        data += written;
-        len -= static_cast<size_t>(written);
-    }
-#endif
-}
-
-void writeStr(int fd, const char* s) {
-    if (s != nullptr) {
-        rawWrite(fd, s, std::strlen(s));
-    }
-}
-
-void writeHex(int fd, unsigned long long value) {
-    char buf[2 + 16];
-    size_t o = sizeof(buf);
-    do {
-        buf[--o] = kHexDigits[value & 0xF];
-        value >>= 4;
-    } while (value != 0);
-    buf[--o] = 'x';
-    buf[--o] = '0';
-    rawWrite(fd, buf + o, sizeof(buf) - o);
-}
-
-void writeDec(int fd, unsigned int value) {
-    char buf[10];
-    size_t o = sizeof(buf);
-    do {
-        buf[--o] = static_cast<char>('0' + value % 10);
-        value /= 10;
-    } while (value != 0);
-    rawWrite(fd, buf + o, sizeof(buf) - o);
-}
-
-void writeHexBytes(int fd, const uint8_t* data, unsigned len) {
-    char buf[2];
-    for (unsigned i = 0; i < len; ++i) {
-        buf[0] = kHexDigits[data[i] >> 4];
-        buf[1] = kHexDigits[data[i] & 0xF];
-        rawWrite(fd, buf, 2);
-    }
-}
-
-void writeHexByte(int fd, uint8_t value) {
-    char buf[2];
-    buf[0] = kHexDigits[value >> 4];
-    buf[1] = kHexDigits[value & 0xF];
-    rawWrite(fd, buf, 2);
-}
-
-void writeQuoted(int fd, const char* s) {
-    writeStr(fd, "\"");
-    if (s != nullptr) {
-        for (const char* p = s; *p != '\0'; ++p) {
-            if (*p == '"' || *p == '\\') {
-                rawWrite(fd, "\\", 1);
-            }
-            rawWrite(fd, p, 1);
-        }
-    }
-    writeStr(fd, "\"");
-}
-
-const char* baseName(const char* path) {
-    const char* name = path;
-    for (const char* p = path; p != nullptr && *p != '\0'; ++p) {
-        if (*p == '/' || *p == '\\') {
-            name = p + 1;
-        }
-    }
-    return name[0] != '\0' ? name : "(unknown)";
-}
-
-void writeBuildId(int fd, const uint8_t* buildId, unsigned buildIdLen, unsigned pdbAge) {
-    if (buildIdLen == 0) {
-        writeStr(fd, "(unavailable)");
-        return;
-    }
-#if defined(_WIN32)
-    if (buildIdLen == 16) {
-        writeHexByte(fd, buildId[3]);
-        writeHexByte(fd, buildId[2]);
-        writeHexByte(fd, buildId[1]);
-        writeHexByte(fd, buildId[0]);
-        writeStr(fd, "-");
-        writeHexByte(fd, buildId[5]);
-        writeHexByte(fd, buildId[4]);
-        writeStr(fd, "-");
-        writeHexByte(fd, buildId[7]);
-        writeHexByte(fd, buildId[6]);
-        writeStr(fd, "-");
-        writeHexByte(fd, buildId[8]);
-        writeHexByte(fd, buildId[9]);
-        writeStr(fd, "-");
-        writeHexBytes(fd, buildId + 10, 6);
-        if (pdbAge != 0) {
-            writeStr(fd, "-");
-            writeDec(fd, pdbAge);
-        }
-        return;
-    }
-#else
-    (void)pdbAge;
-#endif
-    writeHexBytes(fd, buildId, buildIdLen);
-}
-
-const char* symbolFor(uintptr_t pc, unsigned long long* disp) {
-#if defined(_WIN32) && defined(DUSK_CRASH_DBGHELP)
-    alignas(SYMBOL_INFO) static char storage[sizeof(SYMBOL_INFO) + 512];
-    auto* sym = reinterpret_cast<SYMBOL_INFO*>(storage);
-    sym->SizeOfStruct = sizeof(SYMBOL_INFO);
-    sym->MaxNameLen = 511;
-    DWORD64 d = 0;
-    if (SymFromAddr(GetCurrentProcess(), pc, &d, sym)) {
-        *disp = d;
-        return sym->Name;
-    }
-    return nullptr;
-#elif defined(_WIN32)
-    (void)pc;
-    (void)disp;
-    return nullptr;
-#else
-    Dl_info info;
-    if (dladdr(reinterpret_cast<void*>(pc), &info) != 0 && info.dli_sname != nullptr) {
-        const auto base = reinterpret_cast<uintptr_t>(info.dli_saddr);
-        *disp = pc >= base ? pc - base : 0;
-        return info.dli_sname;
-    }
-    return nullptr;
-#endif
-}
-
-void fallbackModuleInfo(ModuleInfo& info) {
-    info = {};
-    info.base = g_ctx.moduleBase;
-    std::strncpy(info.path, g_ctx.modulePath, sizeof(info.path) - 1);
-    if (g_ctx.buildIdLen > sizeof(info.buildId)) {
-        info.buildIdLen = sizeof(info.buildId);
-    } else {
-        info.buildIdLen = g_ctx.buildIdLen;
-    }
-    if (info.buildIdLen != 0) {
-        std::memcpy(info.buildId, g_ctx.buildId, info.buildIdLen);
-    }
-    info.pdbAge = g_ctx.pdbAge;
-}
-
-bool findModuleInfo(uintptr_t pc, ModuleInfo& info);
-
-void emitAddressDetail(int fd, uintptr_t pc) {
-    ModuleInfo info;
-    findModuleInfo(pc, info);
-    const uintptr_t rva = pc >= info.base ? pc - info.base : 0ull;
-    writeHex(fd, pc);
-    writeStr(fd, " module_base=");
-    writeHex(fd, info.base);
-    if (info.size != 0) {
-        writeStr(fd, " image_size=");
-        writeHex(fd, info.size);
-    }
-    writeStr(fd, " rva=");
-    writeHex(fd, rva);
-    writeStr(fd, " module=");
-    writeQuoted(fd, info.path[0] != '\0' ? info.path : baseName(g_ctx.modulePath));
-    writeStr(fd, " build_id=");
-    writeBuildId(fd, info.buildId, info.buildIdLen, info.pdbAge);
-}
-
-void emitFrame(int fd, int index, uintptr_t pc) {
-    ModuleInfo info;
-    findModuleInfo(pc, info);
-    const uintptr_t rva = pc >= info.base ? pc - info.base : 0ull;
-
-    writeStr(fd, "#");
-    if (index < 10) {
-        writeStr(fd, "0");
-    }
-    writeDec(fd, static_cast<unsigned int>(index));
-    writeStr(fd, " abs=");
-    writeHex(fd, pc);
-    writeStr(fd, " module_base=");
-    writeHex(fd, info.base);
-    if (info.size != 0) {
-        writeStr(fd, " image_size=");
-        writeHex(fd, info.size);
-    }
-    writeStr(fd, " rva=");
-    writeHex(fd, rva);
-    writeStr(fd, " module=");
-    writeQuoted(fd, info.path[0] != '\0' ? info.path : baseName(g_ctx.modulePath));
-    writeStr(fd, " build_id=");
-    writeBuildId(fd, info.buildId, info.buildIdLen, info.pdbAge);
-    unsigned long long disp = 0;
-    const char* sym = symbolFor(pc, &disp);
-    if (sym != nullptr && sym[0] != '\0') {
-        writeStr(fd, " ");
-        writeStr(fd, sym);
-        writeStr(fd, "+");
-        writeHex(fd, disp);
-    }
-    writeStr(fd, "\n");
-}
-
-void emitHeader(int fd, const char* reason, unsigned long long code, bool hasCode,
-    uintptr_t faultAddr, uintptr_t crashPc, bool crashPcKnown) {
-    writeStr(fd, "\n==================== DUSKLIGHT CRASHED ====================\n");
-    writeStr(fd, "Build:       " DUSK_WC_DESCRIBE " (" DUSK_WC_BRANCH ")\n");
-    writeStr(fd, "Revision:    " DUSK_WC_REVISION "  Date: " DUSK_WC_DATE
-                 "  Type: " DUSK_BUILD_TYPE "\n");
-    writeStr(fd, "Platform:    " DUSK_PLATFORM_NAME " / " DUSK_ARCH "\n");
-    writeStr(fd, "Module:      ");
-    writeStr(fd, g_ctx.modulePath[0] != '\0' ? g_ctx.modulePath : "(unknown)");
-    writeStr(fd, "\nModule base: ");
-    writeHex(fd, g_ctx.moduleBase);
-    writeStr(fd, "\nBuild-ID:    ");
-    writeBuildId(fd, g_ctx.buildId, g_ctx.buildIdLen, g_ctx.pdbAge);
-    writeStr(fd, "\nReason:      ");
-    writeStr(fd, reason);
-    if (hasCode) {
-        writeStr(fd, " (");
-        writeHex(fd, code);
-        writeStr(fd, ")");
-    }
-    writeStr(fd, "\nFault addr:  ");
-    writeHex(fd, faultAddr);
-    writeStr(fd, "\nCrash PC:    ");
-    if (crashPcKnown) {
-        emitAddressDetail(fd, crashPc);
-    } else {
-        writeStr(fd, "(unavailable on this platform)");
-    }
-    writeStr(fd, "\n");
-    writeStr(fd, "Backtrace:\n");
-}
-
-void emitFooter(int fd) {
-    writeStr(fd, "========================================================\n");
-}
-
-#if defined(_WIN32)
-
-LONG g_inHandler = 0;
-LPTOP_LEVEL_EXCEPTION_FILTER g_prevFilter = nullptr;
-
-bool readPeModuleInfo(uintptr_t moduleBase, ModuleInfo& info) {
-    const auto* base = reinterpret_cast<const uint8_t*>(moduleBase);
-    if (base == nullptr) {
-        return false;
-    }
-    const auto* dos = reinterpret_cast<const IMAGE_DOS_HEADER*>(base);
-    if (dos->e_magic != IMAGE_DOS_SIGNATURE) {
-        return false;
-    }
-    const auto* nt = reinterpret_cast<const IMAGE_NT_HEADERS*>(base + dos->e_lfanew);
-    if (nt->Signature != IMAGE_NT_SIGNATURE) {
-        return false;
-    }
-    info.base = moduleBase;
-    info.size = nt->OptionalHeader.SizeOfImage;
-    const IMAGE_DATA_DIRECTORY& dir =
-        nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_DEBUG];
-    if (dir.VirtualAddress == 0 || dir.Size == 0) {
-        return true;
-    }
-    const auto* dbg = reinterpret_cast<const IMAGE_DEBUG_DIRECTORY*>(base + dir.VirtualAddress);
-    const unsigned count = dir.Size / sizeof(IMAGE_DEBUG_DIRECTORY);
-    for (unsigned i = 0; i < count; ++i) {
-        if (dbg[i].Type != IMAGE_DEBUG_TYPE_CODEVIEW) {
-            continue;
-        }
-        const auto* cv = base + dbg[i].AddressOfRawData;
-        if (std::memcmp(cv, "RSDS", 4) != 0) {
-            continue;
-        }
-        std::memcpy(info.buildId, cv + 4, sizeof(GUID));
-        info.buildIdLen = sizeof(GUID);
-        std::memcpy(&info.pdbAge, cv + 4 + sizeof(GUID), sizeof(info.pdbAge));
-        break;
-    }
-    return true;
-}
-
-void captureBuildId() {
-    ModuleInfo info;
-    if (!readPeModuleInfo(g_ctx.moduleBase, info)) {
-        return;
-    }
-    g_ctx.buildIdLen = info.buildIdLen;
-    if (g_ctx.buildIdLen != 0) {
-        std::memcpy(g_ctx.buildId, info.buildId, g_ctx.buildIdLen);
-    }
-    g_ctx.pdbAge = info.pdbAge;
-}
-
-bool findModuleInfo(uintptr_t pc, ModuleInfo& info) {
-    fallbackModuleInfo(info);
-    MEMORY_BASIC_INFORMATION mbi;
-    if (VirtualQuery(reinterpret_cast<LPCVOID>(pc), &mbi, sizeof(mbi)) == 0 ||
-        mbi.AllocationBase == nullptr) {
-        return false;
-    }
-    const auto moduleBase = reinterpret_cast<uintptr_t>(mbi.AllocationBase);
-    info = {};
-    info.base = moduleBase;
-    GetModuleFileNameA(reinterpret_cast<HMODULE>(moduleBase), info.path,
-        static_cast<DWORD>(sizeof(info.path) - 1));
-    readPeModuleInfo(moduleBase, info);
-    return true;
-}
-
-const char* exceptionName(DWORD code) {
-    switch (code) {
-    case EXCEPTION_ACCESS_VIOLATION:
-        return "EXCEPTION_ACCESS_VIOLATION";
-    case EXCEPTION_ILLEGAL_INSTRUCTION:
-        return "EXCEPTION_ILLEGAL_INSTRUCTION";
-    case EXCEPTION_INT_DIVIDE_BY_ZERO:
-        return "EXCEPTION_INT_DIVIDE_BY_ZERO";
-    case EXCEPTION_STACK_OVERFLOW:
-        return "EXCEPTION_STACK_OVERFLOW";
-    case EXCEPTION_DATATYPE_MISALIGNMENT:
-        return "EXCEPTION_DATATYPE_MISALIGNMENT";
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        return "EXCEPTION_FLT_DIVIDE_BY_ZERO";
-    default:
-        return "EXCEPTION";
-    }
-}
-
-int captureBacktraceWin(CONTEXT ctx, uintptr_t* out, int cap) {
-    int n = 0;
-    while (n < cap) {
-#if defined(_M_X64)
-        const DWORD64 ip = ctx.Rip;
-#elif defined(_M_ARM64)
-        const DWORD64 ip = ctx.Pc;
-#else
-        const DWORD64 ip = 0;
-#endif
-        if (ip == 0) {
-            break;
-        }
-        out[n++] = static_cast<uintptr_t>(ip);
-#if defined(_M_X64) || defined(_M_ARM64)
-        DWORD64 imageBase = 0;
-        PRUNTIME_FUNCTION fn = RtlLookupFunctionEntry(ip, &imageBase, nullptr);
-        if (fn != nullptr) {
-            PVOID handlerData = nullptr;
-            DWORD64 establisherFrame = 0;
-            RtlVirtualUnwind(UNW_FLAG_NHANDLER, imageBase, ip, fn, &ctx, &handlerData,
-                &establisherFrame, nullptr);
-            continue;
-        }
-#if defined(_M_X64)
-        if (ctx.Rsp == 0) {
-            break;
-        }
-        ctx.Rip = *reinterpret_cast<const DWORD64*>(ctx.Rsp);
-        ctx.Rsp += sizeof(DWORD64);
-#else
-        if (ctx.Lr == 0 || ctx.Lr == ip) {
-            break;
-        }
-        ctx.Pc = ctx.Lr;
-        ctx.Lr = 0;
-#endif
-#else
-        break;
-#endif
-    }
-    return n;
-}
-
-void emit(int fd, EXCEPTION_POINTERS* ep) {
-    if (fd < 0) {
-        return;
-    }
-
-    const DWORD code = ep->ExceptionRecord->ExceptionCode;
-    const uintptr_t pc = reinterpret_cast<uintptr_t>(ep->ExceptionRecord->ExceptionAddress);
-    uintptr_t faultAddr = 0;
-    if (code == EXCEPTION_ACCESS_VIOLATION && ep->ExceptionRecord->NumberParameters >= 2) {
-        faultAddr = static_cast<uintptr_t>(ep->ExceptionRecord->ExceptionInformation[1]);
-    }
-
-    emitHeader(fd, exceptionName(code), code, true, faultAddr, pc, true);
-
-    uintptr_t frames[kMaxFrames];
-    const int frameCount = captureBacktraceWin(*ep->ContextRecord, frames, kMaxFrames);
-    for (int i = 0; i < frameCount; ++i) {
-        emitFrame(fd, i, frames[i]);
-    }
-
-    emitFooter(fd);
-}
-
-LONG WINAPI windowsHandler(EXCEPTION_POINTERS* ep) {
-    if (InterlockedCompareExchange(&g_inHandler, 1, 0) != 0) {
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-    emit(kStderrFd, ep);
-    const int logFd = dusk::GetLogFileDescriptor();
-    if (logFd >= 0) {
-        emit(logFd, ep);
-    }
-    if (g_prevFilter != nullptr) {
-        return g_prevFilter(ep);
-    }
-    return EXCEPTION_CONTINUE_SEARCH;
-}
-
-#else
-
-constexpr int kSignals[] = {SIGSEGV, SIGBUS, SIGABRT, SIGILL, SIGFPE};
-constexpr int kSignalCount = static_cast<int>(sizeof(kSignals) / sizeof(kSignals[0]));
-constexpr int kAltStackSize = 128 * 1024;
-
-volatile std::sig_atomic_t g_inHandler = 0;
-char g_altStack[kAltStackSize];
-struct sigaction g_prev[kSignalCount];
-std::terminate_handler g_prevTerminate = nullptr;
-
-void crashRegs(void* ucv, uintptr_t& pc, uintptr_t& lr, uintptr_t& fp) {
-    pc = 0;
-    lr = 0;
-    fp = 0;
-    if (ucv == nullptr) {
-        return;
-    }
-    auto* uc = static_cast<ucontext_t*>(ucv);
-#if defined(__APPLE__)
-#if defined(__aarch64__) || defined(__arm64__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext->__ss.__pc);
-    lr = static_cast<uintptr_t>(uc->uc_mcontext->__ss.__lr);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext->__ss.__fp);
-#elif defined(__x86_64__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext->__ss.__rip);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext->__ss.__rbp);
-#endif
-#elif defined(__ANDROID__)
-#if defined(__aarch64__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.pc);
-    lr = static_cast<uintptr_t>(uc->uc_mcontext.regs[30]);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.regs[29]);
-#elif defined(__x86_64__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_RIP]);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_RBP]);
-#elif defined(__arm__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.arm_pc);
-    lr = static_cast<uintptr_t>(uc->uc_mcontext.arm_lr);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.arm_fp);
-#elif defined(__i386__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_EIP]);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_EBP]);
-#endif
-#elif defined(__linux__)
-#if defined(__x86_64__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_RIP]);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_RBP]);
-#elif defined(__aarch64__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.pc);
-    lr = static_cast<uintptr_t>(uc->uc_mcontext.regs[30]);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.regs[29]);
-#elif defined(__i386__)
-    pc = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_EIP]);
-    fp = static_cast<uintptr_t>(uc->uc_mcontext.gregs[REG_EBP]);
-#endif
-#endif
-}
-
-bool pcNearFunctionEntry(uintptr_t pc) {
-    constexpr uintptr_t kPrologueWindow = 20;
-    Dl_info info;
-    if (dladdr(reinterpret_cast<void*>(pc), &info) == 0 || info.dli_saddr == nullptr) {
-        return false;
-    }
-    const auto start = reinterpret_cast<uintptr_t>(info.dli_saddr);
-    return pc >= start && pc - start <= kPrologueWindow;
-}
-
-int captureBacktraceFP(uintptr_t pc, uintptr_t lr, uintptr_t fp, uintptr_t* out, int cap) {
-    int n = 0;
-    if (pc != 0 && n < cap) {
-        out[n++] = pc;
-    }
-    bool dedupeLr = false;
-    if (lr != 0 && lr != pc && n < cap && pcNearFunctionEntry(pc)) {
-        out[n++] = lr;
-        dedupeLr = true;
-    }
-    uintptr_t cur = fp;
-    uintptr_t prev = 0;
-    constexpr uintptr_t kMaxFrameSpan = 16u << 20;
-    while (n < cap) {
-        if (cur == 0 || (cur & (sizeof(uintptr_t) - 1)) != 0 || cur <= prev) {
-            break;
-        }
-        const auto* slot = reinterpret_cast<const uintptr_t*>(cur);
-        const uintptr_t next = slot[0];
-        const uintptr_t ret = slot[1];
-        if (ret == 0) {
-            break;
-        }
-        const bool skip = dedupeLr && ret == lr;
-        dedupeLr = false;
-        if (!skip) {
-            out[n++] = ret;
-        }
-        if (next != 0 && next > cur && next - cur > kMaxFrameSpan) {
-            break;
-        }
-        prev = cur;
-        cur = next;
-    }
-    return n;
-}
-
-struct UnwindState {
-    uintptr_t* pcs;
-    int count;
-    int cap;
-    int skip;
-};
-
-_Unwind_Reason_Code unwindCb(struct _Unwind_Context* ctx, void* arg) {
-    auto* s = static_cast<UnwindState*>(arg);
-    const uintptr_t ip = static_cast<uintptr_t>(_Unwind_GetIP(ctx));
-    if (ip == 0) {
-        return _URC_END_OF_STACK;
-    }
-    if (s->skip > 0) {
-        --s->skip;
-        return _URC_NO_REASON;
-    }
-    if (s->count >= s->cap) {
-        return _URC_END_OF_STACK;
-    }
-    s->pcs[s->count++] = ip;
-    return _URC_NO_REASON;
-}
-
-int captureBacktrace(uintptr_t* pcs, int cap, int skip) {
-    UnwindState s{pcs, 0, cap, skip};
-    _Unwind_Backtrace(&unwindCb, &s);
-    return s.count;
-}
-
-void prewarmUnwinder() {
-    uintptr_t warm[4];
-    captureBacktrace(warm, 4, 0);
-}
-
-#if defined(__APPLE__)
-
-bool readMachBuildId(uintptr_t moduleBase, ModuleInfo& info) {
-    const auto* header = reinterpret_cast<const struct mach_header_64*>(moduleBase);
-    if (header == nullptr || header->magic != MH_MAGIC_64) {
-        return false;
-    }
-    const auto* lc = reinterpret_cast<const struct load_command*>(
-        reinterpret_cast<const char*>(header) + sizeof(struct mach_header_64));
-    for (uint32_t i = 0; i < header->ncmds; ++i) {
-        if (lc->cmd == LC_UUID) {
-            const auto* uuid = reinterpret_cast<const struct uuid_command*>(lc);
-            std::memcpy(info.buildId, uuid->uuid, sizeof(uuid->uuid));
-            info.buildIdLen = sizeof(uuid->uuid);
-            return true;
-        }
-        lc = reinterpret_cast<const struct load_command*>(
-            reinterpret_cast<const char*>(lc) + lc->cmdsize);
-    }
-    return true;
-}
-
-void captureBuildId() {
-    ModuleInfo info;
-    if (!readMachBuildId(g_ctx.moduleBase, info)) {
-        return;
-    }
-    g_ctx.buildIdLen = info.buildIdLen;
-    if (g_ctx.buildIdLen != 0) {
-        std::memcpy(g_ctx.buildId, info.buildId, g_ctx.buildIdLen);
-    }
-}
-
-#else
-
-bool segmentContains(const dl_phdr_info* info, uintptr_t addr) {
-    for (int i = 0; i < info->dlpi_phnum; ++i) {
-        const ElfW(Phdr)& ph = info->dlpi_phdr[i];
-        if (ph.p_type != PT_LOAD) {
-            continue;
-        }
-        const uintptr_t start = info->dlpi_addr + ph.p_vaddr;
-        if (addr >= start && addr < start + ph.p_memsz) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void readElfModuleInfo(const dl_phdr_info* info, ModuleInfo& module) {
-    uintptr_t minAddr = ~static_cast<uintptr_t>(0);
-    uintptr_t maxAddr = 0;
-    for (int i = 0; i < info->dlpi_phnum; ++i) {
-        const ElfW(Phdr)& ph = info->dlpi_phdr[i];
-        if (ph.p_type != PT_LOAD) {
-            continue;
-        }
-        const uintptr_t start = info->dlpi_addr + ph.p_vaddr;
-        const uintptr_t end = start + ph.p_memsz;
-        if (start < minAddr) {
-            minAddr = start;
-        }
-        if (end > maxAddr) {
-            maxAddr = end;
-        }
-    }
-    if (minAddr <= maxAddr && maxAddr != 0) {
-        module.base = minAddr;
-        module.size = maxAddr - minAddr;
-    }
-
-    for (int i = 0; i < info->dlpi_phnum; ++i) {
-        const ElfW(Phdr)& ph = info->dlpi_phdr[i];
-        if (ph.p_type != PT_NOTE) {
-            continue;
-        }
-        const auto* p = reinterpret_cast<const uint8_t*>(info->dlpi_addr + ph.p_vaddr);
-        const uint8_t* end = p + ph.p_memsz;
-        while (p + sizeof(ElfW(Nhdr)) <= end) {
-            const auto* nh = reinterpret_cast<const ElfW(Nhdr)*>(p);
-            const char* name = reinterpret_cast<const char*>(nh + 1);
-            const uint8_t* desc =
-                reinterpret_cast<const uint8_t*>(name + ((nh->n_namesz + 3) & ~3u));
-            if (nh->n_type == NT_GNU_BUILD_ID && nh->n_namesz == 4 &&
-                std::memcmp(name, "GNU", 4) == 0) {
-                unsigned n = nh->n_descsz;
-                if (n > sizeof(module.buildId)) {
-                    n = sizeof(module.buildId);
-                }
-                std::memcpy(module.buildId, desc, n);
-                module.buildIdLen = n;
-                return;
-            }
-            p = desc + ((nh->n_descsz + 3) & ~3u);
-        }
-    }
-}
-
-int elfBuildIdCallback(dl_phdr_info* info, size_t, void* arg) {
-    const auto self = *static_cast<const uintptr_t*>(arg);
-    if (!segmentContains(info, self)) {
-        return 0;
-    }
-    ModuleInfo module;
-    readElfModuleInfo(info, module);
-    g_ctx.buildIdLen = module.buildIdLen;
-    if (g_ctx.buildIdLen != 0) {
-        std::memcpy(g_ctx.buildId, module.buildId, g_ctx.buildIdLen);
-    }
-    return 1;
-}
-
-void captureBuildId() {
-    uintptr_t self = reinterpret_cast<uintptr_t>(&install);
-    dl_iterate_phdr(&elfBuildIdCallback, &self);
-}
-
-#endif
-
-#if !defined(__APPLE__)
-struct ElfModuleSearch {
-    uintptr_t pc;
-    ModuleInfo* module;
-};
-
-int elfModuleInfoCallback(dl_phdr_info* info, size_t, void* arg) {
-    auto* search = static_cast<ElfModuleSearch*>(arg);
-    if (!segmentContains(info, search->pc)) {
-        return 0;
-    }
-    if (info->dlpi_name != nullptr && info->dlpi_name[0] != '\0') {
-        std::strncpy(search->module->path, info->dlpi_name,
-            sizeof(search->module->path) - 1);
-    }
-    readElfModuleInfo(info, *search->module);
-    return 1;
-}
-#endif
-
-bool findModuleInfo(uintptr_t pc, ModuleInfo& info) {
-    fallbackModuleInfo(info);
-    Dl_info moduleInfo;
-    if (dladdr(reinterpret_cast<void*>(pc), &moduleInfo) == 0) {
-        return false;
-    }
-    if (moduleInfo.dli_fbase != nullptr) {
-        info.base = reinterpret_cast<uintptr_t>(moduleInfo.dli_fbase);
-    }
-    if (moduleInfo.dli_fname != nullptr && moduleInfo.dli_fname[0] != '\0') {
-        info.path[0] = '\0';
-        std::strncpy(info.path, moduleInfo.dli_fname, sizeof(info.path) - 1);
-    }
-    info.buildIdLen = 0;
-    info.pdbAge = 0;
-#if defined(__APPLE__)
-    readMachBuildId(info.base, info);
-#else
-    ElfModuleSearch search{pc, &info};
-    dl_iterate_phdr(&elfModuleInfoCallback, &search);
-#endif
-    return true;
-}
-
-const char* signalName(int sig) {
-    switch (sig) {
-    case SIGSEGV:
-        return "SIGSEGV (segmentation fault)";
-    case SIGBUS:
-        return "SIGBUS (bus error)";
-    case SIGABRT:
-        return "SIGABRT (abort)";
-    case SIGILL:
-        return "SIGILL (illegal instruction)";
-    case SIGFPE:
-        return "SIGFPE (floating point exception)";
-    default:
-        return "unknown signal";
-    }
-}
-
-void emit(int fd, int sig, siginfo_t* info, const uintptr_t* frames, int frameCount,
-    uintptr_t pc) {
-    if (fd < 0) {
-        return;
-    }
-    const uintptr_t faultAddr =
-        info != nullptr ? reinterpret_cast<uintptr_t>(info->si_addr) : 0;
-    emitHeader(fd, signalName(sig), 0, false, faultAddr, pc, pc != 0);
-    for (int i = 0; i < frameCount; ++i) {
-        emitFrame(fd, i, frames[i]);
-    }
-    emitFooter(fd);
-}
-
-void chainPrevious(int sig, siginfo_t* info, void* uc) {
-    for (int i = 0; i < kSignalCount; ++i) {
-        if (kSignals[i] != sig) {
-            continue;
-        }
-        const struct sigaction& o = g_prev[i];
-        if ((o.sa_flags & SA_SIGINFO) != 0) {
-            if (o.sa_sigaction != nullptr) {
-                o.sa_sigaction(sig, info, uc);
-                return;
-            }
-        } else {
-            if (o.sa_handler == SIG_IGN) {
-                return;
-            }
-            if (o.sa_handler != SIG_DFL && o.sa_handler != nullptr) {
-                o.sa_handler(sig);
-                return;
-            }
-        }
-        break;
-    }
-    ::signal(sig, SIG_DFL);
-    ::raise(sig);
-}
-
-void handler(int sig, siginfo_t* info, void* ucv) {
-    if (g_inHandler != 0) {
-        _exit(128 + sig);
-    }
-    g_inHandler = 1;
-
-    uintptr_t pc = 0;
-    uintptr_t lr = 0;
-    uintptr_t fp = 0;
-    crashRegs(ucv, pc, lr, fp);
-    uintptr_t frames[kMaxFrames];
-    int frameCount = captureBacktraceFP(pc, lr, fp, frames, kMaxFrames);
-    if (frameCount < 2) {
-        frameCount = captureBacktrace(frames, kMaxFrames, 2);
-    }
-
-    emit(kStderrFd, sig, info, frames, frameCount, pc);
-    const int logFd = dusk::GetLogFileDescriptor();
-    if (logFd >= 0) {
-        emit(logFd, sig, info, frames, frameCount, pc);
-        ::fsync(logFd);
-    }
-
-    chainPrevious(sig, info, ucv);
-}
-
-void writeTerminateMessage(int fd, const char* body, const char* what) {
-    writeStr(fd, "\nterminate: ");
-    writeStr(fd, body);
-    writeStr(fd, what);
-    writeStr(fd, "\n");
-}
-
-void onTerminate() {
-    const char* body = "unknown reason";
-    const char* what = nullptr;
-    if (std::exception_ptr ep = std::current_exception()) {
-        try {
-            std::rethrow_exception(ep);
-        } catch (const std::exception& e) {
-            body = "uncaught exception: ";
-            what = e.what();
-        } catch (...) {
-            body = "uncaught non-std exception";
-        }
-    } else {
-        body = "no active exception";
-    }
-    writeTerminateMessage(kStderrFd, body, what);
-    writeTerminateMessage(dusk::GetLogFileDescriptor(), body, what);
-    if (g_prevTerminate != nullptr) {
-        g_prevTerminate();
-    }
-    std::abort();
-}
-
-#endif
-
-}  // namespace
-
-void install() {
-#if defined(_WIN32)
-    g_ctx.moduleBase = reinterpret_cast<uintptr_t>(GetModuleHandleW(nullptr));
-    GetModuleFileNameA(nullptr, g_ctx.modulePath, sizeof(g_ctx.modulePath) - 1);
-    captureBuildId();
-#if defined(DUSK_CRASH_DBGHELP)
-    SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES);
-    SymInitialize(GetCurrentProcess(), nullptr, TRUE);
-#endif
-    g_prevFilter = SetUnhandledExceptionFilter(&windowsHandler);
-#elif !defined(__APPLE__) || !TARGET_OS_TV
-    Dl_info moduleInfo;
-    if (dladdr(reinterpret_cast<void*>(&install), &moduleInfo) != 0) {
-        g_ctx.moduleBase = reinterpret_cast<uintptr_t>(moduleInfo.dli_fbase);
-        if (moduleInfo.dli_fname != nullptr) {
-            std::strncpy(g_ctx.modulePath, moduleInfo.dli_fname,
-                sizeof(g_ctx.modulePath) - 1);
-        }
-    }
-    captureBuildId();
-    prewarmUnwinder();
-
-    static stack_t altStack;
-    altStack.ss_sp = g_altStack;
-    altStack.ss_size = sizeof(g_altStack);
-    altStack.ss_flags = 0;
-    sigaltstack(&altStack, nullptr);
-
-    struct sigaction sa;
-    std::memset(&sa, 0, sizeof(sa));
-    sa.sa_sigaction = &handler;
-    sigemptyset(&sa.sa_mask);
-    sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
-
-    for (int i = 0; i < kSignalCount; ++i) {
-        sigaction(kSignals[i], &sa, &g_prev[i]);
-    }
-
-    g_prevTerminate = std::set_terminate(&onTerminate);
-#endif
-}
-
-}  // namespace dusk::crash_handler
diff --git a/src/dusk/crash_reporting.cpp b/src/dusk/crash_reporting.cpp
deleted file mode 100644
index 2c2a77079b..0000000000
--- a/src/dusk/crash_reporting.cpp
+++ /dev/null
@@ -1,188 +0,0 @@
-#include "dusk/crash_reporting.h"
-
-#include "dusk/app_info.hpp"
-#include "dusk/dusk.h"
-#include "dusk/logging.h"
-#include "dusk/main.h"
-#include "version.h"
-
-#include <cstdlib>
-#include <filesystem>
-#include <string>
-#include <string_view>
-#include <system_error>
-
-#if DUSK_ENABLE_SENTRY_NATIVE
-#include <sentry.h>
-#endif
-
-namespace dusk::crash_reporting {
-
-namespace {
-
-#if DUSK_ENABLE_SENTRY_NATIVE
-bool g_sentryInitialized = false;
-
-bool truthy(std::string_view value) {
-    return value == "1" || value == "true" || value == "TRUE" || value == "yes" || value == "YES" ||
-           value == "on" || value == "ON";
-}
-
-std::string env_or_empty(const char* name) {
-    if (const char* value = std::getenv(name)) {
-        return value;
-    }
-    return {};
-}
-
-bool disabled_by_env() {
-    const std::string env = env_or_empty("DUSK_SENTRY_ENABLED");
-    return !env.empty() && !truthy(env);
-}
-
-std::string effective_dsn() {
-    const std::string env = env_or_empty("DUSK_SENTRY_DSN");
-    if (!env.empty()) {
-        return env;
-    }
-    return DUSK_SENTRY_DSN;
-}
-
-bool effective_debug() {
-    const std::string env = env_or_empty("DUSK_SENTRY_DEBUG");
-    if (!env.empty()) {
-        return truthy(env);
-    }
-    return false;
-}
-
-std::string release_name() {
-    return std::string(AppName) + "@" DUSK_WC_DESCRIBE;
-}
-
-std::filesystem::path sentry_database_path() {
-    return dusk::CachePath / "sentry";
-}
-
-std::filesystem::path log_attachment_path() {
-    if (const char* logPath = GetLogFilePath()) {
-        return logPath;
-    }
-    return {};
-}
-
-void configure_path_options(sentry_options_t* options) {
-    const auto databasePath = sentry_database_path();
-    std::error_code ec;
-    std::filesystem::create_directories(databasePath, ec);
-    if (ec) {
-        DuskLog.warn(
-            "Unable to create Sentry database path '{}': {}", databasePath.string(), ec.message());
-    }
-
-#if _WIN32
-    const std::wstring databasePathWide = databasePath.wstring();
-    sentry_options_set_database_pathw(options, databasePathWide.c_str());
-#else
-    const std::string databasePathUtf8 = databasePath.string();
-    sentry_options_set_database_path(options, databasePathUtf8.c_str());
-#endif
-
-    const auto logPath = log_attachment_path();
-    if (!logPath.empty()) {
-#if _WIN32
-        sentry_options_add_attachmentw(options, logPath.wstring().c_str());
-#else
-        sentry_options_add_attachment(options, logPath.string().c_str());
-#endif
-    }
-}
-#endif
-
-}  // namespace
-
-void initialize() {
-#if DUSK_ENABLE_SENTRY_NATIVE
-    if (g_sentryInitialized || disabled_by_env()) {
-        return;
-    }
-
-    const std::string dsn = effective_dsn();
-    if (dsn.empty()) {
-        DuskLog.warn("Crash reporting is enabled but no Sentry DSN is configured");
-        return;
-    }
-
-    const std::string release = release_name();
-
-    sentry_options_t* options = sentry_options_new();
-    sentry_options_set_dsn(options, dsn.c_str());
-    sentry_options_set_release(options, release.c_str());
-    sentry_options_set_environment(options, DUSK_SENTRY_ENVIRONMENT);
-    sentry_options_set_debug(options, effective_debug() ? 1 : 0);
-    sentry_options_set_require_user_consent(options, 1);
-    sentry_options_set_cache_keep(options, 1);
-    sentry_options_set_max_breadcrumbs(options, 100);
-    configure_path_options(options);
-
-    if (sentry_init(options) != 0) {
-        DuskLog.warn("Failed to initialize Sentry crash reporting");
-        return;
-    }
-
-    sentry_set_tag("git_branch", DUSK_WC_BRANCH);
-    sentry_set_tag("build_type", DUSK_BUILD_TYPE);
-    g_sentryInitialized = true;
-
-    DuskLog.info("Initialized Sentry crash reporting");
-#endif
-}
-
-void shutdown() {
-#if DUSK_ENABLE_SENTRY_NATIVE
-    if (!g_sentryInitialized) {
-        return;
-    }
-
-    sentry_close();
-    g_sentryInitialized = false;
-#endif
-}
-
-Consent get_consent() {
-#if DUSK_ENABLE_SENTRY_NATIVE
-    if (!g_sentryInitialized) {
-        return Consent::Unavailable;
-    }
-
-    switch (sentry_user_consent_get()) {
-    case SENTRY_USER_CONSENT_GIVEN:
-        return Consent::Given;
-    case SENTRY_USER_CONSENT_REVOKED:
-        return Consent::Revoked;
-    case SENTRY_USER_CONSENT_UNKNOWN:
-    default:
-        return Consent::Unknown;
-    }
-#else
-    return Consent::Unavailable;
-#endif
-}
-
-void set_consent(bool enabled) {
-#if DUSK_ENABLE_SENTRY_NATIVE
-    if (!g_sentryInitialized) {
-        return;
-    }
-
-    if (enabled) {
-        sentry_user_consent_give();
-    } else {
-        sentry_user_consent_revoke();
-    }
-#else
-    (void)enabled;
-#endif
-}
-
-}  // namespace dusk::crash_reporting
diff --git a/src/dusk/data.cpp b/src/dusk/data.cpp
index 69ee5bebc8..0477d096a1 100644
--- a/src/dusk/data.cpp
+++ b/src/dusk/data.cpp
@@ -1,1008 +1,192 @@
 #include "data.hpp"
 
 #include "dusk/app_info.hpp"
-#include "dusk/io.hpp"
-#include "dusk/logging.h"
-#include "dusk/main.h"
 
-#include <array>
-#include <chrono>
-#include <filesystem>
-#include <optional>
-#include <ranges>
+#include <borealis/io.hpp>
+#include <borealis/log.hpp>
+
 #include <string>
-#include <string_view>
-#include <system_error>
-#include <vector>
-
-#include <SDL3/SDL_filesystem.h>
-#include <SDL3/SDL_misc.h>
-#include <SDL3/SDL_stdinc.h>
-
-#include "nlohmann/json.hpp"
 
 namespace dusk::data {
 namespace {
 
-aurora::Module Log{"dusk::data"};
+constexpr borealis::Log Log{"dusk::data"};
 
-constexpr auto kLocationDescriptorName = "data_location.json";
+std::string status_message(const borealis::data::Status& status) {
+    using enum borealis::data::ErrorCode;
 
-constexpr std::array<std::string_view, 4> kUserDataDirectories = {
-    "texture_replacements",
-    "USA",
-    "EUR",
-    "JAP",
-};
-constexpr std::array<std::string_view, 7> kUserDataFiles = {
-    "achievements.json",
-    "config.json",
-    "controller_ports.dat",
-    "gamecontrollerdb.txt",
-    "imgui.ini",
-    "keyboard_bindings.dat",
-    "states.json",
-};
-
-enum class LocationMode {
-    Default,
-    Portable,
-    Custom,
-};
-
-struct LocationDescriptor {
-    LocationMode mode = LocationMode::Default;
-    std::filesystem::path customPath;
-    std::filesystem::path previousPath;
-};
-
-struct LocatedDescriptor {
-    LocationDescriptor descriptor;
-    std::filesystem::path path;
-};
-
-struct MigrationStats {
-    std::uintmax_t directoriesCreated = 0;
-    std::uintmax_t filesCopied = 0;
-    std::uintmax_t symlinksCopied = 0;
-    std::uintmax_t sourcesRemoved = 0;
-    std::uintmax_t emptyDirectoriesRemoved = 0;
-    std::uintmax_t skippedExistingTargets = 0;
-    std::uintmax_t skippedDescriptorFiles = 0;
-    std::uintmax_t skippedNestedTargets = 0;
-    std::uintmax_t skippedUnsupportedEntries = 0;
-    std::uintmax_t failures = 0;
-};
-
-std::optional<std::filesystem::path> sConfiguredDataPath;
-std::optional<std::filesystem::path> sActiveDescriptorPath;
-std::optional<std::filesystem::path> sActivePrefPath;
-
-std::filesystem::path path_from_utf8(std::string_view value) {
-    return std::filesystem::path{
-        reinterpret_cast<const char8_t*>(value.data()),
-        reinterpret_cast<const char8_t*>(value.data() + value.size()),
-    };
-}
-
-std::filesystem::path legacy_path_for_pref_path(const std::filesystem::path& prefPath) {
-    if (std::string_view{LegacyAppName}.empty() || prefPath.empty()) {
+    std::string message;
+    switch (status.code) {
+    case None:
         return {};
+    case NotInitialized:
+        message = "Data folders have not been initialized.";
+        break;
+    case PreferencePathUnavailable:
+        message = "The system data folder is unavailable.";
+        break;
+    case EmptyPath:
+        message = "Choose a folder.";
+        break;
+    case CreateDirectoryFailed:
+        message = "The selected folder could not be created.";
+        break;
+    case NotDirectory:
+        message = "The selected path is not a folder.";
+        break;
+    case WriteProbeFailed:
+        message = "The selected folder is not writable.";
+        break;
+    case WriteProbeCleanupFailed:
+        message = "The selected folder could not be validated.";
+        break;
+    case DescriptorWriteFailed:
+        message = "Dusklight could not save the data folder setting.";
+        break;
+    case MigrationIncomplete:
+        message = "Data migration could not be completed.";
+        break;
+    case OverrideActive:
+        message = "The data folder is fixed by --user-dir for this session.";
+        break;
+    case Unsupported:
+        message = "Changing the data folder is not supported on this platform.";
+        break;
+    case OpenFolderFailed:
+        message = "The data folder could not be opened.";
+        break;
     }
 
-    auto normalizedPrefPath = prefPath;
-    if (normalizedPrefPath.filename().empty()) {
-        normalizedPrefPath = normalizedPrefPath.parent_path();
+    if (!status.path.empty()) {
+        message += " (" + borealis::io::fs_path_to_string(status.path) + ")";
     }
-
-    const auto parentPath = normalizedPrefPath.parent_path();
-    if (parentPath.empty()) {
-        return {};
+    if (status.systemError) {
+        message += ": " + status.systemError.message();
     }
-
-    return parentPath / LegacyAppName;
+    return message;
 }
 
-std::filesystem::path get_pref_path() {
-    char* prefPath = SDL_GetPrefPath(OrgName, AppName);
-    if (!prefPath) {
-        Log.fatal("Unable to get PrefPath: {}", SDL_GetError());
-    }
-
-    std::filesystem::path result = path_from_utf8(prefPath);
-    SDL_free(prefPath);
-    return result;
-}
-
-std::filesystem::path active_pref_path() {
-    if (sActivePrefPath) {
-        return *sActivePrefPath;
-    }
-    return get_pref_path();
-}
-
-std::filesystem::path default_data_path(const std::filesystem::path& prefPath) {
-#ifdef __APPLE__
-#if TARGET_OS_IOS && !TARGET_OS_TV
-    const char* documentsPath = SDL_GetUserFolder(SDL_FOLDER_DOCUMENTS);
-    if (!documentsPath) {
-        Log.fatal("Unable to get iOS Documents path: {}", SDL_GetError());
-    }
-
-    return reinterpret_cast<const char8_t*>(documentsPath);
-#endif
-#endif
-
-    return prefPath;
-}
-
-std::filesystem::path portable_data_path() {
-    return base_path_relative("data");
-}
-
-std::vector<std::filesystem::path> descriptor_paths(const std::filesystem::path& prefPath) {
-    std::vector<std::filesystem::path> paths;
-    if (const auto basePath = base_path_relative(kLocationDescriptorName); !basePath.empty()) {
-        paths.push_back(basePath);
-    }
-    paths.push_back(prefPath / kLocationDescriptorName);
-    return paths;
-}
-
-std::optional<LocationDescriptor> read_location_descriptor_file(const std::filesystem::path& path) {
-    if (path.empty()) {
-        return std::nullopt;
-    }
-    if (std::error_code ec; !std::filesystem::exists(path, ec)) {
-        return std::nullopt;
-    }
-
-    try {
-        const auto bytes = io::FileStream::ReadAllBytes(path);
-        const auto json = nlohmann::json::parse(bytes);
-        if (!json.is_object()) {
-            Log.warn("Ignoring data location descriptor '{}': root is not an object",
-                io::fs_path_to_string(path));
-            return std::nullopt;
-        }
-
-        LocationDescriptor descriptor;
-        const auto mode = json.value<std::string>("mode", "default");
-        if (mode == "portable") {
-            descriptor.mode = LocationMode::Portable;
-        } else if (mode == "custom") {
-            descriptor.mode = LocationMode::Custom;
-        } else if (mode != "default") {
-            Log.warn("Ignoring unknown data location mode '{}'", mode);
-        }
-
-        if (const auto customPath = json.find("customPath");
-            customPath != json.end() && customPath->is_string())
-        {
-            descriptor.customPath = path_from_utf8(customPath->get<std::string>());
-        }
-        if (const auto previousPath = json.find("previousPath");
-            previousPath != json.end() && previousPath->is_string())
-        {
-            descriptor.previousPath = path_from_utf8(previousPath->get<std::string>());
-        }
-
-        return descriptor;
-    } catch (const std::exception& e) {
-        Log.warn(
-            "Ignoring data location descriptor '{}': {}", io::fs_path_to_string(path), e.what());
-        return std::nullopt;
-    }
-}
-
-std::optional<LocatedDescriptor> read_location_descriptor(const std::filesystem::path& prefPath) {
-    for (const auto& path : descriptor_paths(prefPath)) {
-        if (auto descriptor = read_location_descriptor_file(path)) {
-            return LocatedDescriptor{
-                .descriptor = *descriptor,
-                .path = path,
-            };
-        }
-    }
-    return std::nullopt;
-}
-
-std::filesystem::path resolve_data_path(
-    const std::filesystem::path& prefPath, const LocationDescriptor* descriptor) {
-    if (!descriptor) {
-        return default_data_path(prefPath);
-    }
-
-    switch (descriptor->mode) {
-    case LocationMode::Default:
-        return default_data_path(prefPath);
-    case LocationMode::Portable:
-        return portable_data_path();
-    case LocationMode::Custom:
-        if (!descriptor->customPath.empty()) {
-            return descriptor->customPath;
-        }
-        Log.warn("Data location descriptor requested custom mode without a path");
-        return default_data_path(prefPath);
-    }
-
-    return default_data_path(prefPath);
-}
-
-const char* location_mode_id(LocationMode mode) {
-    switch (mode) {
-    case LocationMode::Default:
-        return "default";
-    case LocationMode::Portable:
-        return "portable";
-    case LocationMode::Custom:
-        return "custom";
-    }
-
-    return "default";
-}
-
-std::filesystem::path normalized_path(const std::filesystem::path& path) {
-    std::error_code ec;
-    auto normalized = std::filesystem::weakly_canonical(path, ec);
-    if (!ec) {
-        return normalized;
-    }
-
-    normalized = std::filesystem::absolute(path, ec);
-    if (!ec) {
-        return normalized.lexically_normal();
-    }
-
-    return path.lexically_normal();
-}
-
-std::filesystem::path absolute_path(const std::filesystem::path& path) {
-    std::error_code ec;
-    const auto absolute = std::filesystem::absolute(path, ec);
-    if (ec) {
-        return path;
-    }
-    return absolute.lexically_normal();
-}
-
-std::filesystem::path rename_legacy_pref_path(
-    const std::filesystem::path& legacyPath, const std::filesystem::path& prefPath) {
-    if (legacyPath.empty() || prefPath.empty() ||
-        normalized_path(legacyPath) == normalized_path(prefPath))
-    {
-        return prefPath;
-    }
-
-    std::error_code ec;
-    if (!std::filesystem::exists(legacyPath, ec)) {
-        if (ec) {
-            Log.warn("Failed to inspect legacy data directory '{}': {}",
-                io::fs_path_to_string(legacyPath), ec.message());
-        }
-        return prefPath;
-    }
-
-    const bool prefExists = std::filesystem::exists(prefPath, ec);
-    if (ec) {
-        Log.warn("Failed to inspect data directory '{}': {}", io::fs_path_to_string(prefPath),
-            ec.message());
-        return prefPath;
-    }
-    if (prefExists) {
-        if (!std::filesystem::is_directory(prefPath, ec) ||
-            !std::filesystem::is_empty(prefPath, ec))
-        {
-            if (ec) {
-                Log.warn("Failed to inspect data directory '{}': {}",
-                    io::fs_path_to_string(prefPath), ec.message());
-            } else {
-                Log.info("Skipping legacy data directory rename because '{}' is not empty",
-                    io::fs_path_to_string(prefPath));
-            }
-            return prefPath;
-        }
-
-        std::filesystem::remove(prefPath, ec);
-        if (ec) {
-            Log.warn("Failed to remove empty data directory '{}' before legacy rename: {}",
-                io::fs_path_to_string(prefPath), ec.message());
-            return prefPath;
-        }
-    }
-
-    std::filesystem::rename(legacyPath, prefPath, ec);
-    if (ec) {
-        Log.warn("Failed to rename legacy data directory '{}' to '{}': {}",
-            io::fs_path_to_string(legacyPath), io::fs_path_to_string(prefPath), ec.message());
-        ec.clear();
-        if (!std::filesystem::exists(prefPath, ec) && !ec) {
-            Log.info("Using legacy data directory '{}' because the new data directory is absent",
-                io::fs_path_to_string(legacyPath));
-            return legacyPath;
-        }
-        return prefPath;
-    }
-
-    Log.info("Renamed legacy data directory '{}' to '{}'", io::fs_path_to_string(legacyPath),
-        io::fs_path_to_string(prefPath));
-    return prefPath;
-}
-
-bool is_same_or_inside(const std::filesystem::path& root, const std::filesystem::path& path) {
-    const auto normalizedRoot = normalized_path(root);
-    const auto normalizedPath = normalized_path(path);
-    const auto relativePath = normalizedPath.lexically_relative(normalizedRoot);
-    if (relativePath.empty()) {
-        return normalizedPath == normalizedRoot;
-    }
-    if (relativePath == ".") {
+bool operation_succeeded(const borealis::data::Status& status, std::string* errorOut = nullptr) {
+    if (status) {
         return true;
     }
-    if (relativePath.is_absolute()) {
-        return false;
-    }
-
-    const auto it = relativePath.begin();
-    return it == relativePath.end() || *it != "..";
-}
-
-bool should_skip_migration_path(const std::filesystem::path& path,
-    const std::filesystem::path& from, const std::filesystem::path& to, MigrationStats& stats) {
-    if (is_same_or_inside(to, path)) {
-        ++stats.skippedNestedTargets;
-        return true;
-    }
-
-    const auto relativePath = path.lexically_relative(from);
-    if (relativePath == kLocationDescriptorName) {
-        ++stats.skippedDescriptorFiles;
-        return true;
-    }
-
-    return false;
-}
-
-bool matches_name(std::string_view name, const auto& names) {
-    return std::ranges::find(names, name) != names.end();
-}
-
-bool should_migrate_user_data_path(
-    const std::filesystem::path& sourcePath, const std::filesystem::path& from) {
-    const auto relativePath = sourcePath.lexically_relative(from);
-    if (relativePath.empty() || relativePath.is_absolute()) {
-        return false;
-    }
-
-    auto it = relativePath.begin();
-    if (it == relativePath.end() || *it == "..") {
-        return false;
-    }
-
-    const auto first = io::fs_path_to_string(*it);
-    if (matches_name(first, kUserDataDirectories)) {
-        return true;
-    }
-
-    ++it;
-    if (it != relativePath.end()) {
-        return false;
-    }
-
-    const auto filename = io::fs_path_to_string(relativePath.filename());
-    if (matches_name(filename, kUserDataFiles)) {
-        return true;
-    }
-
-    return relativePath.extension() == ".controller" || relativePath.extension() == ".gci" ||
-           (filename.starts_with("MemoryCard") && filename.ends_with(".raw"));
-}
-
-std::filesystem::path current_data_path() {
-    if (!ConfigPath.empty()) {
-        return ConfigPath;
-    }
-    const auto prefPath = active_pref_path();
-    const auto descriptor = read_location_descriptor(prefPath);
-    if (descriptor) {
-        sActiveDescriptorPath = descriptor->path;
-    }
-    return resolve_data_path(prefPath, descriptor ? &descriptor->descriptor : nullptr);
-}
-
-std::vector<std::filesystem::path> descriptor_write_paths(const std::filesystem::path& prefPath) {
-    if (sActiveDescriptorPath && !sActiveDescriptorPath->empty()) {
-        return {*sActiveDescriptorPath};
-    }
-
-    std::vector<std::filesystem::path> paths;
-#if defined(_WIN32)
-    if (const auto basePath = base_path_relative(kLocationDescriptorName); !basePath.empty()) {
-        paths.push_back(basePath);
-    }
-#endif
-    paths.push_back(prefPath / kLocationDescriptorName);
-    return paths;
-}
-
-bool write_descriptor_json(const std::filesystem::path& path, const nlohmann::json& json) {
-    std::error_code ec;
-    std::filesystem::create_directories(path.parent_path(), ec);
-    if (ec) {
-        Log.warn("Failed to create data location descriptor directory '{}': {}",
-            io::fs_path_to_string(path.parent_path()), ec.message());
-        return false;
-    }
-    try {
-        io::FileStream::WriteAllText(path, json.dump(4));
-    } catch (const std::exception& e) {
-        Log.warn("Failed to write data location descriptor '{}': {}", io::fs_path_to_string(path),
-            e.what());
-        return false;
-    }
-    return true;
-}
-
-bool write_location_descriptor(LocationMode mode, const std::filesystem::path& targetPath) {
-    LocationDescriptor descriptor;
-    descriptor.mode = mode;
-    if (mode == LocationMode::Custom) {
-        descriptor.customPath = absolute_path(targetPath);
-    }
-
-    const auto currentPath = current_data_path();
-    const auto resolvedTargetPath =
-        mode == LocationMode::Custom ? descriptor.customPath : targetPath;
-    if (!currentPath.empty() && normalized_path(currentPath) != normalized_path(resolvedTargetPath))
-    {
-        descriptor.previousPath = currentPath;
-    }
-
-    nlohmann::json json;
-    json["version"] = 1;
-    json["mode"] = location_mode_id(descriptor.mode);
-    if (descriptor.mode == LocationMode::Custom && !descriptor.customPath.empty()) {
-        json["customPath"] = io::fs_path_to_string(descriptor.customPath);
-    }
-    if (!descriptor.previousPath.empty()) {
-        json["previousPath"] = io::fs_path_to_string(descriptor.previousPath);
-    }
-
-    const auto prefPath = active_pref_path();
-    for (const auto& path : descriptor_write_paths(prefPath)) {
-        if (write_descriptor_json(path, json)) {
-            sActiveDescriptorPath = path;
-            sConfiguredDataPath = resolvedTargetPath;
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void set_error(std::string* errorOut, std::string error) {
+    const auto message = status_message(status);
     if (errorOut != nullptr) {
-        *errorOut = std::move(error);
-    }
-}
-
-bool validate_writable_data_path(const std::filesystem::path& path, std::string* errorOut) {
-    if (path.empty()) {
-        set_error(errorOut, "Choose a folder.");
-        return false;
-    }
-
-    std::error_code ec;
-    std::filesystem::create_directories(path, ec);
-    if (ec) {
-        set_error(errorOut, fmt::format("{} could not create the selected folder.", AppName));
-        Log.warn("Failed to create custom data folder '{}': {}", io::fs_path_to_string(path),
-            ec.message());
-        return false;
-    }
-
-    if (!std::filesystem::is_directory(path, ec)) {
-        set_error(errorOut, "The selected path is not a folder.");
-        if (ec) {
-            Log.warn("Failed to inspect custom data folder '{}': {}", io::fs_path_to_string(path),
-                ec.message());
-        }
-        return false;
-    }
-
-    const auto probePath = path / fmt::format(".write-probe-{}.tmp",
-                                      std::chrono::steady_clock::now().time_since_epoch().count());
-    try {
-        io::FileStream::WriteAllText(probePath, "dusk");
-    } catch (const std::exception& e) {
-#if defined(__ANDROID__)
-        set_error(errorOut,
-            fmt::format("{} could not write to the selected folder. On Android, allow "
-                        "\"All files access\" for Dusklight and try again.",
-                AppName));
-#else
-        set_error(errorOut, fmt::format("{} could not write to the selected folder.", AppName));
-#endif
-        Log.warn("Failed write probe for custom data folder '{}': {}", io::fs_path_to_string(path),
-            e.what());
-        return false;
-    }
-
-    std::filesystem::remove(probePath, ec);
-    if (ec) {
-        set_error(
-            errorOut, fmt::format("{} could write to the selected folder, but could not remove "
-                                  "the test file it created.",
-                          AppName));
-        Log.warn("Failed to remove custom data folder write probe '{}': {}",
-            io::fs_path_to_string(probePath), ec.message());
-        return false;
-    }
-
-    return true;
-}
-
-std::uintmax_t remove_empty_directories(const std::filesystem::path& root, bool includeRoot) {
-    std::error_code ec;
-    std::vector<std::filesystem::path> directories;
-    for (std::filesystem::recursive_directory_iterator it(
-             root, std::filesystem::directory_options::skip_permission_denied, ec);
-        it != std::filesystem::recursive_directory_iterator(); it.increment(ec))
-    {
-        if (ec) {
-            Log.warn("Failed to scan empty directories under '{}': {}", io::fs_path_to_string(root),
-                ec.message());
-            return 0;
-        }
-        const auto status = it->symlink_status(ec);
-        if (ec) {
-            Log.warn("Failed to inspect '{}' while pruning empty directories: {}",
-                io::fs_path_to_string(it->path()), ec.message());
-            ec.clear();
-            continue;
-        }
-        if (std::filesystem::is_directory(status)) {
-            directories.push_back(it->path());
-        }
-    }
-
-    std::uintmax_t removed = 0;
-    for (auto& dir : std::views::reverse(directories)) {
-        if (!std::filesystem::is_empty(dir, ec)) {
-            ec.clear();
-            continue;
-        }
-        if (std::filesystem::remove(dir, ec)) {
-            ++removed;
-        } else if (ec) {
-            Log.warn("Failed to remove empty migrated source directory '{}': {}",
-                io::fs_path_to_string(dir), ec.message());
-        }
-        ec.clear();
-    }
-
-    if (includeRoot) {
-        if (std::filesystem::is_empty(root, ec)) {
-            if (std::filesystem::remove(root, ec)) {
-                ++removed;
-            } else if (ec) {
-                Log.warn("Failed to remove empty migrated source root '{}': {}",
-                    io::fs_path_to_string(root), ec.message());
-            }
-        }
-        ec.clear();
-    }
-
-    return removed;
-}
-
-bool ensure_parent_directory(const std::filesystem::path& targetPath, MigrationStats& stats) {
-    std::error_code ec;
-    std::filesystem::create_directories(targetPath.parent_path(), ec);
-    if (ec) {
-        ++stats.failures;
-        Log.warn("Failed to create migration target parent '{}': {}",
-            io::fs_path_to_string(targetPath.parent_path()), ec.message());
-        return false;
-    }
-    return true;
-}
-
-bool remove_migrated_source(const std::filesystem::path& sourcePath, MigrationStats& stats) {
-    std::error_code ec;
-    std::filesystem::remove(sourcePath, ec);
-    if (ec) {
-        ++stats.failures;
-        Log.warn("Migrated '{}' but failed to remove source: {}", io::fs_path_to_string(sourcePath),
-            ec.message());
-        return false;
-    }
-
-    ++stats.sourcesRemoved;
-    return true;
-}
-
-bool try_rename_migration_entry(
-    const std::filesystem::path& sourcePath, const std::filesystem::path& targetPath) {
-    std::error_code ec;
-    if (std::filesystem::exists(targetPath, ec) || std::filesystem::is_symlink(targetPath, ec)) {
-        return false;
-    }
-    ec.clear();
-
-    if (!std::filesystem::exists(sourcePath, ec)) {
-        return false;
-    }
-    ec.clear();
-
-    std::filesystem::create_directories(targetPath.parent_path(), ec);
-    if (ec) {
-        Log.debug("Could not create migration target parent '{}' before rename: {}",
-            io::fs_path_to_string(targetPath.parent_path()), ec.message());
-        return false;
-    }
-
-    std::filesystem::rename(sourcePath, targetPath, ec);
-    if (ec) {
-        Log.debug("Could not rename migration entry '{}' to '{}': {}",
-            io::fs_path_to_string(sourcePath), io::fs_path_to_string(targetPath), ec.message());
-        return false;
-    }
-
-    return true;
-}
-
-void migrate_symlink(const std::filesystem::path& sourcePath,
-    const std::filesystem::path& targetPath, MigrationStats& stats) {
-    std::error_code ec;
-    if (std::filesystem::exists(targetPath, ec) || std::filesystem::is_symlink(targetPath, ec)) {
-        ++stats.skippedExistingTargets;
-        return;
-    }
-    ec.clear();
-
-    const auto linkTarget = std::filesystem::read_symlink(sourcePath, ec);
-    if (ec) {
-        ++stats.failures;
-        Log.warn("Failed to read migration symlink '{}': {}", io::fs_path_to_string(sourcePath),
-            ec.message());
-        return;
-    }
-
-    if (!ensure_parent_directory(targetPath, stats)) {
-        return;
-    }
-
-    const bool targetIsDirectory = std::filesystem::is_directory(sourcePath, ec);
-    if (ec) {
-        Log.debug("Could not resolve symlink target type for '{}': {}",
-            io::fs_path_to_string(sourcePath), ec.message());
-        ec.clear();
-    }
-
-    if (targetIsDirectory) {
-        std::filesystem::create_directory_symlink(linkTarget, targetPath, ec);
-    } else {
-        std::filesystem::create_symlink(linkTarget, targetPath, ec);
-    }
-    if (ec) {
-        ++stats.failures;
-        Log.warn("Failed to migrate symlink '{}' -> '{}' to '{}': {}",
-            io::fs_path_to_string(sourcePath), io::fs_path_to_string(linkTarget),
-            io::fs_path_to_string(targetPath), ec.message());
-        return;
-    }
-
-    ++stats.symlinksCopied;
-    remove_migrated_source(sourcePath, stats);
-}
-
-void migrate_regular_file(const std::filesystem::path& sourcePath,
-    const std::filesystem::path& targetPath, MigrationStats& stats) {
-    std::error_code ec;
-    if (std::filesystem::exists(targetPath, ec)) {
-        ++stats.skippedExistingTargets;
-        return;
-    }
-    ec.clear();
-
-    if (try_rename_migration_entry(sourcePath, targetPath)) {
-        ++stats.filesCopied;
-        ++stats.sourcesRemoved;
-        return;
-    }
-
-    if (!ensure_parent_directory(targetPath, stats)) {
-        return;
-    }
-
-    std::filesystem::copy_file(
-        sourcePath, targetPath, std::filesystem::copy_options::skip_existing, ec);
-    if (ec) {
-        ++stats.failures;
-        Log.warn("Failed to migrate file '{}' to '{}': {}", io::fs_path_to_string(sourcePath),
-            io::fs_path_to_string(targetPath), ec.message());
-        return;
-    }
-
-    ++stats.filesCopied;
-    remove_migrated_source(sourcePath, stats);
-}
-
-void migrate_directory(const std::filesystem::path& from, const std::filesystem::path& to,
-    const std::filesystem::path& prefPath) {
-    if (from.empty() || to.empty() || normalized_path(from) == normalized_path(to)) {
-        Log.debug("Skipping data migration from '{}' to '{}'", io::fs_path_to_string(from),
-            io::fs_path_to_string(to));
-        return;
-    }
-
-    MigrationStats stats;
-
-    std::error_code ec;
-    if (!std::filesystem::exists(from, ec)) {
-        if (ec) {
-            Log.warn("Failed to inspect migration source '{}': {}", io::fs_path_to_string(from),
-                ec.message());
-        } else {
-            Log.debug("Migration source '{}' does not exist", io::fs_path_to_string(from));
-        }
-        return;
-    }
-
-    std::filesystem::create_directories(to, ec);
-    if (ec) {
-        ++stats.failures;
-        Log.warn("Failed to create data directory '{}' for migration: {}",
-            io::fs_path_to_string(to), ec.message());
-        return;
-    }
-
-    std::filesystem::recursive_directory_iterator it(
-        from, std::filesystem::directory_options::skip_permission_denied, ec);
-    if (ec) {
-        Log.warn("Failed to begin migration scan for '{}': {}", io::fs_path_to_string(from),
-            ec.message());
-        return;
-    }
-
-    const std::filesystem::recursive_directory_iterator end;
-    while (it != end) {
-        if (ec) {
-            ++stats.failures;
-            Log.warn(
-                "Migration scan error under '{}': {}", io::fs_path_to_string(from), ec.message());
-            ec.clear();
-        }
-
-        const auto sourcePath = it->path();
-        const auto status = it->symlink_status(ec);
-        if (ec) {
-            ++stats.failures;
-            Log.warn("Failed to inspect migration source '{}': {}",
-                io::fs_path_to_string(sourcePath), ec.message());
-            ec.clear();
-            it.increment(ec);
-            continue;
-        }
-
-        if (should_skip_migration_path(sourcePath, from, to, stats)) {
-            if (std::filesystem::is_directory(status)) {
-                it.disable_recursion_pending();
-            }
-            ec.clear();
-            it.increment(ec);
-            continue;
-        }
-
-        if (!should_migrate_user_data_path(sourcePath, from)) {
-            ++stats.skippedUnsupportedEntries;
-            if (std::filesystem::is_directory(status)) {
-                it.disable_recursion_pending();
-            }
-            ec.clear();
-            it.increment(ec);
-            continue;
-        }
-
-        const auto relativePath = sourcePath.lexically_relative(from);
-        if (relativePath.empty() || relativePath.is_absolute()) {
-            ++stats.failures;
-            Log.warn("Failed to calculate migration relative path for '{}'",
-                io::fs_path_to_string(sourcePath));
-            it.increment(ec);
-            continue;
-        }
-
-        const auto targetPath = to / relativePath;
-        if (std::filesystem::is_symlink(status)) {
-            migrate_symlink(sourcePath, targetPath, stats);
-        } else if (std::filesystem::is_directory(status)) {
-            if (try_rename_migration_entry(sourcePath, targetPath)) {
-                ++stats.directoriesCreated;
-                ++stats.sourcesRemoved;
-                it.disable_recursion_pending();
-            } else {
-                std::filesystem::create_directories(targetPath, ec);
-                if (ec) {
-                    ++stats.failures;
-                    Log.warn("Failed to create migration target directory '{}': {}",
-                        io::fs_path_to_string(targetPath), ec.message());
-                    ec.clear();
-                    it.disable_recursion_pending();
-                } else {
-                    ++stats.directoriesCreated;
-                }
-            }
-        } else if (std::filesystem::is_regular_file(status)) {
-            migrate_regular_file(sourcePath, targetPath, stats);
-        } else {
-            ++stats.skippedUnsupportedEntries;
-        }
-
-        it.increment(ec);
-    }
-
-    const bool includeRoot = normalized_path(from) != normalized_path(prefPath);
-    stats.emptyDirectoriesRemoved = remove_empty_directories(from, includeRoot);
-
-    const bool migratedAnything = stats.filesCopied > 0 || stats.symlinksCopied > 0 ||
-                                  stats.sourcesRemoved > 0 || stats.emptyDirectoriesRemoved > 0 ||
-                                  stats.failures > 0;
-    if (migratedAnything) {
-        Log.info(
-            "Finished data migration from '{}' to '{}': {} files copied, {} symlinks copied, {} "
-            "sources removed, {} empty directories removed, {} existing targets skipped, {} "
-            "descriptor files skipped, {} nested destination paths skipped, {} unsupported entries "
-            "skipped, {} failures",
-            io::fs_path_to_string(from), io::fs_path_to_string(to), stats.filesCopied,
-            stats.symlinksCopied, stats.sourcesRemoved, stats.emptyDirectoriesRemoved,
-            stats.skippedExistingTargets, stats.skippedDescriptorFiles, stats.skippedNestedTargets,
-            stats.skippedUnsupportedEntries, stats.failures);
-    }
-}
-
-void migrate_data(const std::filesystem::path& prefPath, const std::filesystem::path& dataPath,
-    const LocationDescriptor* descriptor) {
-    if (descriptor && !descriptor->previousPath.empty()) {
-        migrate_directory(descriptor->previousPath, dataPath, prefPath);
-    }
-}
-
-void ensure_data_directory(const std::filesystem::path& dataPath) {
-    std::error_code ec;
-    std::filesystem::create_directories(dataPath, ec);
-    if (ec) {
-        Log.fatal("Failed to create data directory '{}': {}", io::fs_path_to_string(dataPath),
-            ec.message());
+        *errorOut = message;
     }
+    Log.warn("{}", message);
+    return false;
 }
 
 }  // namespace
 
-std::filesystem::path base_path_relative(const std::filesystem::path& path) {
-    const auto* basePath = SDL_GetBasePath();
-    if (!basePath) {
-        return path;
+borealis::data::Manager& manager() {
+    static borealis::data::Manager instance{
+        AppInfo,
+        {
+            .defaultPath = {.useDocumentsOnIOS = true},
+            .portableRelativePath = "data",
+            .legacyApps =
+                {
+                    {.orgName = "TwilitRealm", .appName = "Dusk"},
+                },
+            .migration =
+                {
+                    .directories =
+                        {
+                            "texture_replacements",
+                            "USA",
+                            "EUR",
+                            "JAP",
+                        },
+                    .files =
+                        {
+                            "achievements.json",
+                            "config.json",
+                            "controller_ports.dat",
+                            "gamecontrollerdb.txt",
+                            "imgui.ini",
+                            "keyboard_bindings.dat",
+                            "states.json",
+                        },
+                    .extensions = {".controller", ".gci"},
+                    .filenamePatterns =
+                        {
+                            {.prefix = "MemoryCard", .suffix = ".raw"},
+                        },
+                },
+        },
+    };
+    return instance;
+}
+
+Paths initialize_data(const std::filesystem::path& userDirectoryOverride) {
+    const auto status = manager().initialize(userDirectoryOverride);
+    if (!status && status.code != borealis::data::ErrorCode::MigrationIncomplete) {
+        Log.fatal("Failed to initialize data folders: {}", status_message(status));
     }
-    return path_from_utf8(basePath) / path;
+    if (!status) {
+        Log.warn("{} Migration will be retried on the next launch.", status_message(status));
+    }
+    return manager().paths();
+}
+
+std::filesystem::path base_path_relative(const std::filesystem::path& path) {
+    return manager().base_path_relative(path);
+}
+
+std::filesystem::path configured_data_path() {
+    return manager().configured_data_path();
+}
+
+std::filesystem::path cache_path() {
+    return manager().paths().cachePath;
 }
 
 bool open_data_path() {
-#if DUSK_CAN_OPEN_DATA_FOLDER
-    std::error_code ec;
-    std::filesystem::path path = std::filesystem::absolute(ConfigPath, ec);
-    if (ec) {
-        Log.warn("Failed to resolve absolute data folder path '{}': {}",
-            io::fs_path_to_string(ConfigPath), ec.message());
-        path = ConfigPath;
-    }
-
-#if defined(_WIN32)
-    const std::string url = "file:///" + path.generic_string();
-#else
-    const std::string url = "file://" + path.generic_string();
-#endif
-    if (!SDL_OpenURL(url.c_str())) {
-        Log.warn(
-            "Failed to open data folder '{}': {}", io::fs_path_to_string(path), SDL_GetError());
-        return false;
-    }
-    return true;
-#else
-    return false;
-#endif
+    return operation_succeeded(manager().open_active_data_path());
 }
 
 bool set_custom_data_path(const std::filesystem::path& path, std::string* errorOut) {
-    if (!validate_writable_data_path(path, errorOut)) {
-        return false;
-    }
-
-    if (!write_location_descriptor(LocationMode::Custom, path)) {
-        set_error(errorOut, fmt::format("{} could not save the data folder setting.", AppName));
-        return false;
-    }
-
-    return true;
+    return operation_succeeded(manager().set_custom_data_path(path), errorOut);
 }
 
 bool set_custom_data_path(const char* path, std::string* errorOut) {
     if (path == nullptr) {
-        set_error(errorOut, "Choose a folder.");
+        if (errorOut != nullptr) {
+            *errorOut = "Choose a folder.";
+        }
         return false;
     }
-    return set_custom_data_path(path_from_utf8(path), errorOut);
+    return set_custom_data_path(borealis::io::fs_path_from_utf8(path), errorOut);
 }
 
 bool set_portable_data_path() {
-    return write_location_descriptor(LocationMode::Portable, portable_data_path());
+    return operation_succeeded(manager().set_portable_data_path());
 }
 
 bool reset_data_path() {
-    const auto prefPath = active_pref_path();
-    return write_location_descriptor(LocationMode::Default, default_data_path(prefPath));
+    return operation_succeeded(manager().reset_data_path());
 }
 
 bool is_default_data_path() {
-    const auto prefPath = active_pref_path();
-    return normalized_path(configured_data_path()) == normalized_path(default_data_path(prefPath));
-}
-
-std::filesystem::path configured_data_path() {
-    if (sConfiguredDataPath) {
-        return *sConfiguredDataPath;
-    }
-
-    const auto prefPath = active_pref_path();
-    const auto descriptor = read_location_descriptor(prefPath);
-    if (descriptor) {
-        sActiveDescriptorPath = descriptor->path;
-    }
-    sConfiguredDataPath =
-        resolve_data_path(prefPath, descriptor ? &descriptor->descriptor : nullptr);
-    return *sConfiguredDataPath;
-}
-
-std::filesystem::path cache_path() {
-    if (!CachePath.empty()) {
-        return CachePath;
-    }
-    return active_pref_path();
+    return manager().is_default_data_path();
 }
 
 bool is_data_path_restart_pending() {
-    if (ConfigPath.empty()) {
-        return false;
-    }
-
-    return normalized_path(ConfigPath) != normalized_path(configured_data_path());
+    return manager().is_data_path_restart_pending();
 }
 
-Paths initialize_data() {
-    const auto preferredPrefPath = get_pref_path();
-    const auto prefPath =
-        rename_legacy_pref_path(legacy_path_for_pref_path(preferredPrefPath), preferredPrefPath);
-    sActivePrefPath = prefPath;
+std::filesystem::path user_home_path() {
+    return manager().user_home_path();
+}
 
-    const auto descriptor = read_location_descriptor(prefPath);
-    if (descriptor) {
-        sActiveDescriptorPath = descriptor->path;
-    } else {
-        sActiveDescriptorPath.reset();
-    }
-    const auto dataPath =
-        resolve_data_path(prefPath, descriptor ? &descriptor->descriptor : nullptr);
-    sConfiguredDataPath = dataPath;
+std::filesystem::path normalized_display_path(const std::filesystem::path& path) {
+    return manager().normalized_display_path(path);
+}
 
-    migrate_data(prefPath, dataPath, descriptor ? &descriptor->descriptor : nullptr);
-    ensure_data_directory(dataPath);
-    ensure_data_directory(prefPath);
-
-    return Paths{
-        .userPath = dataPath,
-        .cachePath = prefPath,
-    };
+std::string abbreviated_path_string(const std::filesystem::path& path) {
+    return manager().abbreviated_path_string(path);
 }
 
 }  // namespace dusk::data
diff --git a/src/dusk/data.hpp b/src/dusk/data.hpp
index 7e7861dbf0..6ef83368d6 100644
--- a/src/dusk/data.hpp
+++ b/src/dusk/data.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <borealis/data.hpp>
+
 #include <filesystem>
 #include <string>
 
@@ -15,20 +17,12 @@
 #define DUSK_CAN_OPEN_DATA_FOLDER 0
 #endif
 
-#if (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST)
-#define DUSK_CAN_CHANGE_DATA_FOLDER 0
-#else
-#define DUSK_CAN_CHANGE_DATA_FOLDER 1
-#endif
-
 namespace dusk::data {
 
-struct Paths {
-    std::filesystem::path userPath;
-    std::filesystem::path cachePath;
-};
+using Paths = borealis::data::Paths;
 
-Paths initialize_data();
+borealis::data::Manager& manager();
+Paths initialize_data(const std::filesystem::path& userDirectoryOverride = {});
 std::filesystem::path base_path_relative(const std::filesystem::path& path);
 std::filesystem::path configured_data_path();
 std::filesystem::path cache_path();
@@ -39,5 +33,8 @@ bool set_portable_data_path();
 bool reset_data_path();
 bool is_default_data_path();
 bool is_data_path_restart_pending();
+std::filesystem::path user_home_path();
+std::filesystem::path normalized_display_path(const std::filesystem::path& path);
+std::string abbreviated_path_string(const std::filesystem::path& path);
 
 }  // namespace dusk::data
diff --git a/src/dusk/discord.cpp b/src/dusk/discord.cpp
deleted file mode 100644
index f20541bfa4..0000000000
--- a/src/dusk/discord.cpp
+++ /dev/null
@@ -1,867 +0,0 @@
-#ifdef DUSK_DISCORD
-
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-
-#include "discord.hpp"
-
-#include "dusk/logging.h"
-#include "nlohmann/json.hpp"
-
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <condition_variable>
-#include <cstdint>
-#include <cstring>
-#include <deque>
-#include <mutex>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <thread>
-#include <vector>
-
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#define NOMCX
-#define NOSERVICE
-#define NOIME
-#include <windows.h>
-#else
-#include <cerrno>
-#include <cstdlib>
-#include <fcntl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <unistd.h>
-#endif
-
-namespace dusk::discord::rpc {
-namespace {
-
-using json = nlohmann::json;
-
-constexpr uint32_t kRpcVersion = 1;
-constexpr size_t kFrameHeaderSize = sizeof(uint32_t) * 2;
-constexpr size_t kMaxFramePayloadSize = 64 * 1024;
-constexpr auto kIoWait = std::chrono::milliseconds(500);
-constexpr auto kShutdownClearTimeout = std::chrono::milliseconds(200);
-constexpr auto kInitialReconnectDelay = std::chrono::milliseconds(500);
-constexpr auto kMaxReconnectDelay = std::chrono::milliseconds(60 * 1000);
-
-enum class Opcode : uint32_t {
-    Handshake = 0,
-    Frame = 1,
-    Close = 2,
-    Ping = 3,
-    Pong = 4,
-};
-
-enum class ConnectionState {
-    Disconnected,
-    SentHandshake,
-    Connected,
-};
-
-enum class DisconnectCode : int {
-    PipeClosed = 1,
-    ReadCorrupt = 2,
-    BadFrame = 3,
-};
-
-struct Frame {
-    Opcode opcode = Opcode::Frame;
-    std::string payload;
-};
-
-struct QueuedEvent {
-    enum class Type {
-        Ready,
-        Disconnected,
-        Error,
-    };
-
-    Type type = Type::Ready;
-    User user;
-    int code = 0;
-    std::string message;
-};
-
-class Backoff {
-public:
-    std::chrono::milliseconds next_delay() {
-        const auto delay = currentDelay;
-        currentDelay = std::min(currentDelay * 2, kMaxReconnectDelay);
-        return delay;
-    }
-
-    void reset() { currentDelay = kInitialReconnectDelay; }
-
-private:
-    std::chrono::milliseconds currentDelay = kInitialReconnectDelay;
-};
-
-class IpcConnection {
-public:
-    IpcConnection() = default;
-    ~IpcConnection() { close(); }
-
-    IpcConnection(const IpcConnection&) = delete;
-    IpcConnection& operator=(const IpcConnection&) = delete;
-
-    bool open() {
-#ifdef _WIN32
-        wchar_t pipeName[] = L"\\\\?\\pipe\\discord-ipc-0";
-        constexpr size_t kPipeDigit = sizeof(pipeName) / sizeof(wchar_t) - 2;
-
-        for (wchar_t pipeNumber = L'0'; pipeNumber <= L'9'; ++pipeNumber) {
-            pipeName[kPipeDigit] = pipeNumber;
-            pipe = CreateFileW(
-                pipeName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, OPEN_EXISTING, 0, nullptr);
-            if (pipe != INVALID_HANDLE_VALUE) {
-                return true;
-            }
-
-            if (GetLastError() == ERROR_PIPE_BUSY && WaitNamedPipeW(pipeName, 10000)) {
-                --pipeNumber;
-            }
-        }
-        return false;
-#else
-        const auto tempPaths = get_temp_paths();
-        for (const std::string& tempPath : tempPaths) {
-            for (int pipeNumber = 0; pipeNumber < 10; ++pipeNumber) {
-                socketFd = socket(AF_UNIX, SOCK_STREAM, 0);
-                if (socketFd == -1) {
-                    return false;
-                }
-
-                sockaddr_un pipeAddress{};
-                pipeAddress.sun_family = AF_UNIX;
-                const std::string socketPath =
-                    tempPath + "/discord-ipc-" + std::to_string(pipeNumber);
-                if (socketPath.size() >= sizeof(pipeAddress.sun_path)) {
-                    close();
-                    continue;
-                }
-
-                std::strncpy(
-                    pipeAddress.sun_path, socketPath.c_str(), sizeof(pipeAddress.sun_path) - 1);
-                if (connect(socketFd, reinterpret_cast<const sockaddr*>(&pipeAddress),
-                        sizeof(pipeAddress)) == 0)
-                {
-                    fcntl(socketFd, F_SETFL, O_NONBLOCK);
-#ifdef SO_NOSIGPIPE
-                    int optval = 1;
-                    setsockopt(socketFd, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
-#endif
-                    return true;
-                }
-                close();
-            }
-        }
-        return false;
-#endif
-    }
-
-    void close() {
-#ifdef _WIN32
-        if (pipe != INVALID_HANDLE_VALUE) {
-            CloseHandle(pipe);
-            pipe = INVALID_HANDLE_VALUE;
-        }
-#else
-        if (socketFd != -1) {
-            ::close(socketFd);
-            socketFd = -1;
-        }
-#endif
-        pendingRead.clear();
-    }
-
-    bool is_open() const {
-#ifdef _WIN32
-        return pipe != INVALID_HANDLE_VALUE;
-#else
-        return socketFd != -1;
-#endif
-    }
-
-    bool write_frame(const Frame& frame) {
-        std::array<uint8_t, kFrameHeaderSize> header{};
-        write_u32(header.data(), static_cast<uint32_t>(frame.opcode));
-        write_u32(header.data() + sizeof(uint32_t), static_cast<uint32_t>(frame.payload.size()));
-
-        return write_all(header.data(), header.size()) &&
-               write_all(
-                   reinterpret_cast<const uint8_t*>(frame.payload.data()), frame.payload.size());
-    }
-
-    enum class ReadStatus {
-        None,
-        Frame,
-        Closed,
-        Corrupt,
-    };
-
-    ReadStatus read_frame(Frame& frame) {
-        if (!read_available()) {
-            return is_open() ? ReadStatus::None : ReadStatus::Closed;
-        }
-
-        if (pendingRead.size() < kFrameHeaderSize) {
-            return ReadStatus::None;
-        }
-
-        const uint32_t payloadLength = read_u32(pendingRead.data() + sizeof(uint32_t));
-        if (payloadLength > kMaxFramePayloadSize) {
-            return ReadStatus::Corrupt;
-        }
-
-        const size_t frameLength = kFrameHeaderSize + payloadLength;
-        if (pendingRead.size() < frameLength) {
-            return ReadStatus::None;
-        }
-
-        frame.opcode = static_cast<Opcode>(read_u32(pendingRead.data()));
-        frame.payload.assign(
-            reinterpret_cast<const char*>(pendingRead.data() + kFrameHeaderSize), payloadLength);
-        pendingRead.erase(
-            pendingRead.begin(), pendingRead.begin() + static_cast<std::ptrdiff_t>(frameLength));
-        return ReadStatus::Frame;
-    }
-
-private:
-#ifndef _WIN32
-    static std::vector<std::string> get_temp_paths() {
-        std::vector<std::string> paths;
-        for (const char* name : {"XDG_RUNTIME_DIR", "TMPDIR", "TMP", "TEMP"}) {
-            if (const char* value = std::getenv(name); value && value[0] != '\0') {
-                if (std::find(paths.begin(), paths.end(), value) == paths.end()) {
-                    paths.emplace_back(value);
-                }
-            }
-        }
-        if (std::find(paths.begin(), paths.end(), "/tmp") == paths.end()) {
-            paths.emplace_back("/tmp");
-        }
-        return paths;
-    }
-#endif
-
-    static void write_u32(uint8_t* out, uint32_t value) {
-        out[0] = static_cast<uint8_t>(value & 0xff);
-        out[1] = static_cast<uint8_t>((value >> 8) & 0xff);
-        out[2] = static_cast<uint8_t>((value >> 16) & 0xff);
-        out[3] = static_cast<uint8_t>((value >> 24) & 0xff);
-    }
-
-    static uint32_t read_u32(const uint8_t* in) {
-        return static_cast<uint32_t>(in[0]) | (static_cast<uint32_t>(in[1]) << 8) |
-               (static_cast<uint32_t>(in[2]) << 16) | (static_cast<uint32_t>(in[3]) << 24);
-    }
-
-    bool write_all(const uint8_t* data, size_t length) {
-        size_t written = 0;
-        while (written < length) {
-#ifdef _WIN32
-            DWORD bytesWritten = 0;
-            if (WriteFile(pipe, data + written, static_cast<DWORD>(length - written), &bytesWritten,
-                    nullptr) == FALSE ||
-                bytesWritten == 0)
-            {
-                close();
-                return false;
-            }
-            written += bytesWritten;
-#else
-#ifdef MSG_NOSIGNAL
-            constexpr int kMsgFlags = MSG_NOSIGNAL;
-#else
-            constexpr int kMsgFlags = 0;
-#endif
-            const ssize_t bytesWritten =
-                send(socketFd, data + written, length - written, kMsgFlags);
-            if (bytesWritten < 0) {
-                if (errno == EAGAIN || errno == EWOULDBLOCK) {
-                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
-                    continue;
-                }
-                close();
-                return false;
-            }
-            if (bytesWritten == 0) {
-                close();
-                return false;
-            }
-            written += static_cast<size_t>(bytesWritten);
-#endif
-        }
-        return true;
-    }
-
-    bool read_available() {
-        std::array<uint8_t, 4096> buffer{};
-        bool readAny = false;
-
-        for (;;) {
-#ifdef _WIN32
-            DWORD bytesAvailable = 0;
-            if (PeekNamedPipe(pipe, nullptr, 0, nullptr, &bytesAvailable, nullptr) == FALSE) {
-                close();
-                return readAny;
-            }
-            if (bytesAvailable == 0) {
-                return readAny;
-            }
-
-            const DWORD bytesToRead =
-                std::min<DWORD>(bytesAvailable, static_cast<DWORD>(buffer.size()));
-            DWORD bytesRead = 0;
-            if (ReadFile(pipe, buffer.data(), bytesToRead, &bytesRead, nullptr) == FALSE) {
-                close();
-                return readAny;
-            }
-            if (bytesRead == 0) {
-                close();
-                return readAny;
-            }
-            pendingRead.insert(pendingRead.end(), buffer.begin(), buffer.begin() + bytesRead);
-            readAny = true;
-#else
-#ifdef MSG_NOSIGNAL
-            constexpr int kMsgFlags = MSG_NOSIGNAL;
-#else
-            constexpr int kMsgFlags = 0;
-#endif
-            const ssize_t bytesRead = recv(socketFd, buffer.data(), buffer.size(), kMsgFlags);
-            if (bytesRead < 0) {
-                if (errno == EAGAIN || errno == EWOULDBLOCK) {
-                    return readAny;
-                }
-                close();
-                return readAny;
-            }
-            if (bytesRead == 0) {
-                close();
-                return readAny;
-            }
-            pendingRead.insert(pendingRead.end(), buffer.begin(), buffer.begin() + bytesRead);
-            readAny = true;
-#endif
-        }
-    }
-
-#ifdef _WIN32
-    HANDLE pipe = INVALID_HANDLE_VALUE;
-#else
-    int socketFd = -1;
-#endif
-    std::vector<uint8_t> pendingRead;
-};
-
-int current_process_id() {
-#ifdef _WIN32
-    return static_cast<int>(GetCurrentProcessId());
-#else
-    return static_cast<int>(getpid());
-#endif
-}
-
-std::string next_nonce() {
-    static std::atomic_uint64_t sNonce{1};
-    return std::to_string(sNonce.fetch_add(1));
-}
-
-const json* find_member(const json& object, const char* key) {
-    if (!object.is_object()) {
-        return nullptr;
-    }
-
-    const auto member = object.find(key);
-    if (member == object.end()) {
-        return nullptr;
-    }
-    return &*member;
-}
-
-std::string json_string_member(const json& object, const char* key) {
-    const json* member = find_member(object, key);
-    if (!member || !member->is_string()) {
-        return {};
-    }
-    return member->get<std::string>();
-}
-
-int json_int_member(const json& object, const char* key, int defaultValue) {
-    const json* member = find_member(object, key);
-    if (!member || !member->is_number_integer()) {
-        return defaultValue;
-    }
-
-    try {
-        return member->get<int>();
-    } catch (const json::exception&) {
-        return defaultValue;
-    }
-}
-
-json make_presence_activity(const Presence& presence) {
-    json activity = json::object();
-
-    if (!presence.state.empty()) {
-        activity["state"] = presence.state;
-    }
-    if (!presence.details.empty()) {
-        activity["details"] = presence.details;
-    }
-    if (presence.startTimestamp != 0) {
-        activity["timestamps"] = {{"start", presence.startTimestamp}};
-    }
-    if (!presence.largeImageKey.empty() || !presence.largeImageText.empty()) {
-        json assets = json::object();
-        if (!presence.largeImageKey.empty()) {
-            assets["large_image"] = presence.largeImageKey;
-        }
-        if (!presence.largeImageText.empty()) {
-            assets["large_text"] = presence.largeImageText;
-        }
-        activity["assets"] = std::move(assets);
-    }
-
-    return activity;
-}
-
-Frame make_handshake_frame(std::string_view applicationId) {
-    return {
-        Opcode::Handshake,
-        json{
-            {"v", kRpcVersion},
-            {"client_id", std::string(applicationId)},
-        }
-            .dump(),
-    };
-}
-
-Frame make_set_activity_frame(std::string nonce, int pid, std::optional<Presence> presence) {
-    json args = {{"pid", pid}};
-    if (presence) {
-        args["activity"] = make_presence_activity(*presence);
-    } else {
-        args["activity"] = nullptr;
-    }
-
-    return {
-        Opcode::Frame,
-        json{
-            {"cmd", "SET_ACTIVITY"},
-            {"nonce", std::move(nonce)},
-            {"args", std::move(args)},
-        }
-            .dump(),
-    };
-}
-
-class Client {
-public:
-    void initialize(std::string applicationId, EventHandlers handlers) {
-        shutdown();
-
-        {
-            std::lock_guard lock(mutex);
-            this->applicationId = std::move(applicationId);
-            this->handlers = std::move(handlers);
-            shouldRun = true;
-            queuedPresence.reset();
-            hasQueuedPresence = false;
-            clearRequested = false;
-            sentInitialConnectLog = false;
-        }
-
-        ioThread = std::thread([this] { io_loop(); });
-    }
-
-    void run_callbacks() {
-        std::deque<QueuedEvent> events;
-        EventHandlers localHandlers;
-        {
-            std::lock_guard lock(mutex);
-            events.swap(queuedEvents);
-            localHandlers = handlers;
-        }
-
-        for (const QueuedEvent& event : events) {
-            switch (event.type) {
-            case QueuedEvent::Type::Ready:
-                if (localHandlers.ready) {
-                    localHandlers.ready(event.user);
-                }
-                break;
-            case QueuedEvent::Type::Disconnected:
-                if (localHandlers.disconnected) {
-                    localHandlers.disconnected(event.code, event.message);
-                }
-                break;
-            case QueuedEvent::Type::Error:
-                if (localHandlers.error) {
-                    localHandlers.error(event.code, event.message);
-                }
-                break;
-            }
-        }
-    }
-
-    void update_presence(Presence presence) {
-        {
-            std::lock_guard lock(mutex);
-            if (!shouldRun) {
-                return;
-            }
-            queuedPresence = std::move(presence);
-            hasQueuedPresence = true;
-        }
-        cv.notify_all();
-    }
-
-    void clear_presence() {
-        {
-            std::lock_guard lock(mutex);
-            if (!shouldRun) {
-                return;
-            }
-            queuedPresence.reset();
-            hasQueuedPresence = false;
-            clearRequested = true;
-        }
-        cv.notify_all();
-    }
-
-    void shutdown() {
-        {
-            std::lock_guard lock(mutex);
-            if (!shouldRun && !ioThread.joinable()) {
-                return;
-            }
-            shouldRun = false;
-            clearRequested = true;
-        }
-        cv.notify_all();
-
-        if (ioThread.joinable()) {
-            ioThread.join();
-        }
-
-        std::lock_guard lock(mutex);
-        queuedPresence.reset();
-        hasQueuedPresence = false;
-        clearRequested = false;
-        queuedEvents.clear();
-        handlers = {};
-        applicationId.clear();
-    }
-
-private:
-    void io_loop() {
-        IpcConnection connection;
-        ConnectionState state = ConnectionState::Disconnected;
-        Backoff reconnectBackoff;
-        auto nextConnect = std::chrono::steady_clock::now();
-        const int pid = current_process_id();
-        std::string localApplicationId;
-
-        for (;;) {
-            {
-                std::unique_lock lock(mutex);
-                if (!shouldRun) {
-                    break;
-                }
-                localApplicationId = applicationId;
-            }
-
-            const auto now = std::chrono::steady_clock::now();
-            if (state == ConnectionState::Disconnected && now >= nextConnect) {
-                if (connection.open()) {
-                    if (connection.write_frame(make_handshake_frame(localApplicationId))) {
-                        state = ConnectionState::SentHandshake;
-                    } else {
-                        connection.close();
-                    }
-                }
-
-                if (state == ConnectionState::Disconnected) {
-                    log_waiting_for_discord_once();
-                    nextConnect = now + reconnectBackoff.next_delay();
-                }
-            }
-
-            if (state != ConnectionState::Disconnected) {
-                process_reads(connection, state, reconnectBackoff, nextConnect);
-            }
-
-            if (state == ConnectionState::Connected) {
-                flush_pending_presence(connection, pid);
-            }
-
-            std::unique_lock lock(mutex);
-            if (!shouldRun) {
-                break;
-            }
-            cv.wait_for(lock, kIoWait);
-        }
-
-        flush_shutdown_clear(connection, state, pid);
-        connection.close();
-    }
-
-    void process_reads(IpcConnection& connection, ConnectionState& state, Backoff& reconnectBackoff,
-        std::chrono::steady_clock::time_point& nextConnect) {
-        for (;;) {
-            Frame frame;
-            const auto status = connection.read_frame(frame);
-            if (status == IpcConnection::ReadStatus::None) {
-                return;
-            }
-            if (status == IpcConnection::ReadStatus::Closed) {
-                handle_disconnect(connection, state, reconnectBackoff, nextConnect,
-                    static_cast<int>(DisconnectCode::PipeClosed), "Pipe closed");
-                return;
-            }
-            if (status == IpcConnection::ReadStatus::Corrupt) {
-                handle_disconnect(connection, state, reconnectBackoff, nextConnect,
-                    static_cast<int>(DisconnectCode::ReadCorrupt), "Oversized Discord IPC frame");
-                return;
-            }
-
-            switch (frame.opcode) {
-            case Opcode::Frame:
-                process_json_frame(frame.payload, state, reconnectBackoff);
-                break;
-            case Opcode::Close:
-                process_close_frame(
-                    frame.payload, connection, state, reconnectBackoff, nextConnect);
-                return;
-            case Opcode::Ping:
-                connection.write_frame({Opcode::Pong, frame.payload});
-                break;
-            case Opcode::Pong:
-                break;
-            case Opcode::Handshake:
-            default:
-                handle_disconnect(connection, state, reconnectBackoff, nextConnect,
-                    static_cast<int>(DisconnectCode::BadFrame), "Bad Discord IPC frame");
-                return;
-            }
-        }
-    }
-
-    void process_json_frame(
-        const std::string& payload, ConnectionState& state, Backoff& reconnectBackoff) {
-        json message;
-        try {
-            message = json::parse(payload);
-        } catch (const json::parse_error&) {
-            enqueue_error(
-                static_cast<int>(DisconnectCode::ReadCorrupt), "Invalid Discord IPC JSON");
-            return;
-        }
-
-        const std::string cmd = json_string_member(message, "cmd");
-        const std::string evt = json_string_member(message, "evt");
-
-        if (state == ConnectionState::SentHandshake && cmd == "DISPATCH" && evt == "READY") {
-            state = ConnectionState::Connected;
-            reconnectBackoff.reset();
-            enqueue_ready(message);
-            return;
-        }
-
-        if (evt == "ERROR") {
-            const json* data = find_member(message, "data");
-            enqueue_error(data ? json_int_member(*data, "code", 0) : 0,
-                data ? json_string_member(*data, "message") : std::string{});
-        }
-    }
-
-    void process_close_frame(const std::string& payload, IpcConnection& connection,
-        ConnectionState& state, Backoff& reconnectBackoff,
-        std::chrono::steady_clock::time_point& nextConnect) {
-        int code = static_cast<int>(DisconnectCode::PipeClosed);
-        std::string message = "Discord closed IPC connection";
-
-        try {
-            const json closePayload = json::parse(payload);
-            code = json_int_member(closePayload, "code", code);
-            const std::string closeMessage = json_string_member(closePayload, "message");
-            if (!closeMessage.empty()) {
-                message = closeMessage;
-            }
-        } catch (const json::exception&) {
-        }
-
-        handle_disconnect(connection, state, reconnectBackoff, nextConnect, code, message);
-    }
-
-    void handle_disconnect(IpcConnection& connection, ConnectionState& state,
-        Backoff& reconnectBackoff, std::chrono::steady_clock::time_point& nextConnect, int code,
-        std::string_view message) {
-        const bool wasConnected =
-            state == ConnectionState::Connected || state == ConnectionState::SentHandshake;
-        connection.close();
-        state = ConnectionState::Disconnected;
-        nextConnect = std::chrono::steady_clock::now() + reconnectBackoff.next_delay();
-        if (wasConnected) {
-            enqueue_disconnected(code, message);
-        }
-    }
-
-    void flush_pending_presence(IpcConnection& connection, int pid) {
-        std::optional<Presence> presence;
-        bool shouldClear = false;
-        {
-            std::lock_guard lock(mutex);
-            if (hasQueuedPresence) {
-                presence = queuedPresence;
-                hasQueuedPresence = false;
-            } else if (clearRequested) {
-                shouldClear = true;
-                clearRequested = false;
-            }
-        }
-
-        if (presence) {
-            if (!connection.write_frame(
-                    make_set_activity_frame(next_nonce(), pid, std::move(presence))))
-            {
-                requeue_presence();
-            }
-        } else if (shouldClear) {
-            connection.write_frame(make_set_activity_frame(next_nonce(), pid, std::nullopt));
-        }
-    }
-
-    void flush_shutdown_clear(IpcConnection& connection, ConnectionState state, int pid) {
-        if (state != ConnectionState::Connected || !connection.is_open()) {
-            return;
-        }
-
-        connection.write_frame(make_set_activity_frame(next_nonce(), pid, std::nullopt));
-        const auto deadline = std::chrono::steady_clock::now() + kShutdownClearTimeout;
-        while (std::chrono::steady_clock::now() < deadline) {
-            Frame frame;
-            const auto status = connection.read_frame(frame);
-            if (status == IpcConnection::ReadStatus::None) {
-                std::this_thread::sleep_for(std::chrono::milliseconds(10));
-                continue;
-            }
-            if (status != IpcConnection::ReadStatus::Frame) {
-                break;
-            }
-            if (frame.opcode == Opcode::Ping) {
-                connection.write_frame({Opcode::Pong, frame.payload});
-            }
-        }
-    }
-
-    void requeue_presence() {
-        std::lock_guard lock(mutex);
-        if (queuedPresence) {
-            hasQueuedPresence = true;
-        }
-    }
-
-    void enqueue_ready(const json& readyMessage) {
-        User user;
-        const auto data = readyMessage.find("data");
-        if (data != readyMessage.end() && data->is_object()) {
-            const auto userIt = data->find("user");
-            if (userIt != data->end() && userIt->is_object()) {
-                user.id = json_string_member(*userIt, "id");
-                user.username = json_string_member(*userIt, "username");
-                user.discriminator = json_string_member(*userIt, "discriminator");
-                user.avatar = json_string_member(*userIt, "avatar");
-            }
-        }
-
-        std::lock_guard lock(mutex);
-        queuedEvents.push_back({QueuedEvent::Type::Ready, std::move(user)});
-    }
-
-    void enqueue_disconnected(int code, std::string_view message) {
-        std::lock_guard lock(mutex);
-        QueuedEvent event;
-        event.type = QueuedEvent::Type::Disconnected;
-        event.code = code;
-        event.message = message;
-        queuedEvents.push_back(std::move(event));
-    }
-
-    void enqueue_error(int code, std::string_view message) {
-        std::lock_guard lock(mutex);
-        QueuedEvent event;
-        event.type = QueuedEvent::Type::Error;
-        event.code = code;
-        event.message = message;
-        queuedEvents.push_back(std::move(event));
-    }
-
-    void log_waiting_for_discord_once() {
-        bool shouldLog = false;
-        {
-            std::lock_guard lock(mutex);
-            if (!sentInitialConnectLog) {
-                sentInitialConnectLog = true;
-                shouldLog = true;
-            }
-        }
-        if (shouldLog) {
-            DuskLog.info("Discord: Waiting for local Discord IPC");
-        }
-    }
-
-    std::mutex mutex;
-    std::condition_variable cv;
-    std::thread ioThread;
-    std::string applicationId;
-    EventHandlers handlers;
-    std::deque<QueuedEvent> queuedEvents;
-    std::optional<Presence> queuedPresence;
-    bool hasQueuedPresence = false;
-    bool clearRequested = false;
-    bool shouldRun = false;
-    bool sentInitialConnectLog = false;
-};
-
-Client& client() {
-    static Client sClient;
-    return sClient;
-}
-
-}  // namespace
-
-void initialize(std::string applicationId, EventHandlers handlers) {
-    client().initialize(std::move(applicationId), std::move(handlers));
-}
-
-void run_callbacks() {
-    client().run_callbacks();
-}
-
-void update_presence(Presence presence) {
-    client().update_presence(std::move(presence));
-}
-
-void clear_presence() {
-    client().clear_presence();
-}
-
-void shutdown() {
-    client().shutdown();
-}
-
-}  // namespace dusk::discord::rpc
-
-#endif  // DUSK_DISCORD
diff --git a/src/dusk/discord.hpp b/src/dusk/discord.hpp
deleted file mode 100644
index 67f54ff2f3..0000000000
--- a/src/dusk/discord.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-
-#ifdef DUSK_DISCORD
-
-#include <cstdint>
-#include <functional>
-#include <string>
-#include <string_view>
-
-namespace dusk::discord::rpc {
-
-struct User {
-    std::string id;
-    std::string username;
-    std::string discriminator;
-    std::string avatar;
-};
-
-struct Presence {
-    std::string state;
-    std::string details;
-    int64_t startTimestamp = 0;
-    std::string largeImageKey;
-    std::string largeImageText;
-};
-
-struct EventHandlers {
-    std::function<void(const User&)> ready;
-    std::function<void(int, std::string_view)> disconnected;
-    std::function<void(int, std::string_view)> error;
-};
-
-void initialize(std::string applicationId, EventHandlers handlers);
-void run_callbacks();
-void update_presence(Presence presence);
-void clear_presence();
-void shutdown();
-
-}  // namespace dusk::discord::rpc
-
-#endif  // DUSK_DISCORD
diff --git a/src/dusk/discord_presence.cpp b/src/dusk/discord_presence.cpp
index cad28148bc..29e4f27617 100644
--- a/src/dusk/discord_presence.cpp
+++ b/src/dusk/discord_presence.cpp
@@ -1,12 +1,15 @@
-#ifdef DUSK_DISCORD
+#if BOREALIS_HAS_DISCORD
+#include "discord_presence.hpp"
+
+#include "app_info.hpp"
+#include "logging.h"
+#include "main.h"
+#include "map_loader_definitions.h"
 
-#include "dusk/discord_presence.hpp"
 #include "d/d_com_inf_game.h"
-#include "discord.hpp"
-#include "dusk/logging.h"
-#include "dusk/main.h"
-#include "dusk/map_loader_definitions.h"
-#include "fmt/format.h"
+
+#include <borealis/discord.hpp>
+#include <fmt/format.h>
 
 #include <chrono>
 #include <string>
@@ -14,21 +17,22 @@
 #include <utility>
 
 namespace dusk::discord {
+namespace {
+constexpr borealis::Log Log{"dusk::discord"};
+int64_t g_startTime = 0;
+bool g_initialized = false;
+}  // namespace
 
-static int64_t g_startTime = 0;
-static bool g_initialized = false;
-static constexpr const char* kApplicationId = "1495632471994405035";
-
-static void on_ready(const rpc::User& user) {
-    DuskLog.info("Discord: Connected as {}", user.username);
+static void on_ready(const borealis::discord::User& user) {
+    Log.info("Connected as {}", user.username);
 }
 
 static void on_disconnected(int errorCode, std::string_view message) {
-    DuskLog.warn("Discord: Disconnected ({}: {})", errorCode, message);
+    Log.warn("Disconnected ({}: {})", errorCode, message);
 }
 
 static void on_error(int errorCode, std::string_view message) {
-    DuskLog.warn("Discord: Error ({}: {})", errorCode, message);
+    Log.warn("Error ({}: {})", errorCode, message);
 }
 
 static const char* lookup_map_name(const char* mapFile) {
@@ -49,20 +53,22 @@ void initialize() {
         std::chrono::system_clock::now().time_since_epoch())
                       .count();
 
-    rpc::EventHandlers handlers{};
+    borealis::discord::EventHandlers handlers{};
     handlers.ready = on_ready;
     handlers.disconnected = on_disconnected;
     handlers.error = on_error;
-    rpc::initialize(kApplicationId, std::move(handlers));
-    g_initialized = true;
+    g_initialized = borealis::discord::initialize(AppInfo, std::move(handlers));
+    if (!g_initialized) {
+        return;
+    }
 
-    DuskLog.info("Discord Rich Presence initialized");
+    Log.info("Discord Rich Presence initialized");
 }
 
 void run_callbacks() {
     if (!g_initialized)
         return;
-    rpc::run_callbacks();
+    borealis::discord::run_callbacks();
 }
 
 void update_presence() {
@@ -78,7 +84,7 @@ void update_presence() {
     static std::string sDetailsBuf;
     static std::string sStateBuf;
 
-    rpc::Presence presence{};
+    borealis::discord::Presence presence{};
     presence.startTimestamp = g_startTime;
     presence.largeImageKey = "icon";
     presence.largeImageText = "Dusklight";
@@ -105,19 +111,20 @@ void update_presence() {
         }
     }
 
-    rpc::update_presence(std::move(presence));
-    DuskLog.debug("Discord Rich Presence sent");
+    if (borealis::discord::update_presence(std::move(presence))) {
+        Log.debug("Discord Rich Presence changed");
+    }
 }
 
 void shutdown() {
     if (!g_initialized)
         return;
-    rpc::clear_presence();
-    rpc::shutdown();
+    borealis::discord::clear_presence();
+    borealis::discord::shutdown();
     g_initialized = false;
-    DuskLog.info("Discord Rich Presence shut down");
+    Log.info("Discord Rich Presence shut down");
 }
 
 }  // namespace dusk::discord
 
-#endif  // DUSK_DISCORD
+#endif  // BOREALIS_HAS_DISCORD
diff --git a/include/dusk/discord_presence.hpp b/src/dusk/discord_presence.hpp
similarity index 73%
rename from include/dusk/discord_presence.hpp
rename to src/dusk/discord_presence.hpp
index ebecc2d07b..ddda8c3948 100644
--- a/include/dusk/discord_presence.hpp
+++ b/src/dusk/discord_presence.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#ifdef DUSK_DISCORD
+#if BOREALIS_HAS_DISCORD
 
 namespace dusk::discord {
 
@@ -11,4 +11,4 @@ void shutdown();
 
 }  // namespace dusk::discord
 
-#endif  // DUSK_DISCORD
+#endif  // BOREALIS_HAS_DISCORD
diff --git a/include/dusk/dusk.h b/src/dusk/dusk.h
similarity index 82%
rename from include/dusk/dusk.h
rename to src/dusk/dusk.h
index 911ddbb535..e360a24d26 100644
--- a/include/dusk/dusk.h
+++ b/src/dusk/dusk.h
@@ -1,9 +1,7 @@
-#ifndef DUSK_DUSK_H
-#define DUSK_DUSK_H
+#pragma once
 
 #include <aurora/aurora.h>
-
-#include "aurora/gfx.h"
+#include <aurora/gfx.h>
 
 extern AuroraInfo auroraInfo;
 
@@ -19,5 +17,3 @@ constexpr u32 defaultAspectRatioW = 19;
 constexpr u32 defaultAspectRatioH = 14;
 
 static_assert(defaultWindowWidth / defaultAspectRatioW == defaultWindowHeight / defaultAspectRatioH);
-
-#endif  // DUSK_DUSK_H
diff --git a/src/dusk/dvd_asset.cpp b/src/dusk/dvd_asset.cpp
index 75c82107cc..335b1c5572 100644
--- a/src/dusk/dvd_asset.cpp
+++ b/src/dusk/dvd_asset.cpp
@@ -1,12 +1,13 @@
 #include "dusk/dvd_asset.hpp"
+
 #include "dusk/logging.h"
-#include "dusk/endian.h"
-#include "dolphin/dvd.h"
+#include "helpers/endian.h"
+
 #include "DynamicLink.h"
 #include "JSystem/JKernel/JKRArchive.h"
 #include "JSystem/JKernel/JKRDvdRipper.h"
 
-#include <cstring>
+#include <dolphin/dvd.h>
 
 namespace dusk {
 
diff --git a/include/dusk/dvd_asset.hpp b/src/dusk/dvd_asset.hpp
similarity index 61%
rename from include/dusk/dvd_asset.hpp
rename to src/dusk/dvd_asset.hpp
index 8594d4631c..d1ce5f3e39 100644
--- a/include/dusk/dvd_asset.hpp
+++ b/src/dusk/dvd_asset.hpp
@@ -23,9 +23,20 @@ bool LoadDolAsset(void* dst, std::initializer_list<OffsetVersion> virtualAddress
  */
 bool LoadRelAsset(void* dst, const char* dvdPath, std::initializer_list<OffsetVersion> offset, s32 size);
 
+template <typename T, size_t N>
+bool LoadRelAsset(T (&dst)[N], const char* dvdPath, std::initializer_list<OffsetVersion> offset) {
+    return LoadRelAsset(static_cast<void*>(dst), dvdPath, offset, static_cast<s32>(sizeof(dst)));
+}
+
 /**
  * Load bytes from a REL inside RELS.arc
  */
 bool LoadArchivedRelAsset(void* dst, u32 memType, const char* relFileName, std::initializer_list<OffsetVersion> offset, s32 size);
 
+template <typename T, size_t N>
+bool LoadArchivedRelAsset(T (&dst)[N], u32 memType, const char* relFileName,
+                          std::initializer_list<OffsetVersion> offset) {
+    return LoadArchivedRelAsset(static_cast<void*>(dst), memType, relFileName, offset, static_cast<s32>(sizeof(dst)));
+}
+
 }  // namespace dusk
diff --git a/src/dusk/extras.c b/src/dusk/extras.c
index a1fb26e998..ec81d45f9d 100644
--- a/src/dusk/extras.c
+++ b/src/dusk/extras.c
@@ -68,11 +68,3 @@ int strnicmp(const char* str1, const char* str2, int n) {
     return 0;
 }
 #endif
-
-void DCZeroRange(void* addr, uint32_t nBytes) {
-#if defined(_MSC_VER) || TARGET_ANDROID
-    memset(addr, 0, nBytes);
-#else
-    bzero(addr, nBytes);
-#endif
-}
diff --git a/include/dusk/extras.h b/src/dusk/extras.h
similarity index 73%
rename from include/dusk/extras.h
rename to src/dusk/extras.h
index 562ca051c1..8a3d633a3f 100644
--- a/include/dusk/extras.h
+++ b/src/dusk/extras.h
@@ -1,5 +1,4 @@
-#ifndef _SRC_EXTRAS_H_
-#define _SRC_EXTRAS_H_
+#pragma once
 
 #ifdef __cplusplus
 extern "C" {
@@ -13,5 +12,3 @@ int stricmp(const char* str1, const char* str2);
 #ifdef __cplusplus
 }
 #endif
-
-#endif // _SRC_EXTRAS_H_
diff --git a/src/dusk/file_select.cpp b/src/dusk/file_select.cpp
deleted file mode 100644
index c2277b61fc..0000000000
--- a/src/dusk/file_select.cpp
+++ /dev/null
@@ -1,314 +0,0 @@
-#include "file_select.hpp"
-
-#include <memory>
-#include <string_view>
-
-#include <SDL3/SDL_dialog.h>
-#include <SDL3/SDL_error.h>
-#include <SDL3/SDL_init.h>
-#include <SDL3/SDL_stdinc.h>
-
-#if defined(__ANDROID__) || defined(ANDROID)
-#include <SDL3/SDL_system.h>
-#include <jni.h>
-#endif
-
-#if defined(__APPLE__)
-#include <TargetConditionals.h>
-#endif
-
-#if defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_TV && !TARGET_OS_MACCATALYST
-#define USE_MACOS_FOLDER_DIALOG 1
-#else
-#define USE_MACOS_FOLDER_DIALOG 0
-#endif
-
-#if defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST
-#define USE_IOS_DIALOG 1
-#include "ios/FileSelectDialog.h"
-#else
-#define USE_IOS_DIALOG 0
-#endif
-
-#if USE_MACOS_FOLDER_DIALOG
-namespace dusk {
-bool ShowMacOSFolderSelect(
-    FileCallback callback, void* userdata, SDL_Window* window, const char* default_location);
-}  // namespace dusk
-#endif
-
-namespace dusk {
-namespace {
-
-std::string fallback_display_name(std::string_view path) {
-    if (path.empty()) {
-        return {};
-    }
-
-    std::string pathString(path);
-    while (pathString.size() > 1 && (pathString.back() == '/' || pathString.back() == '\\')) {
-        pathString.pop_back();
-    }
-
-    const std::size_t slash = pathString.find_last_of("/\\");
-    if (slash == std::string::npos || slash + 1 >= pathString.size()) {
-        return pathString;
-    }
-    return pathString.substr(slash + 1);
-}
-
-#if defined(__ANDROID__) || defined(ANDROID)
-bool clear_pending_exception(JNIEnv* env) {
-    if (env == nullptr || !env->ExceptionCheck()) {
-        return false;
-    }
-    env->ExceptionClear();
-    return true;
-}
-
-std::string to_string(JNIEnv* env, jstring value) {
-    if (env == nullptr || value == nullptr) {
-        return {};
-    }
-
-    const char* utf8 = env->GetStringUTFChars(value, nullptr);
-    if (utf8 == nullptr) {
-        clear_pending_exception(env);
-        return {};
-    }
-
-    std::string result(utf8);
-    env->ReleaseStringUTFChars(value, utf8);
-    return result;
-}
-
-std::string android_display_name(std::string_view path) {
-    auto* env = static_cast<JNIEnv*>(SDL_GetAndroidJNIEnv());
-    if (env == nullptr) {
-        return {};
-    }
-
-    jobject activity = static_cast<jobject>(SDL_GetAndroidActivity());
-    if (activity == nullptr || clear_pending_exception(env)) {
-        if (activity != nullptr) {
-            env->DeleteLocalRef(activity);
-        }
-        return {};
-    }
-
-    jclass activityClass = env->GetObjectClass(activity);
-    if (activityClass == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return {};
-    }
-
-    jmethodID getDisplayName = env->GetMethodID(
-        activityClass, "getDisplayNameForUri", "(Ljava/lang/String;)Ljava/lang/String;");
-    env->DeleteLocalRef(activityClass);
-    if (getDisplayName == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return {};
-    }
-
-    jstring uri = env->NewStringUTF(std::string(path).c_str());
-    if (uri == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return {};
-    }
-
-    auto* displayName = static_cast<jstring>(env->CallObjectMethod(activity, getDisplayName, uri));
-    env->DeleteLocalRef(uri);
-    env->DeleteLocalRef(activity);
-    if (displayName == nullptr || clear_pending_exception(env)) {
-        return {};
-    }
-
-    std::string result = to_string(env, displayName);
-    env->DeleteLocalRef(displayName);
-    return result;
-}
-
-struct AndroidFolderDialogState {
-    FileCallback callback;
-    void* userdata;
-    std::string path;
-    std::string error;
-};
-
-void onAndroidFolderDialogFinished(void* userdata) {
-    std::unique_ptr<AndroidFolderDialogState> state(
-        static_cast<AndroidFolderDialogState*>(userdata));
-
-    const char* path = state->path.empty() ? nullptr : state->path.c_str();
-    const char* error = state->error.empty() ? nullptr : state->error.c_str();
-    state->callback(state->userdata, path, error);
-}
-
-bool show_android_folder_select(AndroidFolderDialogState* state) {
-    auto* env = static_cast<JNIEnv*>(SDL_GetAndroidJNIEnv());
-    if (env == nullptr) {
-        return false;
-    }
-
-    jobject activity = static_cast<jobject>(SDL_GetAndroidActivity());
-    if (activity == nullptr || clear_pending_exception(env)) {
-        if (activity != nullptr) {
-            env->DeleteLocalRef(activity);
-        }
-        return false;
-    }
-
-    jclass activityClass = env->GetObjectClass(activity);
-    if (activityClass == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return false;
-    }
-
-    jmethodID showFolderDialog =
-        env->GetMethodID(activityClass, "showFolderDialog", "(J)Z");
-    env->DeleteLocalRef(activityClass);
-    if (showFolderDialog == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(activity);
-        return false;
-    }
-
-    const jboolean shown = env->CallBooleanMethod(
-        activity, showFolderDialog, reinterpret_cast<jlong>(state));
-    env->DeleteLocalRef(activity);
-    if (clear_pending_exception(env)) {
-        return false;
-    }
-
-    return shown == JNI_TRUE;
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_dev_twilitrealm_dusk_DuskActivity_nativeFolderDialogResult(
-    JNIEnv* env, jclass, jlong userdata, jstring path, jstring error) {
-    auto* state = reinterpret_cast<AndroidFolderDialogState*>(userdata);
-    if (state == nullptr) {
-        return;
-    }
-
-    state->path = to_string(env, path);
-    state->error = to_string(env, error);
-
-    if (!SDL_RunOnMainThread(&onAndroidFolderDialogFinished, state, false)) {
-        onAndroidFolderDialogFinished(state);
-    }
-}
-#endif
-
-#if USE_IOS_DIALOG
-struct IOSDialogCallbackState {
-    FileCallback callback;
-    void* userdata;
-};
-
-void onIOSDialogFinished(void* userdata, const char* path, const char* error) {
-    std::unique_ptr<IOSDialogCallbackState> state(static_cast<IOSDialogCallbackState*>(userdata));
-
-    if (error != nullptr) {
-        state->callback(state->userdata, nullptr, error);
-        return;
-    }
-
-    if (path == nullptr) {
-        state->callback(state->userdata, nullptr, nullptr);
-        return;
-    }
-
-    state->callback(state->userdata, path, nullptr);
-}
-#else
-struct SDLDialogCallbackState {
-    FileCallback callback;
-    void* userdata;
-};
-
-void onSDLDialogFinished(void* userdata, const char* const* filelist, [[maybe_unused]] int filter) {
-    std::unique_ptr<SDLDialogCallbackState> state(static_cast<SDLDialogCallbackState*>(userdata));
-
-    if (filelist == nullptr) {
-        state->callback(state->userdata, nullptr, SDL_GetError());
-        return;
-    }
-
-    if (filelist[0] == nullptr) {
-        state->callback(state->userdata, nullptr, nullptr);
-        return;
-    }
-
-    state->callback(state->userdata, filelist[0], nullptr);
-}
-#endif
-
-}  // namespace
-
-void ShowFileSelect(FileCallback callback, void* userdata, SDL_Window* window,
-    const SDL_DialogFileFilter* filters, int nfilters, const char* default_location,
-    bool allow_many) {
-    if (callback == nullptr) {
-        return;
-    }
-
-#if USE_IOS_DIALOG
-    auto state = std::make_unique<IOSDialogCallbackState>();
-    state->callback = callback;
-    state->userdata = userdata;
-
-    Dusk_iOS_ShowFileSelect(&onIOSDialogFinished, state.release(), window, filters, nfilters,
-        default_location, allow_many);
-#else
-    auto state = std::make_unique<SDLDialogCallbackState>();
-    state->callback = callback;
-    state->userdata = userdata;
-
-    SDL_ShowOpenFileDialog(&onSDLDialogFinished, state.release(), window, filters, nfilters,
-        default_location, allow_many);
-#endif
-}
-
-void ShowFolderSelect(
-    FileCallback callback, void* userdata, SDL_Window* window, const char* default_location) {
-    if (callback == nullptr) {
-        return;
-    }
-
-#if USE_IOS_DIALOG
-    callback(userdata, nullptr, "Folder selection is not supported on this platform");
-#elif USE_MACOS_FOLDER_DIALOG
-    ShowMacOSFolderSelect(callback, userdata, window, default_location);
-#elif defined(__ANDROID__) || defined(ANDROID)
-    auto state = std::make_unique<AndroidFolderDialogState>();
-    state->callback = callback;
-    state->userdata = userdata;
-
-    if (show_android_folder_select(state.get())) {
-        state.release();
-        return;
-    }
-
-    callback(userdata, nullptr, "Folder selection is not supported on this platform");
-#else
-    auto state = std::make_unique<SDLDialogCallbackState>();
-    state->callback = callback;
-    state->userdata = userdata;
-
-    SDL_ShowOpenFolderDialog(
-        &onSDLDialogFinished, state.release(), window, default_location, false);
-#endif
-}
-
-std::string display_name_for_path(std::string_view path) {
-#if defined(__ANDROID__) || defined(ANDROID)
-    if (path.starts_with("content:") || path.starts_with("file:")) {
-        std::string displayName = android_display_name(path);
-        if (!displayName.empty()) {
-            return displayName;
-        }
-    }
-#endif
-    return fallback_display_name(path);
-}
-}  // namespace dusk
diff --git a/src/dusk/file_select.hpp b/src/dusk/file_select.hpp
deleted file mode 100644
index ad4ccce1fd..0000000000
--- a/src/dusk/file_select.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include <SDL3/SDL_dialog.h>
-
-#include <string>
-#include <string_view>
-
-struct SDL_Window;
-
-namespace dusk {
-
-using FileCallback = void (*)(void* userdata, const char* path, const char* error);
-
-void ShowFileSelect(FileCallback callback, void* userdata, SDL_Window* window,
-    const SDL_DialogFileFilter* filters, int nfilters, const char* default_location,
-    bool allow_many);
-void ShowFolderSelect(
-    FileCallback callback, void* userdata, SDL_Window* window, const char* default_location);
-
-std::string display_name_for_path(std::string_view path);
-
-}  // namespace dusk
diff --git a/src/dusk/file_select_macos.mm b/src/dusk/file_select_macos.mm
deleted file mode 100644
index 1bb34f364c..0000000000
--- a/src/dusk/file_select_macos.mm
+++ /dev/null
@@ -1,102 +0,0 @@
-#include "file_select.hpp"
-
-#include <SDL3/SDL_properties.h>
-#include <SDL3/SDL_video.h>
-
-#import <AppKit/AppKit.h>
-
-namespace dusk {
-namespace {
-
-struct MacOSFolderDialogState {
-    FileCallback callback;
-    void* userdata;
-};
-
-void finish_folder_dialog(MacOSFolderDialogState* state, NSURL* url, const char* error) {
-    if (state == nullptr) {
-        return;
-    }
-
-    if (error != nullptr) {
-        state->callback(state->userdata, nullptr, error);
-        delete state;
-        return;
-    }
-
-    if (url == nil) {
-        state->callback(state->userdata, nullptr, nullptr);
-        delete state;
-        return;
-    }
-
-    state->callback(state->userdata, [[url path] UTF8String], nullptr);
-    delete state;
-}
-
-void configure_default_location(NSOpenPanel* panel, const char* defaultLocation) {
-    if (panel == nil || defaultLocation == nullptr || defaultLocation[0] == '\0') {
-        return;
-    }
-
-    NSString* path = [NSString stringWithUTF8String:defaultLocation];
-    if (path == nil) {
-        return;
-    }
-
-    BOOL isDirectory = NO;
-    NSFileManager* fileManager = [NSFileManager defaultManager];
-    NSURL* url = [NSURL fileURLWithPath:path];
-    if ([fileManager fileExistsAtPath:path isDirectory:&isDirectory] && isDirectory) {
-        [panel setDirectoryURL:url];
-    } else {
-        [panel setDirectoryURL:[url URLByDeletingLastPathComponent]];
-    }
-}
-
-NSWindow* window_for_sdl_window(SDL_Window* window) {
-    if (window == nullptr) {
-        return nil;
-    }
-
-    auto props = SDL_GetWindowProperties(window);
-    return (__bridge NSWindow*)SDL_GetPointerProperty(
-        props, SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, nullptr);
-}
-
-}  // namespace
-
-bool ShowMacOSFolderSelect(
-    FileCallback callback, void* userdata, SDL_Window* window, const char* defaultLocation) {
-    if (callback == nullptr) {
-        return false;
-    }
-
-    auto* state = new MacOSFolderDialogState{
-        .callback = callback,
-        .userdata = userdata,
-    };
-
-    NSOpenPanel* panel = [NSOpenPanel openPanel];
-    [panel setCanChooseFiles:NO];
-    [panel setCanChooseDirectories:YES];
-    [panel setAllowsMultipleSelection:NO];
-    [panel setCanCreateDirectories:YES];
-    configure_default_location(panel, defaultLocation);
-
-    NSWindow* modalWindow = window_for_sdl_window(window);
-    if (modalWindow != nil) {
-        [panel beginSheetModalForWindow:modalWindow
-                      completionHandler:^(NSModalResponse result) {
-                          finish_folder_dialog(
-                              state, result == NSModalResponseOK ? [panel URL] : nil, nullptr);
-                      }];
-        return true;
-    }
-
-    const NSModalResponse result = [panel runModal];
-    finish_folder_dialog(state, result == NSModalResponseOK ? [panel URL] : nil, nullptr);
-    return true;
-}
-
-}  // namespace dusk
diff --git a/src/dusk/frame_interpolation.cpp b/src/dusk/frame_interpolation.cpp
deleted file mode 100644
index be03d51e96..0000000000
--- a/src/dusk/frame_interpolation.cpp
+++ /dev/null
@@ -1,459 +0,0 @@
-#include "dusk/frame_interpolation.h"
-
-#include "f_op/f_op_camera_mng.h"
-#include "m_Do/m_Do_graphic.h"
-#include "mtx.h"
-
-#include <absl/container/flat_hash_map.h>
-
-namespace {
-
-struct Recording {
-    absl::flat_hash_map<uintptr_t, Mtx> matrix_values;
-};
-
-bool s_initialized = false;
-
-bool g_enabled = false;
-bool g_recording = false;
-bool g_interpolating = false;
-bool g_sync_presentation = false;
-
-float g_step = 0.0f;
-bool g_is_sim_frame = false;
-bool g_ui_tick_pending = false;
-uint64_t g_sim_tick_seq = 0;
-
-Recording g_current_recording;
-Recording g_previous_recording;
-
-absl::flat_hash_map<uintptr_t, Mtx> g_replacements;
-
-struct CameraSnapshot {
-    cXyz eye{};
-    cXyz center{};
-    cXyz up{};
-    s16 bank{};
-    f32 fovy{};
-    f32 aspect{};
-    f32 near_{};
-    f32 far_{};
-    bool wideZoom{};
-    bool valid{};
-};
-
-CameraSnapshot s_cam_prev{};
-CameraSnapshot s_cam_curr{};
-
-view_class s_presentation_view_backup{};
-int s_presentation_depth = 0;
-
-struct InterpolationCallBackWork {
-    dusk::frame_interp::InterpolationCallBack pCallBack;
-    void* pUserWork;
-};
-
-std::vector<InterpolationCallBackWork> s_interpolationCallBackWork;
-
-void copy_view_to_snap(CameraSnapshot* dst, const view_class& v) {
-    dst->eye = v.lookat.eye;
-    dst->center = v.lookat.center;
-    dst->up = v.lookat.up;
-    dst->bank = v.bank;
-    dst->fovy = v.fovy;
-    dst->aspect = v.aspect;
-    dst->near_ = v.near_;
-    dst->far_ = v.far_;
-    dst->valid = true;
-}
-
-inline void lerp_matrix(Mtx out, const Mtx lhs, const Mtx rhs, float step) {
-    for (size_t row = 0; row < 3; ++row) {
-        for (size_t col = 0; col < 4; ++col) {
-            const float l = lhs[row][col];
-            out[row][col] = l + (rhs[row][col] - l) * step;
-        }
-    }
-}
-
-inline void lerp_xyz(cXyz* out, const cXyz& lhs, const cXyz& rhs, float step) {
-    out->x = lhs.x + (rhs.x - lhs.x) * step;
-    out->y = lhs.y + (rhs.y - lhs.y) * step;
-    out->z = lhs.z + (rhs.z - lhs.z) * step;
-}
-
-static s16 lerp_bank(s16 a, s16 b, f32 t) {
-    const f32 ra = S2RAD(a);
-    const f32 d = remainderf(S2RAD(b) - ra, 2.0f * static_cast<f32>(M_PI));
-    return cAngle::Radian_to_SAngle(ra + d * t);
-}
-
-inline bool matrix_differs(const Mtx lhs, const Mtx rhs, float epsilon = 0.0001f) {
-    for (size_t row = 0; row < 3; ++row) {
-        for (size_t col = 0; col < 4; ++col) {
-            if (std::abs(lhs[row][col] - rhs[row][col]) > epsilon) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-const Mtx* resolve_replacement(const Mtx* source, Mtx* scratch) {
-    if (!g_interpolating || source == nullptr || dusk::frame_interp::presentation_sync_active()) {
-        return source;
-    }
-
-    auto it = g_replacements.find(reinterpret_cast<uintptr_t>(source));
-    if (it == g_replacements.end()) {
-        return source;
-    }
-
-    MTXCopy(it->second, *scratch);
-    return scratch;
-}
-
-bool has_recording_data(const Recording& recording) {
-    return !recording.matrix_values.empty();
-}
-
-void clear_replacements() {
-    g_replacements.clear();
-}
-
-}  // namespace
-
-namespace dusk::frame_interp {
-void ensure_initialized() {
-    s_initialized = true;
-}
-
-void begin_sim_tick() {
-    ensure_initialized();
-    if (!g_enabled) {
-        return;
-    }
-
-    s_interpolationCallBackWork.clear();
-    s_cam_prev = std::move(s_cam_curr);
-    ++g_sim_tick_seq;
-}
-
-uint64_t sim_tick_seq() {
-    return g_sim_tick_seq;
-}
-
-void begin_frame(FrameInterpMode mode, bool is_sim_frame, float step) {
-    g_enabled = mode != FrameInterpMode::Off;
-    g_is_sim_frame = is_sim_frame;
-    g_step = std::clamp(step, 0.0f, 1.0f);
-}
-
-bool is_enabled() {
-    return g_enabled;
-}
-
-bool is_sim_frame() {
-    return g_is_sim_frame;
-}
-
-void begin_record() {
-    ensure_initialized();
-
-    if (!g_enabled) {
-        g_interpolating = false;
-        g_sync_presentation = false;
-        g_previous_recording = {};
-        g_current_recording = {};
-        clear_replacements();
-        s_cam_prev.valid = false;
-        s_cam_curr.valid = false;
-        return;
-    }
-
-    g_sync_presentation = false;
-    g_previous_recording = std::move(g_current_recording);
-    g_current_recording = {};
-    g_recording = true;
-    g_interpolating = false;
-    clear_replacements();
-
-    ::camera_process_class* cam = dComIfGp_getCamera(0);
-    if (cam == nullptr) {
-        s_cam_prev.valid = false;
-        s_cam_curr.valid = false;
-        return;
-    }
-}
-
-void end_record() {
-    g_recording = false;
-}
-
-void interpolate() {
-    ensure_initialized();
-    clear_replacements();
-    g_interpolating = g_enabled && !g_recording && !g_sync_presentation && has_recording_data(g_current_recording);
-    if (!g_interpolating) {
-        return;
-    }
-    for (auto const& old : g_previous_recording.matrix_values) {
-        if (auto it = g_current_recording.matrix_values.find(old.first);
-            it != g_current_recording.matrix_values.end())
-        {
-            lerp_matrix(g_replacements[old.first], old.second, it->second, g_step);
-        }
-    }
-}
-
-void request_presentation_sync() {
-    ensure_initialized();
-    if (!g_enabled) {
-        return;
-    }
-    g_sync_presentation = true;
-}
-
-bool presentation_sync_active() {
-    if (!s_initialized || !g_enabled) {
-        return false;
-    }
-    return g_sync_presentation;
-}
-
-float get_interpolation_step() {
-    ensure_initialized();
-    return presentation_sync_active() ? 1.0f : g_step;
-}
-
-void set_ui_tick_pending(bool value) {
-    if (g_ui_tick_pending == value) { return; }
-    g_ui_tick_pending = value;
-}
-
-bool get_ui_tick_pending() {
-    ensure_initialized();
-    return g_enabled ? g_ui_tick_pending : true;
-}
-
-void record_final_mtx(Mtx m, const void* key) {
-    if (!s_initialized || !g_recording || m == nullptr) {
-        return;
-    }
-
-    auto& it = g_current_recording.matrix_values[reinterpret_cast<uintptr_t>(key)];
-    MTXCopy(m, it);
-}
-
-void record_final_mtx(Mtx m) {
-    record_final_mtx(m, m);
-}
-
-bool lookup_replacement(const void* key, Mtx out) {
-    if (presentation_sync_active() || !g_interpolating || key == nullptr) {
-        return false;
-    }
-
-    auto it = g_replacements.find(reinterpret_cast<uintptr_t>(key));
-    if (it == g_replacements.end()) {
-        return false;
-    }
-
-    MTXCopy(it->second, out);
-    return true;
-}
-
-bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out) {
-    if (presentation_sync_active() || !g_interpolating || lhs == nullptr || rhs == nullptr) {
-        return false;
-    }
-
-    Mtx lhs_scratch;
-    Mtx rhs_scratch;
-    const Mtx* resolved_lhs = resolve_replacement(reinterpret_cast<const Mtx*>(lhs), &lhs_scratch);
-    const Mtx* resolved_rhs = resolve_replacement(reinterpret_cast<const Mtx*>(rhs), &rhs_scratch);
-    if (resolved_lhs == reinterpret_cast<const Mtx*>(lhs) && resolved_rhs == reinterpret_cast<const Mtx*>(rhs)) {
-        return false;
-    }
-
-    MTXConcat(*resolved_lhs, *resolved_rhs, out);
-    return true;
-}
-
-void record_camera(::camera_process_class* cam, int camera_id) {
-    if (!g_enabled || camera_id != 0 || cam == nullptr) {
-        return;
-    }
-    copy_view_to_snap(&s_cam_curr, cam->view);
-#if WIDESCREEN_SUPPORT
-    s_cam_curr.wideZoom = mDoGph_gInf_c::isWideZoom();
-#endif
-}
-
-void interp_view(::view_class* view) {
-    if (!g_enabled)
-        return;
-
-    if (!s_cam_prev.valid || !s_cam_curr.valid)
-        return;
-
-    const f32 step = get_interpolation_step();
-    const bool is_cam_curr_authoritative = g_is_sim_frame && step <= 0.0f;
-
-    cXyz eye;
-    cXyz center;
-    cXyz up;
-    if (is_cam_curr_authoritative) {
-        eye = s_cam_curr.eye;
-        center = s_cam_curr.center;
-        up = s_cam_curr.up;
-    } else {
-        lerp_xyz(&eye, s_cam_prev.eye, s_cam_curr.eye, step);
-        lerp_xyz(&center, s_cam_prev.center, s_cam_curr.center, step);
-        lerp_xyz(&up, s_cam_prev.up, s_cam_curr.up, step);
-    }
-    if (!up.normalizeRS()) {
-        up = s_cam_curr.up;
-        up.normalizeRS();
-    }
-
-    view->lookat.eye = eye;
-    view->lookat.center = center;
-    view->lookat.up = up;
-    if (is_cam_curr_authoritative) {
-        view->bank = s_cam_curr.bank;
-        view->fovy = s_cam_curr.fovy;
-        view->aspect = s_cam_curr.aspect;
-        view->near_ = s_cam_curr.near_;
-        view->far_ = s_cam_curr.far_;
-    } else {
-        view->bank = lerp_bank(s_cam_prev.bank, s_cam_curr.bank, step);
-        view->fovy = s_cam_prev.fovy + (s_cam_curr.fovy - s_cam_prev.fovy) * step;
-        view->aspect = s_cam_prev.aspect + (s_cam_curr.aspect - s_cam_prev.aspect) * step;
-        view->near_ = s_cam_prev.near_ + (s_cam_curr.near_ - s_cam_prev.near_) * step;
-        view->far_ = s_cam_prev.far_ + (s_cam_curr.far_ - s_cam_prev.far_) * step;
-    }
-
-    // FRAME INTERP TODO: It might be better if I rewired the game to not clear this flag until the
-    // next sim frame, but I don't care enough to right now
-#if WIDESCREEN_SUPPORT
-    const f32 wide_step = is_cam_curr_authoritative ? 1.0f : step;
-    if (mDoGph_gInf_c::isWide() && !mDoGph_gInf_c::isWideZoom() && wide_step >= 0.5f ? s_cam_curr.wideZoom : s_cam_prev.wideZoom) {
-        mDoGph_gInf_c::onWideZoom();
-    }
-#endif
-}
-
-static void run_interpolation_callbacks() {
-    for (size_t i = 0; i < s_interpolationCallBackWork.size(); i++) {
-        auto const& work = s_interpolationCallBackWork[i];
-        work.pCallBack(g_is_sim_frame, work.pUserWork);
-    }
-}
-
-void add_interpolation_callback(InterpolationCallBack pCallBack, void* pUserWork) {
-    if (!is_enabled() || s_presentation_depth > 0 || !g_is_sim_frame)
-        return;
-
-    s_interpolationCallBackWork.emplace_back(pCallBack, pUserWork);
-}
-
-void begin_presentation_camera() {
-    ensure_initialized();
-    if (!g_enabled) {
-        return;
-    }
-    if (s_presentation_depth > 0) {
-        s_presentation_depth++;
-        return;
-    }
-    if (!s_cam_prev.valid || !s_cam_curr.valid) {
-        return;
-    }
-
-    view_class* const view = dComIfGd_getView();
-    if (view == nullptr) {
-        return;
-    }
-
-    std::memcpy(&s_presentation_view_backup, view, sizeof(view_class));
-    interp_view(view);
-
-    // FRAME INTERP TODO: Largely copied from d_camera's camera_draw function from this point, got any better ideas?
-    C_MTXPerspective(view->projMtx, view->fovy, view->aspect, view->near_, view->far_);
-    mDoMtx_lookAt(view->viewMtx, &view->lookat.eye, &view->lookat.center, &view->lookat.up, view->bank);
-#if WIDESCREEN_SUPPORT
-    mDoGph_gInf_c::setWideZoomProjection(view->projMtx);
-#endif
-    j3dSys.setViewMtx(view->viewMtx);
-    cMtx_inverse(view->viewMtx, view->invViewMtx);
-
-    bool camera_attention_status = dComIfGp_getCameraAttentionStatus(0) & 0x80;
-    Z2GetAudience()->setAudioCamera(view->viewMtx, view->lookat.eye, view->lookat.center, view->fovy, view->aspect, camera_attention_status, 0, false);
-
-    dBgS_GndChk gndchk;
-    gndchk.OnWaterGrp();
-    gndchk.SetPos(&view->lookat.eye);
-    f32 cross = dComIfG_Bgsp().GroundCross(&gndchk);
-    if (cross != -G_CM3D_F_INF) {
-        if (dComIfG_Bgsp().ChkGrpInf(gndchk, 0x100)) {
-            mDoAud_getCameraMapInfo(6);
-        } else {
-            mDoAud_getCameraMapInfo(dComIfG_Bgsp().GetMtrlSndId(gndchk));
-        }
-        mDoAud_setCameraGroupInfo(dComIfG_Bgsp().GetGrpSoundId(gndchk));
-        Vec spDC;
-        spDC.x = view->lookat.eye.x;
-        spDC.y = cross;
-        spDC.z = view->lookat.eye.z;
-        Z2AudioMgr::getInterface()->setCameraPolygonPos(&spDC);
-    } else {
-        Z2AudioMgr::getInterface()->setCameraPolygonPos(nullptr);
-    }
-
-    MTXCopy(view->viewMtx, view->viewMtxNoTrans);
-    view->viewMtxNoTrans[0][3] = 0.0f;
-    view->viewMtxNoTrans[1][3] = 0.0f;
-    view->viewMtxNoTrans[2][3] = 0.0f;
-    cMtx_concatProjView(view->projMtx, view->viewMtx, view->projViewMtx);
-
-    f32 far_;
-    f32 var_f30;
-    if (dComIfGp_getCameraAttentionStatus(0) & 8) {
-        far_ = view->far_;
-    } else {
-#if DEBUG
-        if (g_envHIO.mOther.mAdjustCullFar != 0) {
-            var_f30 = g_envHIO.mOther.mCullFarValue;
-        } else
-#endif
-        {
-            var_f30 = dStage_stagInfo_GetCullPoint(dComIfGp_getStageStagInfo());
-        }
-        far_ = var_f30;
-    }
-
-    mDoLib_clipper::setup(view->fovy, view->aspect, view->near_, far_);
-
-    // FRAME INTERP NOTE: Removed the call to offWideZoom that was here, it causes problems with presentation during cutscenes.
-
-    s_presentation_depth = 1;
-
-    run_interpolation_callbacks();
-}
-
-void end_presentation_camera() {
-    if (s_presentation_depth == 0) {
-        return;
-    }
-    s_presentation_depth--;
-    if (s_presentation_depth > 0) {
-        return;
-    }
-
-    view_class* const view = dComIfGd_getView();
-    if (view != nullptr) {
-        std::memcpy(view, &s_presentation_view_backup, sizeof(view_class));
-    }
-}
-}  // namespace dusk::frame_interp
diff --git a/src/dusk/game_clock.cpp b/src/dusk/game_clock.cpp
index 1dc7fbf322..3a680fcca8 100644
--- a/src/dusk/game_clock.cpp
+++ b/src/dusk/game_clock.cpp
@@ -1,104 +1,170 @@
 #include "dusk/game_clock.h"
 
+#include <aurora/time.hpp>
+
 #include <algorithm>
 #include <chrono>
-#include <cmath>
 #include <unordered_map>
-#include <dusk/frame_interpolation.h>
 
 namespace dusk::game_clock {
 
-using clock = std::chrono::steady_clock;
+using native_clock = aurora::time::native_clock;
+using game_clock = aurora::time::game_clock;
 
+FrameTiming g_frameTiming{.dt = kUiInitialDt};
+
+namespace {
 bool s_initialized = false;
-clock::time_point s_previous_sample{};
-clock::time_point s_current_snapshot_time{};
+bool s_simTickActive = false;
+native_clock::time_point s_previousNativeSample{};
+game_clock::time_point s_latestGameSample{};
+game_clock::time_point s_currentSnapshotTime{};
+game_clock::time_point s_pendingSimTime{};
+std::unordered_map<uintptr_t, game_clock::time_point> s_intervalLastSample;
+uint64_t s_presentationEpoch = 1;
+bool s_timingModeInitialized = false;
+bool s_previousSeparatePresentation = false;
+bool s_previousInterpolating = false;
+bool s_previousTimeStopped = false;
 
-std::unordered_map<uintptr_t, clock::time_point> s_interval_last_sample;
+constexpr game_clock::duration kSimPeriodDuration =
+    std::chrono::duration_cast<game_clock::duration>(std::chrono::duration<float>(kSimPeriod));
+constexpr native_clock::duration kAbnormalGapResetThreshold = std::chrono::milliseconds(250);
+constexpr int kMaxSimTicksPerFrame = static_cast<int>(aurora::time::kMaximumTimeScale) * 4;
+}  // namespace
 
-constexpr clock::duration kSimPeriodDuration =
-    std::chrono::duration_cast<clock::duration>(std::chrono::duration<float>(sim_pace()));
-constexpr clock::duration kAbnormalGapResetThreshold = std::chrono::milliseconds(250);
-constexpr int kMaxSimTicksPerFrame = 2;
-
-void ensure_initialized() {
+void initialize() {
     if (s_initialized) {
         return;
     }
-    s_previous_sample = clock::now();
-    s_current_snapshot_time = s_previous_sample;
+    s_previousNativeSample = native_clock::now();
+    s_latestGameSample = game_clock::now();
+    s_currentSnapshotTime = s_latestGameSample;
+    s_pendingSimTime = s_latestGameSample;
     s_initialized = true;
 }
 
-void reset_frame_timer() {
-    s_previous_sample = clock::now();
-    s_current_snapshot_time = s_previous_sample - kSimPeriodDuration;
+void reset() {
+    s_previousNativeSample = native_clock::now();
+    s_latestGameSample = game_clock::now();
+    s_currentSnapshotTime = s_latestGameSample - kSimPeriodDuration;
+    s_pendingSimTime = s_currentSnapshotTime;
+    s_simTickActive = false;
+    ++s_presentationEpoch;
 }
 
-MainLoopPacer advance_main_loop() {
-    ensure_initialized();
+void set_sim_rate(float hz) {
+    const float maximumHz = aurora::time::kMaximumTimeScale / kSimPeriod;
+    aurora::time::set_scale(std::clamp(hz, 1.0f, maximumHz) * kSimPeriod);
+    reset();
+}
 
-    const clock::time_point now = clock::now();
-    const clock::duration frame_gap = now - s_previous_sample;
-    const float presentation_dt = std::chrono::duration<float>(frame_gap).count();
-    s_previous_sample = now;
+float get_sim_rate() {
+    return aurora::time::scale() / kSimPeriod;
+}
 
-    MainLoopPacer out{};
-    out.presentation_dt_seconds = presentation_dt;
+const FrameTiming& advance() {
+    const auto nativeNow = native_clock::now();
+    const auto gameNow = game_clock::now();
+    const auto nativeFrameGap = nativeNow - s_previousNativeSample;
+    const auto gameFrameGap = gameNow - s_latestGameSample;
+    s_previousNativeSample = nativeNow;
+    s_latestGameSample = gameNow;
 
-    const bool should_interpolate = dusk::getSettings().game.enableFrameInterpolation.getValue() !=
-                                        dusk::FrameInterpMode::Off &&
-                                    !dusk::getTransientSettings().skipFrameRateLimit;
-    out.is_interpolating = should_interpolate;
-    out.sim_pace = sim_pace();
+    auto& out = g_frameTiming;
+    out = {
+        .dt = std::chrono::duration<float>(gameFrameGap).count(),
+        .presentationEpoch = s_presentationEpoch,
+    };
 
-    if (!should_interpolate) {
-        s_current_snapshot_time = now;
-        out.sim_ticks_to_run = 1;
+    const float timeScale = aurora::time::scale();
+    const bool interpolating =
+        getSettings().game.enableFrameInterpolation.getValue() != FrameInterpMode::Off;
+    const bool separatePresentation = interpolating || timeScale != 1.0f;
+    out.interpolating = interpolating;
+    out.separatePresentation = separatePresentation;
+
+    const bool timeStopped = timeScale == 0.0f;
+    const bool timingModeChanged =
+        s_timingModeInitialized &&
+        (separatePresentation != s_previousSeparatePresentation ||
+            interpolating != s_previousInterpolating || timeStopped != s_previousTimeStopped);
+    const bool abnormalGap = nativeFrameGap > kAbnormalGapResetThreshold;
+    if (timingModeChanged || abnormalGap) {
+        ++s_presentationEpoch;
+        out.presentationEpoch = s_presentationEpoch;
+    }
+    s_timingModeInitialized = true;
+    s_previousSeparatePresentation = separatePresentation;
+    s_previousInterpolating = interpolating;
+    s_previousTimeStopped = timeStopped;
+
+    if (!separatePresentation) {
+        s_currentSnapshotTime = gameNow;
+        out.numSimTicks = 1;
         return out;
     }
 
-    if (frame_gap > kAbnormalGapResetThreshold) {
-        s_current_snapshot_time = now - kSimPeriodDuration;
-        out.sim_ticks_to_run = 0;
+    const auto simulationTarget = interpolating ? gameNow - kSimPeriodDuration : gameNow;
+    if (timeStopped || abnormalGap) {
+        s_currentSnapshotTime = simulationTarget;
+        out.numSimTicks = 0;
         return out;
     }
 
-    int sim_ticks_to_run = 0;
-    clock::time_point projected_snapshot_time = s_current_snapshot_time;
-    const clock::time_point render_time = now - kSimPeriodDuration;
-    while (sim_ticks_to_run < kMaxSimTicksPerFrame && projected_snapshot_time < render_time) {
-        projected_snapshot_time += kSimPeriodDuration;
-        sim_ticks_to_run++;
+    int numSimTicks = 0;
+    auto projectedSnapshotTime = s_currentSnapshotTime;
+    while (numSimTicks < kMaxSimTicksPerFrame) {
+        const bool tickDue = interpolating ?
+                                 projectedSnapshotTime < simulationTarget :
+                                 projectedSnapshotTime + kSimPeriodDuration <= simulationTarget;
+        if (!tickDue) {
+            break;
+        }
+        projectedSnapshotTime += kSimPeriodDuration;
+        numSimTicks++;
     }
-    out.sim_ticks_to_run = sim_ticks_to_run;
+    out.numSimTicks = numSimTicks;
     return out;
 }
 
+void begin_sim_tick() {
+    s_pendingSimTime = g_frameTiming.separatePresentation ? s_currentSnapshotTime + kSimPeriodDuration :
+                                                            s_latestGameSample;
+    s_simTickActive = true;
+}
+
 void commit_sim_tick() {
-    ensure_initialized();
-    s_current_snapshot_time += kSimPeriodDuration;
+    if (s_simTickActive) {
+        s_currentSnapshotTime = s_pendingSimTime;
+        s_simTickActive = false;
+    } else {
+        s_currentSnapshotTime += kSimPeriodDuration;
+    }
+}
+
+bool is_sim_frame() {
+    return !g_frameTiming.separatePresentation || s_simTickActive;
 }
 
 float sample_interpolation_step() {
-    ensure_initialized();
     const float step =
-        std::chrono::duration<float>(clock::now() - s_current_snapshot_time).count() / sim_pace();
+        std::chrono::duration<float>(game_clock::now() - s_currentSnapshotTime).count() /
+        kSimPeriod;
     return std::clamp(step, 0.0f, 1.0f);
 }
 
 float consume_interval(const void* consumer) {
-    ensure_initialized();
-    const uintptr_t key = reinterpret_cast<uintptr_t>(consumer);
-    const clock::time_point now = clock::now();
-
-    float dt = ui_initial_dt();
-    const auto it = s_interval_last_sample.find(key);
-    if (it != s_interval_last_sample.end()) {
+    const auto key = reinterpret_cast<uintptr_t>(consumer);
+    const auto now = s_simTickActive ? s_pendingSimTime : game_clock::now();
+    const float timeScale = aurora::time::scale();
+    float dt = kUiInitialDt * timeScale;
+    if (const auto it = s_intervalLastSample.find(key); it != s_intervalLastSample.end()) {
         dt = std::chrono::duration<float>(now - it->second).count();
-        dt = std::min(dt, ui_maximum_dt());
+        const float maximumDt = std::max(kUiMaximumDt * timeScale, kSimPeriod);
+        dt = std::min(dt, maximumDt);
     }
-    s_interval_last_sample[key] = now;
+    s_intervalLastSample[key] = now;
     return dt;
 }
 
diff --git a/src/dusk/game_clock.h b/src/dusk/game_clock.h
new file mode 100644
index 0000000000..3492456927
--- /dev/null
+++ b/src/dusk/game_clock.h
@@ -0,0 +1,39 @@
+#pragma once
+
+namespace dusk::game_clock {
+
+// Amount of time that a simulation tick advances
+constexpr float kSimPeriod = 1.0f / 30.0f;
+constexpr float kUiMaximumDt = 0.05f;
+constexpr float kUiInitialDt = 1.0f / 60.0f;
+
+struct FrameTiming {
+    // Amount of time elapsed in seconds since the last advance
+    float dt;
+    // Whether interpolation is active
+    bool interpolating;
+    // Run simulation and presentation separately (for interpolation or time scaling)
+    bool separatePresentation;
+    // Number of simulation ticks to run
+    int numSimTicks;
+    // Changes whenever presentation history must be discarded and re-anchored.
+    uint64_t presentationEpoch;
+};
+extern FrameTiming g_frameTiming;
+
+void initialize();
+void reset();
+const FrameTiming& advance();
+void begin_sim_tick();
+void commit_sim_tick();
+float sample_interpolation_step();
+
+bool is_sim_frame();
+
+float consume_interval(const void* consumer);
+
+// Sets the effective simulation rate through the game clock time scale.
+void set_sim_rate(float hz);
+float get_sim_rate();
+
+}  // namespace dusk::game_clock
diff --git a/src/dusk/game_combos.cpp b/src/dusk/game_combos.cpp
new file mode 100644
index 0000000000..a901dba285
--- /dev/null
+++ b/src/dusk/game_combos.cpp
@@ -0,0 +1,136 @@
+#include "dusk/game_combos.h"
+
+#include "SSystem/SComponent/c_API_controller_pad.h"
+#include "SSystem/SComponent/c_xyz.h"
+#include "d/actor/d_a_alink.h"
+#include "d/d_com_inf_game.h"
+#include "dusk/settings.h"
+#include "m_Do/m_Do_controller_pad.h"
+
+namespace dusk {
+namespace {
+
+cXyz s_savedTeleportPos{};
+s16 s_savedTeleportAngle = 0;
+bool s_hasTeleportPos = false;
+
+static daAlink_c* getPlayer() {
+    return (daAlink_c*)dComIfGp_getPlayer(0);
+}
+
+static void consumeButtons(u16 mask) {
+    mDoCPd_c::getCpadInfo(PAD_1).mPressedButtonFlags &= ~mask;
+    mDoCPd_c::getCpadInfo(PAD_1).mButtonFlags &= ~mask;
+}
+
+// Table: holdMask, trigMask, strict, condition, action, consumeMask, exclusive
+static const GameCombo kCombos[] = {
+    // Move Link (L+R+Y), pass-through, non-exclusive
+    {
+        PAD_TRIGGER_R | PAD_TRIGGER_L,
+        PAD_BUTTON_Y,
+        false,
+        [] { return (bool)getSettings().game.enableMoveLinkCombo; },
+        [] { getTransientSettings().moveLinkActive = !getTransientSettings().moveLinkActive; },
+        0,
+        false,
+    },
+    // Quick Transform (R+Y, strictly only R held)
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_Y,
+        true,
+        [] { return getPlayer() != nullptr; },
+        [] { getPlayer()->handleQuickTransform(); },
+        PAD_BUTTON_Y,
+        false,
+    },
+    // Wolf Howl (R+X)
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_X,
+        false,
+        [] { return getPlayer() != nullptr; },
+        [] { getPlayer()->handleWolfHowl(); },
+        PAD_BUTTON_X,
+        false,
+    },
+    // Teleport save (R+D-pad Up), consumes D-pad Up, exclusive
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_UP,
+        false,
+        [] { return getSettings().game.enableTeleportCombo && getPlayer() != nullptr; },
+        [] {
+            auto* p = getPlayer();
+            s_savedTeleportPos = p->current.pos;
+            s_savedTeleportAngle = p->shape_angle.y;
+            s_hasTeleportPos = true;
+        },
+        PAD_BUTTON_UP,
+        true,
+    },
+    // Teleport load (R+D-pad Down), consumes D-pad Down, exclusive
+    {
+        PAD_TRIGGER_R,
+        PAD_BUTTON_DOWN,
+        false,
+        [] {
+            return getSettings().game.enableTeleportCombo && s_hasTeleportPos &&
+                   getPlayer() != nullptr;
+        },
+        [] {
+            auto* p = getPlayer();
+            p->current.pos = s_savedTeleportPos;
+            p->shape_angle.y = s_savedTeleportAngle;
+            p->mNormalSpeed = 0.0f;
+        },
+        PAD_BUTTON_DOWN,
+        true,
+    },
+    // Moon Jump (R+A, hold), continuous, pass-through, non-exclusive
+    {
+        PAD_TRIGGER_R | PAD_BUTTON_A,
+        0,
+        false,
+        [] { return getSettings().game.moonJump && getPlayer() != nullptr; },
+        [] { getPlayer()->speed.y = 56.0f; },
+        0,
+        false,
+    },
+};
+
+}  // namespace
+
+void processGameCombos() {
+    if (!getSettings().game.enableMoveLinkCombo) {
+        getTransientSettings().moveLinkActive = false;
+    }
+
+    const u16 held = mDoCPd_c::getHold(PAD_1) & 0xFFFF;
+    const u16 trig = mDoCPd_c::getTrig(PAD_1) & 0xFFFF;
+
+    for (const auto& combo : kCombos) {
+        if ((held & combo.holdMask) != combo.holdMask) {
+            continue;
+        }
+        if (combo.strict && (held & ~combo.trigMask) != combo.holdMask) {
+            continue;
+        }
+        if (combo.trigMask != 0 && !(trig & combo.trigMask)) {
+            continue;
+        }
+        if (combo.condition != nullptr && !combo.condition()) {
+            continue;
+        }
+        combo.action();
+        if (combo.consumeMask != 0) {
+            consumeButtons(combo.consumeMask);
+        }
+        if (combo.exclusive) {
+            return;
+        }
+    }
+}
+
+}  // namespace dusk
diff --git a/src/dusk/game_combos.h b/src/dusk/game_combos.h
new file mode 100644
index 0000000000..5306cb447c
--- /dev/null
+++ b/src/dusk/game_combos.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <dolphin/types.h>
+
+namespace dusk {
+
+struct GameCombo {
+    using ConditionFn = bool(*)();
+    using ActionFn    = void(*)();
+
+    u16         holdMask;    // all of these must be held (getHold)
+    u16         trigMask;    // at least one must be newly triggered (getTrig); 0 = fires every frame while holdMask is held
+    bool        strict;      // if true: (held & ~trigMask) must equal holdMask exactly, no extra buttons held
+    ConditionFn condition;   // extra game-state guard; nullptr = no extra check
+    ActionFn    action;      // runs when the combo is fired
+    u16         consumeMask; // buttons to clear after firing; 0 = pass-through
+    bool        exclusive;   // stop evaluating future combos if this fires
+};
+
+void processGameCombos();
+
+}  // namespace dusk
diff --git a/src/dusk/game_mode.cpp b/src/dusk/game_mode.cpp
new file mode 100644
index 0000000000..ffecd66df3
--- /dev/null
+++ b/src/dusk/game_mode.cpp
@@ -0,0 +1,101 @@
+#include "dusk/game_mode.hpp"
+
+#include "dusk/config.hpp"
+#include "dusk/ui/prelaunch.hpp"
+
+#include "m_Do/m_Do_MemCard.h"
+
+#include "JSystem/JUtility/JUTGamePad.h"
+
+#include <aurora/lib/logging.hpp>
+
+namespace dusk::gamemode {
+namespace {
+aurora::Module Log("dusk::gamemode");
+}
+
+GameModeManager g_GameModeManager;
+
+GameModeManager::GameModeManager() {
+    GameMode vanilla{kVanillaGameModeId, "Vanilla"};
+    mRegisteredGameModes.emplace(vanilla.getId(), std::move(vanilla));
+    mCurrentGameModeId = kVanillaGameModeId;
+}
+
+void GameModeManager::setGameModeToPrevious() {
+    // Restore the previously selected game mode if still registered.
+    GameModeId id = getSettings().game.lastSelectedGameModeId;
+    if (!mRegisteredGameModes.contains(id)) {
+        setCurrentGameMode(kVanillaGameModeId);
+        return;
+    }
+    setCurrentGameMode(id);
+}
+
+void GameModeManager::registerGameMode(const GameMode& gameMode) {
+    if (gameMode.getId().empty()) {
+        Log.fatal("No game mode ID specified in GameModeManager::registerGameMode");
+    }
+    if (gameMode.getFullName().empty()) {
+        Log.fatal("No display name specified for game mode {}", gameMode.getId());
+    }
+
+    if (mRegisteredGameModes.contains(gameMode.getId())) {
+        Log.warn("Attempting to re-register existing game mode {}", gameMode.getId());
+        return;
+    }
+
+    mRegisteredGameModes.emplace(gameMode.getId(), gameMode);
+    ui::Prelaunch::refresh_menu_buttons();
+}
+
+void GameModeManager::unregisterGameMode(const GameModeId& gameModeId) {
+    const auto& it = mRegisteredGameModes.find(gameModeId);
+    if (it == mRegisteredGameModes.end()) {
+        Log.warn("Attempting to unregister unknown game mode {}", gameModeId);
+        return;
+    }
+
+    if (mCurrentGameModeId == gameModeId) {
+        // Reset to prelaunch before unloading callbacks belonging to the active mod.
+        ui::prelaunch_state().returnToPrelaunchOnReset = true;
+        JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
+        setCurrentGameMode(kVanillaGameModeId);
+    }
+    mRegisteredGameModes.erase(it);
+    ui::Prelaunch::refresh_menu_buttons();
+}
+
+bool GameModeManager::setCurrentGameMode(const GameModeId& id) {
+    if (mCurrentGameModeId == id) {
+        return true;
+    }
+    if (!mRegisteredGameModes.contains(id)) {
+        Log.warn("Attempting to configure unknown game mode {}", id);
+        return false;
+    }
+    const GameMode* currentGameMode = getCurrentGameMode();
+    if (currentGameMode) {
+        currentGameMode->invokeOnDeactivatedFunction();
+    }
+    mCurrentGameModeId = id;
+
+    currentGameMode = getCurrentGameMode();
+    if (currentGameMode) {
+        mDoMemCd_SetFileName(currentGameMode->getSaveName());
+        if (!currentGameMode->invokeOnActivatedFunction()) {
+            mCurrentGameModeId = kVanillaGameModeId;
+            currentGameMode = getCurrentGameMode();
+            mDoMemCd_SetFileName(currentGameMode->getSaveName());
+            currentGameMode->invokeOnActivatedFunction();
+            getSettings().game.lastSelectedGameModeId.setValue(kVanillaGameModeId);
+            config::save();
+            return false;
+        }
+    }
+    getSettings().game.lastSelectedGameModeId.setValue(id);
+    config::save();
+    return true;
+}
+
+}  // namespace dusk::gamemode
diff --git a/src/dusk/game_mode.hpp b/src/dusk/game_mode.hpp
new file mode 100644
index 0000000000..2376eb062b
--- /dev/null
+++ b/src/dusk/game_mode.hpp
@@ -0,0 +1,143 @@
+#pragma once
+
+#include "mods/svc/game_mode.h"
+
+#include "d/d_file_select.h"
+
+#include <functional>
+#include <map>
+#include <string>
+#include <utility>
+
+namespace dusk::gamemode {
+using GameModeId = std::string;
+
+constexpr const char* kVanillaGameModeId = "vanilla";
+constexpr const char* kDefaultGameModeSaveName = "gczelda2";
+
+// Holds a game mode definition and its lifecycle callbacks.
+class GameMode {
+public:
+    using Callback = std::function<bool()>;
+    using NewSaveSelectCallback = std::function<bool(GameModeNewSaveState* state)>;
+
+    GameMode(GameModeId id, std::string fullName, std::string saveName = {})
+        : mId{std::move(id)}, mFullName{std::move(fullName)},
+          mSaveName{saveName.empty() ? kDefaultGameModeSaveName : std::move(saveName)} {}
+    const GameModeId& getId() const { return mId; }
+    const std::string& getFullName() const { return mFullName; }
+    const std::string& getSaveName() const { return mSaveName; }
+
+    GameModeId mId;
+    std::string mFullName;
+    std::string mSaveName;
+
+    bool invokeOnActivatedFunction() const {
+        if (mOnActivatedFunction) {
+            return mOnActivatedFunction();
+        }
+        return true;
+    }
+
+    bool invokeOnDeactivatedFunction() const {
+        if (mOnDeactivatedFunction) {
+            return mOnDeactivatedFunction();
+        }
+        return true;
+    }
+
+    bool invokeOnPlayFunction() const {
+        if (mOnPlayFunction) {
+            return mOnPlayFunction();
+        }
+        return true;
+    }
+
+    bool invokeOnSaveLoadedFunction() const {
+        if (mOnSaveLoadedFunction) {
+            return mOnSaveLoadedFunction();
+        }
+        return true;
+    }
+
+    bool invokeOnNewSaveFunction() const {
+        if (mOnNewSaveFunction) {
+            return mOnNewSaveFunction();
+        }
+        return true;
+    }
+
+    bool invokeOnNewSaveSelectFunction(GameModeNewSaveState* state) const {
+        *state = GAME_MODE_STATE_PENDING;
+        if (mOnNewSaveSelectFunction) {
+            if (mOnNewSaveSelectFunction(state)) {
+                return true;
+            }
+            *state = GAME_MODE_STATE_RETURN;
+            return false;
+        }
+        *state = GAME_MODE_STATE_PROCEED;
+        return true;
+    }
+
+    bool invokeOnGameResetFunction() const {
+        if (mOnGameResetFunction) {
+            return mOnGameResetFunction();
+        }
+        return true;
+    }
+
+    bool invokeOnTickFunction() const {
+        if (mOnTickFunction) {
+            return mOnTickFunction();
+        }
+        return true;
+    }
+
+    Callback mOnActivatedFunction;
+    Callback mOnDeactivatedFunction;
+    Callback mOnPlayFunction;
+    Callback mOnSaveLoadedFunction;
+    Callback mOnNewSaveFunction;
+    NewSaveSelectCallback mOnNewSaveSelectFunction;
+    Callback mOnGameResetFunction;
+    Callback mOnTickFunction;
+};
+
+class GameModeManager {
+public:
+    GameModeManager();
+    void registerGameMode(const GameMode& gameMode);
+    void unregisterGameMode(const GameModeId& gameModeId);
+
+    const GameMode* getCurrentGameMode() const {
+        const auto& it = mRegisteredGameModes.find(mCurrentGameModeId);
+        return it != mRegisteredGameModes.end() ? &it->second :
+                                                  &mRegisteredGameModes.at(kVanillaGameModeId);
+    }
+    bool isCurrentGameMode(const GameModeId& id) const {
+        const GameMode* gameMode = getCurrentGameMode();
+        if (gameMode && gameMode->getId() == id) {
+            return true;
+        }
+        return false;
+    }
+    bool setCurrentGameMode(const GameModeId& id);
+    void setGameModeToPrevious();
+
+    const std::map<GameModeId, GameMode>& getRegisteredGameModes() const {
+        return mRegisteredGameModes;
+    }
+
+private:
+    GameModeId mCurrentGameModeId;
+    std::map<GameModeId, GameMode> mRegisteredGameModes;
+};
+
+extern GameModeManager g_GameModeManager;
+
+inline GameModeManager& getGameModeManager() {
+    return g_GameModeManager;
+}
+
+}  // namespace dusk::gamemode
diff --git a/src/dusk/gamepad_color.cpp b/src/dusk/gamepad_color.cpp
index 9fea8fd769..36e738c29e 100644
--- a/src/dusk/gamepad_color.cpp
+++ b/src/dusk/gamepad_color.cpp
@@ -1,14 +1,17 @@
-#include <cmath>
-#include <SSystem/SComponent/c_xyz.h>
-#include <d/d_com_inf_game.h>
-#include <d/actor/d_a_player.h>
-#include <d/actor/d_a_alink.h>
-#include <dusk/gamepad_color.h>
+#include "dusk/gamepad_color.h"
 
 #include "ui/controller_config.hpp"
 
+#include "d/d_com_inf_game.h"
+#include "d/actor/d_a_player.h"
+#include "d/actor/d_a_alink.h"
+
+#include <SSystem/SComponent/c_xyz.h>
+
 #include <pad.h>
 
+#include <cmath>
+
 namespace dusk::input {
 
 namespace {
diff --git a/include/dusk/gamepad_color.h b/src/dusk/gamepad_color.h
similarity index 66%
rename from include/dusk/gamepad_color.h
rename to src/dusk/gamepad_color.h
index 0524b0b98d..9e3e35a84e 100644
--- a/include/dusk/gamepad_color.h
+++ b/src/dusk/gamepad_color.h
@@ -1,11 +1,6 @@
 #pragma once
 
-#ifndef GAMEPAD_COLOR_H
-#define GAMEPAD_COLOR_H
-
 namespace dusk::input {
     void handleGamepadColor();
     bool pad_has_led(int port) noexcept;
 }
-
-#endif
\ No newline at end of file
diff --git a/src/dusk/gfx.hpp b/src/dusk/gfx.hpp
new file mode 100644
index 0000000000..adb04bee51
--- /dev/null
+++ b/src/dusk/gfx.hpp
@@ -0,0 +1,10 @@
+#pragma once
+
+#include "mods/svc/gfx.h"
+
+namespace dusk::mods {
+
+void gfx_run_stage(GfxStage stage, const view_class* gameView = nullptr,
+    const view_port_class* gameViewport = nullptr);
+
+}  // namespace dusk::mods
diff --git a/src/dusk/globals.cpp b/src/dusk/globals.cpp
index 49ab54ccbe..34649470c9 100644
--- a/src/dusk/globals.cpp
+++ b/src/dusk/globals.cpp
@@ -1,6 +1,25 @@
 #include <dolphin/types.h>
 #include <d/d_kankyo.h>
 #include <d/d_debug_pad.h>
+#include "dusk/dusk.h"
+#include "dusk/main.h"
+
+bool dusk::IsRunning = true;
+bool dusk::IsShuttingDown = false;
+bool dusk::IsGameLaunched = false;
+bool dusk::RestartRequested = false;
+uint8_t dusk::SaveRequested = 0;
+dusk::StageRequest dusk::StageRequested{"", false};
+std::filesystem::path dusk::ConfigPath;
+std::filesystem::path dusk::CachePath;
+AuroraStats dusk::lastFrameAuroraStats;
+float dusk::frameUsagePct = 0.0f;
+
+void dusk::RequestRestart() noexcept {
+    RestartRequested = SupportsProcessRestart;
+    IsRunning = false;
+}
+
 u8 g_printOtherHeapDebug;
 
 dKankyo_HIO_c g_kankyoHIO;
@@ -15,5 +34,5 @@ DSPTaskInfo* __DSP_first_task;
 DSPTaskInfo* __DSP_curr_task;
 
 // mDo_dvd
-#include <m_Do/m_Do_dvd_thread.h>
+#include "m_Do/m_Do_dvd_thread.h"
 u8 mDoDvdThd::DVDLogoMode;
diff --git a/include/dusk/gyro.h b/src/dusk/gyro.h
similarity index 100%
rename from include/dusk/gyro.h
rename to src/dusk/gyro.h
diff --git a/src/dusk/hash.hpp b/src/dusk/hash.hpp
new file mode 100644
index 0000000000..da88aa5547
--- /dev/null
+++ b/src/dusk/hash.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <picosha2.h>
+
+#include <cstdint>
+#include <span>
+#include <string>
+
+namespace dusk::hash {
+
+class Sha256 {
+public:
+    void update(std::span<const uint8_t> bytes) {
+        mHasher.process(bytes.begin(), bytes.end());
+    }
+
+    std::string finish() {
+        mHasher.finish();
+        return picosha2::get_hash_hex_string(mHasher);
+    }
+
+private:
+    picosha2::hash256_one_by_one mHasher;
+};
+
+}  // namespace dusk::hash
diff --git a/include/dusk/hotkeys.h b/src/dusk/hotkeys.h
similarity index 89%
rename from include/dusk/hotkeys.h
rename to src/dusk/hotkeys.h
index 7a774bde80..bdf1778c3f 100644
--- a/include/dusk/hotkeys.h
+++ b/src/dusk/hotkeys.h
@@ -1,5 +1,4 @@
-#ifndef DUSK_HOTKEYS_H
-#define DUSK_HOTKEYS_H
+#pragma once
 
 namespace dusk::hotkeys {
 
@@ -23,5 +22,3 @@ constexpr const char* TOGGLE_FULLSCREEN = "F11";
 constexpr const char* TURBO = "Tab";
 
 }
-
-#endif // DUSK_HOTKEYS_H
diff --git a/src/dusk/hq_minimap.cpp b/src/dusk/hq_minimap.cpp
new file mode 100644
index 0000000000..790597d579
--- /dev/null
+++ b/src/dusk/hq_minimap.cpp
@@ -0,0 +1,211 @@
+#include "dusk/texture_replacements.hpp"
+
+#include <aurora/texture.hpp>
+#include <fmt/format.h>
+
+#include <array>
+#include <cassert>
+#include <span>
+#include <numbers>
+
+namespace {
+
+constexpr u16 kMapIconResolutionMultiplier = 4;
+constexpr u16 kMapImageSide = 16 * kMapIconResolutionMultiplier;
+constexpr u32 kMapImageTotalPixels = kMapImageSide * kMapImageSide;
+
+// give higher priority to user and mod replacements
+constexpr auto kInternalTextureReplacementPriority = dusk::texture_replacements::kUserTextureReplacementPriority - 1;
+
+typedef std::function<u8(size_t, size_t)> PaintI8Fn;
+
+enum class ArcIndex : int {
+    Circle16 = 82,  // map_icon_circle16x16_4i.bti - simple circle
+    Circle   = 76,  // im_map_icon_circle_4i.bti - outlined circle
+    Nijumaru = 78,  // im_map_icon_nijumaru_4i.bti - concentric rings
+    Enter    = 77,  // im_map_icon_enter_4i.bti - outlined octagram
+    TryForce = 81,  // im_map_icon_try_force_4i.bti - outlined circle with triangle
+};
+
+struct Replacement {
+    ArcIndex index;
+    PaintI8Fn painter;
+};
+
+struct Icon {
+    u8* origData = nullptr;
+    std::unique_ptr<u8[]> newData;
+    std::string label;
+    std::optional<aurora::texture::ReplacementRegistration> reg;
+};
+
+bool s_initialized = false;
+bool s_active = false;
+std::unordered_map<int, Icon> s_icons;
+
+void paint_i8(std::span<u8> dst, size_t width, PaintI8Fn paint) {
+    assert(width % 8 == 0 && dst.size() % 32 == 0);
+
+    const auto blocksAcross = width >> 3;
+
+    for (size_t i = 0; i < dst.size(); i++) {
+        // 8x4 block swizzling for I8
+        const auto blockIdx = i >> 5;
+        const auto localIdx = i & 31;
+
+        const auto blockY = blockIdx / blocksAcross;
+        const auto blockX = blockIdx % blocksAcross;
+
+        const auto localY = localIdx >> 3;
+        const auto localX = localIdx & 7;
+
+        const auto x = (blockX << 3) + localX;
+        const auto y = (blockY << 2) + localY;
+
+        dst[i] = paint(x, y);
+    }
+}
+
+void draw_all_replacements() {
+    constexpr auto center = kMapImageSide / 2.0f;
+    constexpr auto radiusSq = center * center;
+
+    // clang-format off
+    const auto replacements = std::to_array<Replacement>({
+        {
+            ArcIndex::Circle16,
+            [=](auto x, auto y) {
+                const auto dx = (x + 0.5f) - center;
+                const auto dy = (y + 0.5f) - center;
+                return (dx * dx + dy * dy < radiusSq) ? 0x11 : 0;
+            }
+        },
+        {
+            ArcIndex::Circle,
+            [=](auto x, auto y) {
+                constexpr auto innerRadius = kMapImageSide * 3.0f / 8.0f;
+                constexpr auto innerRadiusSq = innerRadius * innerRadius;
+
+                const auto dx = (x + 0.5f) - center;
+                const auto dy = (y + 0.5f) - center;
+                const auto dSq = dx * dx + dy * dy;
+
+                return dSq < radiusSq ? (dSq < innerRadiusSq ? 0x22 : 0x11) : 0;
+            }
+        },
+        {
+            ArcIndex::Nijumaru,
+            [=](auto x, auto y) {
+                constexpr u8 nijumaruRings[] = {0x11, 0x22, 0x11, 0x11, 0x22, 0x22};
+
+                const auto dx = (x + 0.5f) - center;
+                const auto dy = (y + 0.5f) - center;
+                const auto dSq = dx * dx + dy * dy;
+
+                if (dSq < radiusSq) {
+                    auto ringIndex = static_cast<size_t>(std::trunc(std::sqrt(dSq) / kMapImageSide * 12));
+                    ringIndex = std::min(ringIndex, sizeof(nijumaruRings) - 1);
+                    return nijumaruRings[ringIndex];
+                }
+                return u8{0};
+            }
+        },
+        {
+            ArcIndex::Enter,
+            [=](auto x, auto y) {
+                constexpr auto outlineWidth = kMapImageSide / 6.0f;
+
+                const auto adx = std::abs((x + 0.5f) - center);
+                const auto ady = std::abs((y + 0.5f) - center);
+                const auto dist =
+                    std::min(adx + ady, std::max(adx, ady) * std::numbers::sqrt2_v<float>) -
+                    kMapImageSide / 2.0f;
+
+                return dist > 0.0f ? 0 : (dist > -outlineWidth ? 0x22 : 0x33);
+            }
+        },
+        {
+            ArcIndex::TryForce,
+            [=](auto x, auto y) {
+                constexpr auto innerRadiusNorm = 5.0f / 12.0f;
+                constexpr auto innerRadius = kMapImageSide * innerRadiusNorm;
+                constexpr auto innerRadiusSq = innerRadius * innerRadius;
+                constexpr auto triRadius = kMapImageSide * innerRadiusNorm / 2.0f;
+
+                const auto dx = (x + 0.5f) - center;
+                const auto dy = (y + 0.5f) - center;
+                const auto dSq = dx * dx + dy * dy;
+                const auto triSideDist = (std::numbers::sqrt3_v<float> * std::abs(dx) - dy) * 0.5f;
+                const auto insideTri = std::max(dy, triSideDist) < triRadius;
+
+                return insideTri ? 0x22 : (dSq < radiusSq ? (dSq < innerRadiusSq ? 0x33 : 0x22) : 0);
+            }
+        }
+    });
+    // clang-format on
+
+    for (const auto r : replacements) {
+        auto pixels = std::make_unique_for_overwrite<u8[]>(kMapImageTotalPixels);
+        paint_i8(std::span{pixels.get(), kMapImageTotalPixels}, kMapImageSide, r.painter);
+        
+        auto& icon = s_icons[static_cast<int>(r.index)];
+        icon.newData = std::move(pixels);
+        icon.label = fmt::format("hq minimap icon {}", static_cast<int>(r.index));
+    }
+}
+
+}  // namespace
+
+namespace dusk::hq_minimap {
+
+void register_pointer(int idx, u8* ptr) {
+    if (s_initialized) {
+        return;
+    }
+
+    s_icons[idx].origData = ptr;
+}
+
+void set_active(bool active) {
+    s_active = active;
+}
+
+void update() {
+    if (!s_initialized) {
+        return;
+    }
+
+    for (auto& [idx, icon] : s_icons) {
+        const bool shouldBeRegistered = s_active && icon.origData && icon.newData;
+
+        if (shouldBeRegistered && !icon.reg) {
+            aurora::texture::ReplacementKey key{aurora::texture::TexturePointerKey{icon.origData}};
+            aurora::texture::RawTextureReplacement repl{
+                .bytes = std::span{icon.newData.get(), kMapImageTotalPixels},
+                .width = kMapImageSide,
+                .height = kMapImageSide,
+                .mipCount = 1,
+                .gxFormat = GX_TF_I8,
+                .label = icon.label,
+            };
+            icon.reg = aurora::texture::register_replacement(
+                key, repl, {.priority = kInternalTextureReplacementPriority});
+        } else if (!shouldBeRegistered && icon.reg) {
+            aurora::texture::unregister_replacement(*icon.reg);
+            icon.reg.reset();
+        }
+    }
+}
+
+void initialize_if_needed() {
+    if (s_initialized) {
+        return;
+    }
+
+    draw_all_replacements();
+    s_initialized = true;
+
+    update();
+}
+
+}  // namespace dusk::hq_minimap
diff --git a/src/dusk/hq_minimap.hpp b/src/dusk/hq_minimap.hpp
new file mode 100644
index 0000000000..5ca89ac7d1
--- /dev/null
+++ b/src/dusk/hq_minimap.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+namespace dusk::hq_minimap {
+
+/// Adds a mapping of an image resource index (into `Always.arc`) to the pointer to its image data.
+/// If `initialize_if_needed` has been called, this is a no-op. Pointers are expected to be stable
+/// and valid for the program's entire lifetime.
+void register_pointer(int idx, u8* ptr);
+
+/// Sets whether HQ minimap texture replacements should be active or not. Does not manage 
+/// replacement registrations itself; see `update`.
+void set_active(bool active);
+
+/// Registers or unregisters texture replacements depending on active state.
+void update();
+
+/// Called once after registering image pointers, in which their HQ replacements are procedurally
+/// drawn and `update` is called. Further calls are no-ops.
+void initialize_if_needed();
+
+}
diff --git a/src/dusk/http/android.cpp b/src/dusk/http/android.cpp
deleted file mode 100644
index 3f4eef8d84..0000000000
--- a/src/dusk/http/android.cpp
+++ /dev/null
@@ -1,402 +0,0 @@
-#include "http.hpp"
-
-#include <SDL3/SDL_system.h>
-#include <jni.h>
-
-#include <algorithm>
-#include <limits>
-#include <string_view>
-#include <utility>
-
-namespace dusk::http {
-namespace {
-
-constexpr int JavaErrorNone = 0;
-constexpr int JavaErrorInvalidUrl = 1;
-constexpr int JavaErrorUnsupportedScheme = 2;
-constexpr int JavaErrorTimeout = 3;
-constexpr int JavaErrorTooLarge = 4;
-
-int timeout_ms(std::chrono::milliseconds timeout) {
-    const auto count = std::max<std::chrono::milliseconds::rep>(1, timeout.count());
-    return static_cast<int>(
-        std::min<std::chrono::milliseconds::rep>(count, std::numeric_limits<int>::max()));
-}
-
-jlong max_body_bytes(size_t maxBodyBytes) {
-    return static_cast<jlong>(std::min<size_t>(
-        maxBodyBytes, static_cast<size_t>(std::numeric_limits<jlong>::max())));
-}
-
-bool clear_pending_exception(JNIEnv* env) {
-    if (env == nullptr || !env->ExceptionCheck()) {
-        return false;
-    }
-    env->ExceptionClear();
-    return true;
-}
-
-std::string to_string(JNIEnv* env, jstring value) {
-    if (env == nullptr || value == nullptr) {
-        return {};
-    }
-
-    const char* utf8 = env->GetStringUTFChars(value, nullptr);
-    if (utf8 == nullptr) {
-        clear_pending_exception(env);
-        return {};
-    }
-
-    std::string result(utf8);
-    env->ReleaseStringUTFChars(value, utf8);
-    return result;
-}
-
-jstring to_jstring(JNIEnv* env, std::string_view value) {
-    if (env == nullptr) {
-        return nullptr;
-    }
-    return env->NewStringUTF(std::string(value).c_str());
-}
-
-Error map_java_error(int error) {
-    switch (error) {
-    case JavaErrorNone:
-        return Error::None;
-    case JavaErrorInvalidUrl:
-        return Error::InvalidUrl;
-    case JavaErrorUnsupportedScheme:
-        return Error::UnsupportedScheme;
-    case JavaErrorTimeout:
-        return Error::Timeout;
-    case JavaErrorTooLarge:
-        return Error::TooLarge;
-    default:
-        return Error::Network;
-    }
-}
-
-jclass load_dusk_class(JNIEnv* env, jobject activity, const char* className) {
-    jclass activityClass = env->GetObjectClass(activity);
-    if (activityClass == nullptr || clear_pending_exception(env)) {
-        return nullptr;
-    }
-
-    jmethodID getClassLoader =
-        env->GetMethodID(activityClass, "getClassLoader", "()Ljava/lang/ClassLoader;");
-    env->DeleteLocalRef(activityClass);
-    if (getClassLoader == nullptr || clear_pending_exception(env)) {
-        return nullptr;
-    }
-
-    jobject classLoader = env->CallObjectMethod(activity, getClassLoader);
-    if (classLoader == nullptr || clear_pending_exception(env)) {
-        return nullptr;
-    }
-
-    jclass classLoaderClass = env->FindClass("java/lang/ClassLoader");
-    if (classLoaderClass == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(classLoader);
-        return nullptr;
-    }
-
-    jmethodID loadClass = env->GetMethodID(
-        classLoaderClass, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
-    env->DeleteLocalRef(classLoaderClass);
-    if (loadClass == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(classLoader);
-        return nullptr;
-    }
-
-    jstring javaClassName = env->NewStringUTF(className);
-    if (javaClassName == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(classLoader);
-        return nullptr;
-    }
-
-    auto* loadedClass =
-        static_cast<jclass>(env->CallObjectMethod(classLoader, loadClass, javaClassName));
-    env->DeleteLocalRef(javaClassName);
-    env->DeleteLocalRef(classLoader);
-    if (loadedClass == nullptr || clear_pending_exception(env)) {
-        return nullptr;
-    }
-
-    return loadedClass;
-}
-
-jobjectArray make_string_array(JNIEnv* env, const std::vector<Header>& headers, bool names) {
-    jclass stringClass = env->FindClass("java/lang/String");
-    if (stringClass == nullptr || clear_pending_exception(env)) {
-        return nullptr;
-    }
-
-    jobjectArray array =
-        env->NewObjectArray(static_cast<jsize>(headers.size()), stringClass, nullptr);
-    env->DeleteLocalRef(stringClass);
-    if (array == nullptr || clear_pending_exception(env)) {
-        return nullptr;
-    }
-
-    for (jsize i = 0; i < static_cast<jsize>(headers.size()); ++i) {
-        const std::string& value = names ? headers[static_cast<size_t>(i)].name :
-                                           headers[static_cast<size_t>(i)].value;
-        jstring javaValue = to_jstring(env, value);
-        if (javaValue == nullptr || clear_pending_exception(env)) {
-            env->DeleteLocalRef(array);
-            return nullptr;
-        }
-        env->SetObjectArrayElement(array, i, javaValue);
-        env->DeleteLocalRef(javaValue);
-        if (clear_pending_exception(env)) {
-            env->DeleteLocalRef(array);
-            return nullptr;
-        }
-    }
-
-    return array;
-}
-
-std::vector<Header> read_headers(JNIEnv* env, jobjectArray names, jobjectArray values) {
-    std::vector<Header> headers;
-    if (names == nullptr || values == nullptr) {
-        return headers;
-    }
-
-    const jsize count = std::min(env->GetArrayLength(names), env->GetArrayLength(values));
-    headers.reserve(static_cast<size_t>(count));
-    for (jsize i = 0; i < count; ++i) {
-        auto* name = static_cast<jstring>(env->GetObjectArrayElement(names, i));
-        auto* value = static_cast<jstring>(env->GetObjectArrayElement(values, i));
-        if (clear_pending_exception(env)) {
-            if (name != nullptr) {
-                env->DeleteLocalRef(name);
-            }
-            if (value != nullptr) {
-                env->DeleteLocalRef(value);
-            }
-            headers.clear();
-            return headers;
-        }
-
-        if (name != nullptr) {
-            headers.push_back({
-                .name = to_string(env, name),
-                .value = to_string(env, value),
-            });
-        }
-
-        if (name != nullptr) {
-            env->DeleteLocalRef(name);
-        }
-        if (value != nullptr) {
-            env->DeleteLocalRef(value);
-        }
-    }
-
-    return headers;
-}
-
-std::string read_body(JNIEnv* env, jbyteArray body) {
-    if (body == nullptr) {
-        return {};
-    }
-
-    const jsize bodySize = env->GetArrayLength(body);
-    std::string result(static_cast<size_t>(bodySize), '\0');
-    if (bodySize > 0) {
-        env->GetByteArrayRegion(body, 0, bodySize, reinterpret_cast<jbyte*>(result.data()));
-        if (clear_pending_exception(env)) {
-            return {};
-        }
-    }
-    return result;
-}
-
-Result result_from_response(JNIEnv* env, jobject response) {
-    if (response == nullptr) {
-        return {
-            .error = Error::Network,
-            .message = "Android HTTP request did not return a response",
-        };
-    }
-
-    jclass responseClass = env->GetObjectClass(response);
-    if (responseClass == nullptr || clear_pending_exception(env)) {
-        return {
-            .error = Error::Network,
-            .message = "Failed to inspect Android HTTP response",
-        };
-    }
-
-    jfieldID errorField = env->GetFieldID(responseClass, "error", "I");
-    jfieldID messageField = env->GetFieldID(responseClass, "message", "Ljava/lang/String;");
-    jfieldID statusField = env->GetFieldID(responseClass, "statusCode", "I");
-    jfieldID headerNamesField =
-        env->GetFieldID(responseClass, "headerNames", "[Ljava/lang/String;");
-    jfieldID headerValuesField =
-        env->GetFieldID(responseClass, "headerValues", "[Ljava/lang/String;");
-    jfieldID bodyField = env->GetFieldID(responseClass, "body", "[B");
-    env->DeleteLocalRef(responseClass);
-    if (errorField == nullptr || messageField == nullptr || statusField == nullptr ||
-        headerNamesField == nullptr || headerValuesField == nullptr || bodyField == nullptr ||
-        clear_pending_exception(env))
-    {
-        return {
-            .error = Error::Network,
-            .message = "Android HTTP response shape was not recognized",
-        };
-    }
-
-    const int javaError = env->GetIntField(response, errorField);
-    auto* message = static_cast<jstring>(env->GetObjectField(response, messageField));
-    auto* headerNames = static_cast<jobjectArray>(env->GetObjectField(response, headerNamesField));
-    auto* headerValues =
-        static_cast<jobjectArray>(env->GetObjectField(response, headerValuesField));
-    auto* body = static_cast<jbyteArray>(env->GetObjectField(response, bodyField));
-    if (clear_pending_exception(env)) {
-        return {
-            .error = Error::Network,
-            .message = "Failed to read Android HTTP response",
-        };
-    }
-
-    Response httpResponse{
-        .statusCode = static_cast<int>(env->GetIntField(response, statusField)),
-        .headers = read_headers(env, headerNames, headerValues),
-        .body = read_body(env, body),
-    };
-
-    std::string messageString = to_string(env, message);
-
-    if (message != nullptr) {
-        env->DeleteLocalRef(message);
-    }
-    if (headerNames != nullptr) {
-        env->DeleteLocalRef(headerNames);
-    }
-    if (headerValues != nullptr) {
-        env->DeleteLocalRef(headerValues);
-    }
-    if (body != nullptr) {
-        env->DeleteLocalRef(body);
-    }
-
-    return {
-        .error = map_java_error(javaError),
-        .message = std::move(messageString),
-        .response = std::move(httpResponse),
-    };
-}
-
-}  // namespace
-
-bool available() noexcept {
-    return true;
-}
-
-Backend backend() noexcept {
-    return Backend::Android;
-}
-
-const char* backend_name() noexcept {
-    return "Android";
-}
-
-Result get(const Request& request) {
-    if (request.url.empty()) {
-        return {
-            .error = Error::InvalidUrl,
-            .message = "URL is empty",
-        };
-    }
-    if (!request.url.starts_with("https://")) {
-        return {
-            .error = Error::UnsupportedScheme,
-            .message = "Only https:// URLs are supported",
-        };
-    }
-
-    auto* env = static_cast<JNIEnv*>(SDL_GetAndroidJNIEnv());
-    if (env == nullptr) {
-        return {
-            .error = Error::Network,
-            .message = "Failed to access Android JNI environment",
-        };
-    }
-
-    jobject activity = static_cast<jobject>(SDL_GetAndroidActivity());
-    if (activity == nullptr || clear_pending_exception(env)) {
-        if (activity != nullptr) {
-            env->DeleteLocalRef(activity);
-        }
-        return {
-            .error = Error::Network,
-            .message = "Failed to access Android activity",
-        };
-    }
-
-    jclass clientClass =
-        load_dusk_class(env, activity, "dev.twilitrealm.dusk.DuskHttpClient");
-    env->DeleteLocalRef(activity);
-    if (clientClass == nullptr) {
-        return {
-            .error = Error::Network,
-            .message = "Failed to load Android HTTP helper",
-        };
-    }
-
-    jmethodID getMethod = env->GetStaticMethodID(clientClass, "get",
-        "(Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;IJ)"
-        "Ldev/twilitrealm/dusk/DuskHttpClient$Response;");
-    if (getMethod == nullptr || clear_pending_exception(env)) {
-        env->DeleteLocalRef(clientClass);
-        return {
-            .error = Error::Network,
-            .message = "Failed to find Android HTTP helper method",
-        };
-    }
-
-    jstring url = to_jstring(env, request.url);
-    jobjectArray headerNames = make_string_array(env, request.headers, true);
-    jobjectArray headerValues = make_string_array(env, request.headers, false);
-    if (url == nullptr || headerNames == nullptr || headerValues == nullptr ||
-        clear_pending_exception(env))
-    {
-        if (url != nullptr) {
-            env->DeleteLocalRef(url);
-        }
-        if (headerNames != nullptr) {
-            env->DeleteLocalRef(headerNames);
-        }
-        if (headerValues != nullptr) {
-            env->DeleteLocalRef(headerValues);
-        }
-        env->DeleteLocalRef(clientClass);
-        return {
-            .error = Error::Network,
-            .message = "Failed to prepare Android HTTP request",
-        };
-    }
-
-    jobject response = env->CallStaticObjectMethod(clientClass, getMethod, url, headerNames,
-        headerValues, timeout_ms(request.timeout), max_body_bytes(request.maxBodyBytes));
-    env->DeleteLocalRef(url);
-    env->DeleteLocalRef(headerNames);
-    env->DeleteLocalRef(headerValues);
-    env->DeleteLocalRef(clientClass);
-    if (clear_pending_exception(env)) {
-        return {
-            .error = Error::Network,
-            .message = "Android HTTP request failed with a Java exception",
-        };
-    }
-
-    Result result = result_from_response(env, response);
-    if (response != nullptr) {
-        env->DeleteLocalRef(response);
-    }
-    return result;
-}
-
-}  // namespace dusk::http
diff --git a/src/dusk/http/curl.cpp b/src/dusk/http/curl.cpp
deleted file mode 100644
index 5fdaf88a64..0000000000
--- a/src/dusk/http/curl.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-#include "http.hpp"
-
-#include <curl/curl.h>
-
-#include <algorithm>
-#include <mutex>
-#include <string_view>
-#include <utility>
-
-namespace dusk::http {
-namespace {
-
-struct CurlHeaders {
-    curl_slist* list = nullptr;
-
-    ~CurlHeaders() {
-        if (list != nullptr) {
-            curl_slist_free_all(list);
-        }
-    }
-
-    bool append(const std::string& header) {
-        curl_slist* next = curl_slist_append(list, header.c_str());
-        if (next == nullptr) {
-            return false;
-        }
-        list = next;
-        return true;
-    }
-};
-
-struct CurlContext {
-    Response response;
-    size_t maxBodyBytes = 0;
-    bool tooLarge = false;
-};
-
-void initialize_curl() {
-    curl_global_init(CURL_GLOBAL_DEFAULT);
-}
-
-std::string trim_header_value(std::string_view value) {
-    while (!value.empty() && (value.front() == ' ' || value.front() == '\t')) {
-        value.remove_prefix(1);
-    }
-    while (!value.empty() &&
-           (value.back() == '\r' || value.back() == '\n' || value.back() == ' ' ||
-               value.back() == '\t')) {
-        value.remove_suffix(1);
-    }
-    return std::string(value);
-}
-
-size_t write_body(char* ptr, size_t size, size_t nmemb, void* userdata) {
-    auto* context = static_cast<CurlContext*>(userdata);
-    const size_t bytes = size * nmemb;
-    if (bytes > context->maxBodyBytes ||
-        context->response.body.size() > context->maxBodyBytes - bytes) {
-        context->tooLarge = true;
-        return 0;
-    }
-
-    context->response.body.append(ptr, bytes);
-    return bytes;
-}
-
-size_t write_header(char* ptr, size_t size, size_t nmemb, void* userdata) {
-    auto* context = static_cast<CurlContext*>(userdata);
-    const std::string_view line(ptr, size * nmemb);
-    if (line.starts_with("HTTP/")) {
-        context->response.headers.clear();
-        return size * nmemb;
-    }
-
-    const size_t colon = line.find(':');
-    if (colon == std::string_view::npos) {
-        return size * nmemb;
-    }
-
-    context->response.headers.push_back({
-        .name = std::string(line.substr(0, colon)),
-        .value = trim_header_value(line.substr(colon + 1)),
-    });
-    return size * nmemb;
-}
-
-Error map_curl_error(CURLcode code, bool tooLarge) {
-    if (tooLarge) {
-        return Error::TooLarge;
-    }
-
-    switch (code) {
-    case CURLE_OK:
-        return Error::None;
-    case CURLE_URL_MALFORMAT:
-        return Error::InvalidUrl;
-    case CURLE_UNSUPPORTED_PROTOCOL:
-        return Error::UnsupportedScheme;
-    case CURLE_OPERATION_TIMEDOUT:
-        return Error::Timeout;
-    default:
-        return Error::Network;
-    }
-}
-
-long timeout_ms(std::chrono::milliseconds timeout) {
-    return std::max<std::chrono::milliseconds::rep>(1, timeout.count());
-}
-
-}  // namespace
-
-bool available() noexcept {
-    return true;
-}
-
-Backend backend() noexcept {
-    return Backend::LibCurl;
-}
-
-const char* backend_name() noexcept {
-    return "libcurl";
-}
-
-Result get(const Request& request) {
-    if (request.url.empty()) {
-        return {
-            .error = Error::InvalidUrl,
-            .message = "URL is empty",
-        };
-    }
-    if (!request.url.starts_with("https://")) {
-        return {
-            .error = Error::UnsupportedScheme,
-            .message = "Only https:// URLs are supported",
-        };
-    }
-
-    static std::once_flag initFlag;
-    std::call_once(initFlag, initialize_curl);
-
-    CURL* curl = curl_easy_init();
-    if (curl == nullptr) {
-        return {
-            .error = Error::Network,
-            .message = "Failed to create libcurl request",
-        };
-    }
-
-    CurlHeaders headers;
-    for (const Header& header : request.headers) {
-        if (!headers.append(header.name + ": " + header.value)) {
-            curl_easy_cleanup(curl);
-            return {
-                .error = Error::Network,
-                .message = "Failed to allocate libcurl headers",
-            };
-        }
-    }
-
-    CurlContext context{
-        .maxBodyBytes = request.maxBodyBytes,
-    };
-
-    curl_easy_setopt(curl, CURLOPT_URL, request.url.c_str());
-    curl_easy_setopt(curl, CURLOPT_HTTPGET, 1L);
-    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers.list);
-    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
-    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 5L);
-    curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, timeout_ms(request.timeout));
-    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, timeout_ms(request.timeout));
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_body);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &context);
-    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, write_header);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, &context);
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
-    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
-#if CURL_AT_LEAST_VERSION(7, 85, 0)
-    curl_easy_setopt(curl, CURLOPT_PROTOCOLS_STR, "https");
-    curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS_STR, "https");
-#else
-    curl_easy_setopt(curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTPS);
-    curl_easy_setopt(curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTPS);
-#endif
-
-    const CURLcode code = curl_easy_perform(curl);
-    long statusCode = 0;
-    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &statusCode);
-    curl_easy_cleanup(curl);
-
-    context.response.statusCode = static_cast<int>(statusCode);
-    if (code == CURLE_OK) {
-        return {
-            .response = std::move(context.response),
-        };
-    }
-
-    const Error error = map_curl_error(code, context.tooLarge);
-    return {
-        .error = error,
-        .message = error == Error::TooLarge ? "Response body exceeded the configured limit"
-                                            : curl_easy_strerror(code),
-        .response = std::move(context.response),
-    };
-}
-
-}  // namespace dusk::http
diff --git a/src/dusk/http/http.hpp b/src/dusk/http/http.hpp
deleted file mode 100644
index 54bef6eec1..0000000000
--- a/src/dusk/http/http.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef DUSK_HTTP_HTTP_HPP
-#define DUSK_HTTP_HTTP_HPP
-
-#include <chrono>
-#include <cstddef>
-#include <string>
-#include <vector>
-
-namespace dusk::http {
-
-enum class Backend {
-    None,
-    WinHttp,
-    UrlSession,
-    LibCurl,
-    Android,
-};
-
-enum class Error {
-    None,
-    NoBackend,
-    InvalidUrl,
-    UnsupportedScheme,
-    Timeout,
-    TooLarge,
-    Network,
-};
-
-struct Header {
-    std::string name;
-    std::string value;
-};
-
-struct Request {
-    std::string url;
-    std::vector<Header> headers;
-    std::chrono::milliseconds timeout{10000};
-    size_t maxBodyBytes = 1024 * 1024;
-};
-
-struct Response {
-    int statusCode = 0;
-    std::vector<Header> headers;
-    std::string body;
-};
-
-struct Result {
-    Error error = Error::None;
-    std::string message;
-    Response response;
-};
-
-bool available() noexcept;
-Backend backend() noexcept;
-const char* backend_name() noexcept;
-Result get(const Request& request);
-
-}  // namespace dusk::http
-
-#endif  // DUSK_HTTP_HTTP_HPP
diff --git a/src/dusk/http/no_backend.cpp b/src/dusk/http/no_backend.cpp
deleted file mode 100644
index 4b42afb3c7..0000000000
--- a/src/dusk/http/no_backend.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "http.hpp"
-
-namespace dusk::http {
-
-bool available() noexcept {
-    return false;
-}
-
-Backend backend() noexcept {
-    return Backend::None;
-}
-
-const char* backend_name() noexcept {
-    return "none";
-}
-
-Result get(const Request&) {
-    return {
-        .error = Error::NoBackend,
-        .message = "No HTTP backend is available",
-    };
-}
-
-}  // namespace dusk::http
diff --git a/src/dusk/http/url_session.mm b/src/dusk/http/url_session.mm
deleted file mode 100644
index 01dd699a9c..0000000000
--- a/src/dusk/http/url_session.mm
+++ /dev/null
@@ -1,238 +0,0 @@
-#include "http.hpp"
-
-#import <Foundation/Foundation.h>
-
-#include <algorithm>
-#include <string_view>
-#include <utility>
-
-@interface DuskHttpRequestDelegate : NSObject <NSURLSessionDataDelegate, NSURLSessionTaskDelegate>
-@property(nonatomic) dispatch_semaphore_t semaphore;
-@property(nonatomic) size_t maxBodyBytes;
-@property(nonatomic, strong) NSMutableData* data;
-@property(nonatomic, strong) NSURLResponse* response;
-@property(nonatomic, strong) NSError* error;
-@property(nonatomic) BOOL tooLarge;
-- (instancetype)initWithMaxBodyBytes:(size_t)maxBodyBytes;
-@end
-
-@implementation DuskHttpRequestDelegate
-
-- (instancetype)initWithMaxBodyBytes:(size_t)maxBodyBytes {
-    self = [super init];
-    if (self != nil) {
-        _semaphore = dispatch_semaphore_create(0);
-        _maxBodyBytes = maxBodyBytes;
-        _data = [NSMutableData data];
-    }
-    return self;
-}
-
-- (void)URLSession:(NSURLSession*)session
-              task:(NSURLSessionTask*)task
-    willPerformHTTPRedirection:(NSHTTPURLResponse*)response
-                    newRequest:(NSURLRequest*)request
-              completionHandler:(void (^)(NSURLRequest*))completionHandler {
-    if ([[request.URL.scheme lowercaseString] isEqualToString:@"https"]) {
-        completionHandler(request);
-    } else {
-        completionHandler(nil);
-    }
-}
-
-- (void)URLSession:(NSURLSession*)session
-          dataTask:(NSURLSessionDataTask*)dataTask
-didReceiveResponse:(NSURLResponse*)response
- completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {
-    self.response = response;
-    completionHandler(NSURLSessionResponseAllow);
-}
-
-- (void)URLSession:(NSURLSession*)session
-          dataTask:(NSURLSessionDataTask*)dataTask
-    didReceiveData:(NSData*)data {
-    if (data.length > self.maxBodyBytes ||
-        self.data.length > self.maxBodyBytes - data.length) {
-        self.tooLarge = YES;
-        [dataTask cancel];
-        return;
-    }
-    [self.data appendData:data];
-}
-
-- (void)URLSession:(NSURLSession*)session
-                    task:(NSURLSessionTask*)task
-    didCompleteWithError:(NSError*)error {
-    if (error != nil && !self.tooLarge) {
-        self.error = error;
-    }
-    dispatch_semaphore_signal(self.semaphore);
-}
-
-@end
-
-namespace dusk::http {
-namespace {
-
-NSString* to_nsstring(std::string_view value) {
-    return [[NSString alloc] initWithBytes:value.data()
-                                    length:value.size()
-                                  encoding:NSUTF8StringEncoding];
-}
-
-std::string to_string(NSString* value) {
-    if (value == nil) {
-        return {};
-    }
-
-    const char* utf8 = [value UTF8String];
-    return utf8 == nullptr ? std::string() : std::string(utf8);
-}
-
-Error map_nsurl_error(NSError* error) {
-    if (error == nil || ![error.domain isEqualToString:NSURLErrorDomain]) {
-        return Error::Network;
-    }
-
-    switch (error.code) {
-    case NSURLErrorTimedOut:
-        return Error::Timeout;
-    case NSURLErrorBadURL:
-    case NSURLErrorUnsupportedURL:
-        return Error::InvalidUrl;
-    default:
-        return Error::Network;
-    }
-}
-
-dispatch_time_t timeout_deadline(std::chrono::milliseconds timeout) {
-    const auto milliseconds = std::max<std::chrono::milliseconds::rep>(1, timeout.count());
-    return dispatch_time(DISPATCH_TIME_NOW,
-        static_cast<int64_t>(milliseconds) * static_cast<int64_t>(NSEC_PER_MSEC));
-}
-
-}  // namespace
-
-bool available() noexcept {
-    return true;
-}
-
-Backend backend() noexcept {
-    return Backend::UrlSession;
-}
-
-const char* backend_name() noexcept {
-    return "NSURLSession";
-}
-
-Result get(const Request& request) {
-    @autoreleasepool {
-        if (request.url.empty()) {
-            return {
-                .error = Error::InvalidUrl,
-                .message = "URL is empty",
-            };
-        }
-        if (!request.url.starts_with("https://")) {
-            return {
-                .error = Error::UnsupportedScheme,
-                .message = "Only https:// URLs are supported",
-            };
-        }
-
-        NSString* urlString = to_nsstring(request.url);
-        if (urlString == nil) {
-            return {
-                .error = Error::InvalidUrl,
-                .message = "URL is not valid UTF-8",
-            };
-        }
-
-        NSURL* url = [NSURL URLWithString:urlString];
-        if (url == nil || ![[url.scheme lowercaseString] isEqualToString:@"https"]) {
-            return {
-                .error = Error::InvalidUrl,
-                .message = "Failed to parse URL",
-            };
-        }
-
-        NSMutableURLRequest* urlRequest = [NSMutableURLRequest requestWithURL:url];
-        urlRequest.HTTPMethod = @"GET";
-        urlRequest.timeoutInterval = request.timeout.count() / 1000.0;
-        urlRequest.cachePolicy = NSURLRequestReloadIgnoringLocalCacheData;
-        for (const Header& header : request.headers) {
-            NSString* name = to_nsstring(header.name);
-            NSString* value = to_nsstring(header.value);
-            if (name == nil || value == nil) {
-                return {
-                    .error = Error::InvalidUrl,
-                    .message = "Request header is not valid UTF-8",
-                };
-            }
-            [urlRequest setValue:value forHTTPHeaderField:name];
-        }
-
-        NSURLSessionConfiguration* configuration =
-            [NSURLSessionConfiguration ephemeralSessionConfiguration];
-        configuration.timeoutIntervalForRequest = request.timeout.count() / 1000.0;
-        configuration.timeoutIntervalForResource = request.timeout.count() / 1000.0;
-
-        DuskHttpRequestDelegate* delegate =
-            [[DuskHttpRequestDelegate alloc] initWithMaxBodyBytes:request.maxBodyBytes];
-        NSURLSession* session = [NSURLSession sessionWithConfiguration:configuration
-                                                              delegate:delegate
-                                                         delegateQueue:nil];
-        NSURLSessionDataTask* task = [session dataTaskWithRequest:urlRequest];
-        [task resume];
-
-        if (dispatch_semaphore_wait(delegate.semaphore, timeout_deadline(request.timeout)) != 0) {
-            [task cancel];
-            [session invalidateAndCancel];
-            return {
-                .error = Error::Timeout,
-                .message = "Request timed out",
-            };
-        }
-
-        [session finishTasksAndInvalidate];
-
-        Response response;
-        if ([delegate.response isKindOfClass:[NSHTTPURLResponse class]]) {
-            NSHTTPURLResponse* httpResponse = (NSHTTPURLResponse*)delegate.response;
-            response.statusCode = static_cast<int>(httpResponse.statusCode);
-            NSDictionary* headers = httpResponse.allHeaderFields;
-            for (id key in headers) {
-                id value = headers[key];
-                response.headers.push_back({
-                    .name = to_string([key description]),
-                    .value = to_string([value description]),
-                });
-            }
-        }
-        if (delegate.data != nil && delegate.data.length > 0) {
-            response.body.assign(static_cast<const char*>(delegate.data.bytes),
-                static_cast<size_t>(delegate.data.length));
-        }
-
-        if (delegate.tooLarge) {
-            return {
-                .error = Error::TooLarge,
-                .message = "Response body exceeded the configured limit",
-                .response = std::move(response),
-            };
-        }
-        if (delegate.error != nil) {
-            return {
-                .error = map_nsurl_error(delegate.error),
-                .message = to_string(delegate.error.localizedDescription),
-                .response = std::move(response),
-            };
-        }
-
-        return {
-            .response = std::move(response),
-        };
-    }
-}
-
-}  // namespace dusk::http
diff --git a/src/dusk/http/winhttp.cpp b/src/dusk/http/winhttp.cpp
deleted file mode 100644
index 937579f076..0000000000
--- a/src/dusk/http/winhttp.cpp
+++ /dev/null
@@ -1,320 +0,0 @@
-#include "http.hpp"
-
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <Windows.h>
-#include <winhttp.h>
-
-#include <algorithm>
-#include <limits>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace dusk::http {
-namespace {
-
-struct WinHttpHandle {
-    HINTERNET handle = nullptr;
-
-    WinHttpHandle() = default;
-    explicit WinHttpHandle(HINTERNET handle) : handle(handle) {}
-    WinHttpHandle(const WinHttpHandle&) = delete;
-    WinHttpHandle& operator=(const WinHttpHandle&) = delete;
-
-    ~WinHttpHandle() {
-        if (handle != nullptr) {
-            WinHttpCloseHandle(handle);
-        }
-    }
-
-    operator HINTERNET() const { return handle; }
-};
-
-std::wstring utf8_to_wide(std::string_view value) {
-    if (value.empty()) {
-        return {};
-    }
-
-    const int required = MultiByteToWideChar(
-        CP_UTF8, MB_ERR_INVALID_CHARS, value.data(), static_cast<int>(value.size()), nullptr, 0);
-    if (required <= 0) {
-        return {};
-    }
-
-    std::wstring result(static_cast<size_t>(required), L'\0');
-    MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, value.data(), static_cast<int>(value.size()),
-        result.data(), required);
-    return result;
-}
-
-std::string wide_to_utf8(std::wstring_view value) {
-    if (value.empty()) {
-        return {};
-    }
-
-    const int required = WideCharToMultiByte(
-        CP_UTF8, 0, value.data(), static_cast<int>(value.size()), nullptr, 0, nullptr, nullptr);
-    if (required <= 0) {
-        return {};
-    }
-
-    std::string result(static_cast<size_t>(required), '\0');
-    WideCharToMultiByte(CP_UTF8, 0, value.data(), static_cast<int>(value.size()), result.data(),
-        required, nullptr, nullptr);
-    return result;
-}
-
-DWORD timeout_ms(std::chrono::milliseconds timeout) {
-    const auto count = std::max<std::chrono::milliseconds::rep>(1, timeout.count());
-    return static_cast<DWORD>(
-        std::min<std::chrono::milliseconds::rep>(count, std::numeric_limits<int>::max()));
-}
-
-Error map_winhttp_error(DWORD error) {
-    switch (error) {
-    case ERROR_WINHTTP_TIMEOUT:
-        return Error::Timeout;
-    case ERROR_WINHTTP_INVALID_URL:
-    case ERROR_WINHTTP_UNRECOGNIZED_SCHEME:
-        return Error::InvalidUrl;
-    case ERROR_WINHTTP_SECURE_FAILURE:
-    case ERROR_WINHTTP_CANNOT_CONNECT:
-    case ERROR_WINHTTP_CONNECTION_ERROR:
-    default:
-        return Error::Network;
-    }
-}
-
-Result fail_from_last_error(const char* message) {
-    const DWORD error = GetLastError();
-    return {
-        .error = map_winhttp_error(error),
-        .message = std::string(message) + " (" + std::to_string(error) + ")",
-    };
-}
-
-std::string trim_header_value(std::string_view value) {
-    while (!value.empty() && (value.front() == ' ' || value.front() == '\t')) {
-        value.remove_prefix(1);
-    }
-    while (!value.empty() && (value.back() == '\r' || value.back() == '\n' || value.back() == ' ' ||
-                                 value.back() == '\t'))
-    {
-        value.remove_suffix(1);
-    }
-    return std::string(value);
-}
-
-void parse_headers(std::wstring_view rawHeaders, Response& response) {
-    size_t start = 0;
-    bool firstLine = true;
-    while (start < rawHeaders.size()) {
-        size_t end = rawHeaders.find(L"\r\n", start);
-        if (end == std::wstring_view::npos) {
-            end = rawHeaders.size();
-        }
-
-        const std::wstring_view line = rawHeaders.substr(start, end - start);
-        if (!line.empty() && !firstLine) {
-            const size_t colon = line.find(L':');
-            if (colon != std::wstring_view::npos) {
-                response.headers.push_back({
-                    .name = wide_to_utf8(line.substr(0, colon)),
-                    .value = trim_header_value(wide_to_utf8(line.substr(colon + 1))),
-                });
-            }
-        }
-        firstLine = false;
-
-        if (end == rawHeaders.size()) {
-            break;
-        }
-        start = end + 2;
-    }
-}
-
-bool read_status(HINTERNET request, Response& response) {
-    DWORD statusCode = 0;
-    DWORD statusCodeSize = sizeof(statusCode);
-    if (!WinHttpQueryHeaders(request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
-            WINHTTP_HEADER_NAME_BY_INDEX, &statusCode, &statusCodeSize, WINHTTP_NO_HEADER_INDEX))
-    {
-        return false;
-    }
-    response.statusCode = static_cast<int>(statusCode);
-    return true;
-}
-
-bool read_headers(HINTERNET request, Response& response) {
-    DWORD headerBytes = 0;
-    WinHttpQueryHeaders(request, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_HEADER_NAME_BY_INDEX,
-        WINHTTP_NO_OUTPUT_BUFFER, &headerBytes, WINHTTP_NO_HEADER_INDEX);
-    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        return false;
-    }
-
-    std::wstring rawHeaders(headerBytes / sizeof(wchar_t), L'\0');
-    if (!WinHttpQueryHeaders(request, WINHTTP_QUERY_RAW_HEADERS_CRLF, WINHTTP_HEADER_NAME_BY_INDEX,
-            rawHeaders.data(), &headerBytes, WINHTTP_NO_HEADER_INDEX))
-    {
-        return false;
-    }
-    if (!rawHeaders.empty() && rawHeaders.back() == L'\0') {
-        rawHeaders.pop_back();
-    }
-    parse_headers(rawHeaders, response);
-    return true;
-}
-
-}  // namespace
-
-bool available() noexcept {
-    return true;
-}
-
-Backend backend() noexcept {
-    return Backend::WinHttp;
-}
-
-const char* backend_name() noexcept {
-    return "WinHTTP";
-}
-
-Result get(const Request& request) {
-    if (request.url.empty()) {
-        return {
-            .error = Error::InvalidUrl,
-            .message = "URL is empty",
-        };
-    }
-
-    std::wstring wideUrl = utf8_to_wide(request.url);
-    if (wideUrl.empty()) {
-        return {
-            .error = Error::InvalidUrl,
-            .message = "URL is not valid UTF-8",
-        };
-    }
-
-    URL_COMPONENTS components{};
-    components.dwStructSize = sizeof(components);
-    components.dwSchemeLength = static_cast<DWORD>(-1);
-    components.dwHostNameLength = static_cast<DWORD>(-1);
-    components.dwUrlPathLength = static_cast<DWORD>(-1);
-    components.dwExtraInfoLength = static_cast<DWORD>(-1);
-    if (!WinHttpCrackUrl(wideUrl.c_str(), static_cast<DWORD>(wideUrl.size()), 0, &components)) {
-        return fail_from_last_error("Failed to parse URL");
-    }
-    if (components.nScheme != INTERNET_SCHEME_HTTPS) {
-        return {
-            .error = Error::UnsupportedScheme,
-            .message = "Only https:// URLs are supported",
-        };
-    }
-
-    const std::wstring host(components.lpszHostName, components.dwHostNameLength);
-    std::wstring path;
-    if (components.lpszUrlPath != nullptr && components.dwUrlPathLength > 0) {
-        path.assign(components.lpszUrlPath, components.dwUrlPathLength);
-    }
-    if (components.lpszExtraInfo != nullptr && components.dwExtraInfoLength > 0) {
-        path.append(components.lpszExtraInfo, components.dwExtraInfoLength);
-    }
-    if (path.empty()) {
-        path = L"/";
-    }
-
-    WinHttpHandle session(WinHttpOpen(L"Dusk", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
-        WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0));
-    if (session.handle == nullptr) {
-        return fail_from_last_error("Failed to create WinHTTP session");
-    }
-
-    const DWORD timeout = timeout_ms(request.timeout);
-    WinHttpSetTimeouts(session, timeout, timeout, timeout, timeout);
-
-    WinHttpHandle connection(WinHttpConnect(session, host.c_str(), components.nPort, 0));
-    if (connection.handle == nullptr) {
-        return fail_from_last_error("Failed to connect");
-    }
-
-    WinHttpHandle httpRequest(WinHttpOpenRequest(connection, L"GET", path.c_str(), nullptr,
-        WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE));
-    if (httpRequest.handle == nullptr) {
-        return fail_from_last_error("Failed to create request");
-    }
-
-    DWORD redirectPolicy = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP;
-    WinHttpSetOption(
-        httpRequest, WINHTTP_OPTION_REDIRECT_POLICY, &redirectPolicy, sizeof(redirectPolicy));
-    DWORD maxRedirects = 5;
-    WinHttpSetOption(httpRequest, WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS, &maxRedirects,
-        sizeof(maxRedirects));
-
-    for (const Header& header : request.headers) {
-        const std::wstring wideHeader = utf8_to_wide(header.name + ": " + header.value);
-        if (wideHeader.empty()) {
-            return {
-                .error = Error::InvalidUrl,
-                .message = "Request header is not valid UTF-8",
-            };
-        }
-        if (!WinHttpAddRequestHeaders(httpRequest, wideHeader.c_str(),
-                static_cast<DWORD>(wideHeader.size()), WINHTTP_ADDREQ_FLAG_ADD))
-        {
-            return fail_from_last_error("Failed to add request header");
-        }
-    }
-
-    if (!WinHttpSendRequest(
-            httpRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0))
-    {
-        return fail_from_last_error("Failed to send request");
-    }
-    if (!WinHttpReceiveResponse(httpRequest, nullptr)) {
-        return fail_from_last_error("Failed to receive response");
-    }
-
-    Response response;
-    if (!read_status(httpRequest, response)) {
-        return fail_from_last_error("Failed to read response status");
-    }
-    read_headers(httpRequest, response);
-
-    for (;;) {
-        DWORD availableBytes = 0;
-        if (!WinHttpQueryDataAvailable(httpRequest, &availableBytes)) {
-            return fail_from_last_error("Failed to query response body");
-        }
-        if (availableBytes == 0) {
-            break;
-        }
-        if (availableBytes > request.maxBodyBytes ||
-            response.body.size() > request.maxBodyBytes - availableBytes)
-        {
-            return {
-                .error = Error::TooLarge,
-                .message = "Response body exceeded the configured limit",
-                .response = std::move(response),
-            };
-        }
-
-        std::vector<char> buffer(availableBytes);
-        DWORD bytesRead = 0;
-        if (!WinHttpReadData(httpRequest, buffer.data(), availableBytes, &bytesRead)) {
-            return fail_from_last_error("Failed to read response body");
-        }
-        response.body.append(buffer.data(), bytesRead);
-    }
-
-    return {
-        .response = std::move(response),
-    };
-}
-
-}  // namespace dusk::http
diff --git a/src/dusk/imgui/ImGuiActorSpawner.cpp b/src/dusk/imgui/ImGuiActorSpawner.cpp
index f3aefd4c41..ba2a41dcc4 100644
--- a/src/dusk/imgui/ImGuiActorSpawner.cpp
+++ b/src/dusk/imgui/ImGuiActorSpawner.cpp
@@ -1,12 +1,13 @@
-#include "imgui.h"
-
 #include "ImGuiMenuTools.hpp"
+
 #include "d/actor/d_a_alink.h"
-#include "d/d_com_inf_game.h"
 #include "f_op/f_op_actor_mng.h"
+
 #include "SSystem/SComponent/c_sxyz.h"
 #include "SSystem/SComponent/c_xyz.h"
 
+#include <imgui.h>
+
 namespace dusk {
 namespace {
 
diff --git a/src/dusk/imgui/ImGuiBloomWindow.cpp b/src/dusk/imgui/ImGuiBloomWindow.cpp
index 1741f82cd8..e22b86ee1e 100644
--- a/src/dusk/imgui/ImGuiBloomWindow.cpp
+++ b/src/dusk/imgui/ImGuiBloomWindow.cpp
@@ -1,11 +1,13 @@
-#include <algorithm>
-
-#include "imgui.h"
-
 #include "ImGuiBloomWindow.hpp"
+
 #include "ImGuiMenuTools.hpp"
+
 #include "m_Do/m_Do_graphic.h"
 
+#include <imgui.h>
+
+#include <algorithm>
+
 namespace dusk {
 namespace {
 struct BloomOverride {
diff --git a/src/dusk/imgui/ImGuiCameraOverlay.cpp b/src/dusk/imgui/ImGuiCameraOverlay.cpp
index 320c41ec92..914f13f1af 100644
--- a/src/dusk/imgui/ImGuiCameraOverlay.cpp
+++ b/src/dusk/imgui/ImGuiCameraOverlay.cpp
@@ -1,13 +1,16 @@
-#include "f_op/f_op_camera_mng.h"
-#include "SSystem/SComponent/c_xyz.h"
-#include "d/d_com_inf_game.h"
-
-#include "imgui.h"
 #include "ImGuiConfig.hpp"
 #include "ImGuiConsole.hpp"
 #include "ImGuiMenuTools.hpp"
+
 #include "dusk/settings.h"
 
+#include "d/d_com_inf_game.h"
+#include "f_op/f_op_camera_mng.h"
+
+#include "SSystem/SComponent/c_xyz.h"
+
+#include <imgui.h>
+
 namespace dusk {
     void ImGuiMenuTools::ShowCameraOverlay() {
         if (!getSettings().backend.enableAdvancedSettings ||
@@ -64,10 +67,15 @@ namespace dusk {
             if (eventRunning) {
                 ImGui::SetTooltip("Cannot enable while paused or during an active event.");
             } else {
-                ImGui::SetTooltip("Detach camera and fly freely.\n"
-                                  "WASD/Arrows/Left stick: move, Mouse/C-stick: look\n"
-                                  "Ctrl/L: down, Space/R: up, Shift/Z: fast\n"
-                                "Q Key/Y: roll left, R Key/X: roll right");
+                ImGui::SetTooltip("Detach camera and fly freely.\n\n"
+                                  "Controls:\n"
+                                  "WASD/Arrows/Left stick - Move\n"
+                                  "Right Click+Mouse/C-stick - Look\n"
+                                  "Ctrl/L - Down\n"
+                                  "Space/R - Up\n"
+                                  "Shift/Z - Faster\n"
+                                  "Q Key/Y - Roll Left\n"
+                                  "R Key/X - Roll Right");
             }
         }
         if (eventRunning) {
diff --git a/src/dusk/imgui/ImGuiConfig.hpp b/src/dusk/imgui/ImGuiConfig.hpp
index 4bceb36a38..6e6cbdea9d 100644
--- a/src/dusk/imgui/ImGuiConfig.hpp
+++ b/src/dusk/imgui/ImGuiConfig.hpp
@@ -2,7 +2,8 @@
 #define DUSK_IMGUICONFIG_HPP
 
 #include "dusk/config.hpp"
-#include "imgui.h"
+
+#include <imgui.h>
 
 namespace dusk::config {
     inline bool ImGuiCheckbox(const char* title, ConfigVar<bool>& var) {
diff --git a/src/dusk/imgui/ImGuiConsole.cpp b/src/dusk/imgui/ImGuiConsole.cpp
index 3c0131c729..badf7297c2 100644
--- a/src/dusk/imgui/ImGuiConsole.cpp
+++ b/src/dusk/imgui/ImGuiConsole.cpp
@@ -1,32 +1,32 @@
-#include <algorithm>
-#include <array>
-#include <numeric>
-#include <string_view>
-#include <chrono>
-
 #define IMGUI_DEFINE_MATH_OPERATORS
-#include "imgui.h"
-#include <imgui_internal.h>
-
-#include "fmt/format.h"
 #include "ImGuiConsole.hpp"
+
 #include "ImGuiEngine.hpp"
-#include "JSystem/JUtility/JUTGamePad.h"
+
 #include "dusk/action_bindings.h"
-#include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/config.hpp"
 #include "dusk/data.hpp"
-#include "dusk/dusk.h"
-#include "dusk/frame_interpolation.h"
+#include "dusk/game_mode.hpp"
 #include "dusk/livesplit.h"
 #include "dusk/main.h"
+#include "dusk/presentation.hpp"
 #include "dusk/settings.h"
 #include "dusk/ui/ui.hpp"
+
 #include "f_pc/f_pc_manager.h"
 #include "f_pc/f_pc_name.h"
-#include "m_Do/m_Do_controller_pad.h"
-#include "m_Do/m_Do_main.h"
-#include "tracy/Tracy.hpp"
+
+#include "JSystem/JUtility/JUTGamePad.h"
+
+#include <aurora/aurora.h>
+#include <fmt/format.h>
+#include <imgui.h>
+#include <imgui_internal.h>
+#include <tracy/Tracy.hpp>
+
+#include <array>
+#include <chrono>
+#include <string_view>
 
 #if _WIN32
 #define NOMINMAX
@@ -37,6 +37,8 @@ using namespace std::string_literals;
 using namespace std::string_view_literals;
 
 namespace {
+constexpr float kTurboTimeScale = 4.f;
+
 ImGuiWindow* FindDragScrollWindow(ImGuiWindow* window) {
     while (window != nullptr) {
         const bool canScrollX = window->ScrollMax.x > 0.0f;
@@ -235,15 +237,30 @@ namespace dusk {
     }
 
     void ImGuiConsole::UpdateSettings() {
-        getTransientSettings().skipFrameRateLimit = getSettings().game.enableTurboKeybind &&
-            (ImGui::IsKeyDown(ImGuiKey_Tab) || getActionBindHoldAnyPort(ActionBinds::TURBO_SPEED_BUTTON));
+        static bool previousTurboActive = false;
+        static bool previousSlowActive = false;
+        static float previousTimeScale = 1.0f;
 
-        if (dusk::frame_interp::get_ui_tick_pending() && mDoMain::developmentMode == 1 && (mDoCPd_c::getHold(PAD_1) & (PAD_TRIGGER_R | PAD_TRIGGER_L)) == (PAD_TRIGGER_R | PAD_TRIGGER_L) && mDoCPd_c::getTrigY(PAD_1)) {
-            getTransientSettings().moveLinkActive = !getTransientSettings().moveLinkActive;
-        }
-        if (mDoMain::developmentMode != 1) {
-            getTransientSettings().moveLinkActive = false;
+        const bool turboBound = isActionBoundAnyPort(ActionBinds::TURBO_SPEED_BUTTON);
+        const bool turboActive =
+            getSettings().game.enableTurboKeybind &&
+            (turboBound ? getActionBindHoldAnyPort(ActionBinds::TURBO_SPEED_BUTTON) :
+                          ImGui::IsKeyDown(ImGuiKey_Tab));
+        const bool slowDown = turboActive && ImGui::GetIO().KeyShift;
+        if (turboActive != previousTurboActive) {
+            getTransientSettings().turboMode = turboActive;
+            presentation::update_frame_rate_preference();
+            if (turboActive) {
+                previousTimeScale = aurora_get_timescale();
+                aurora_set_timescale(slowDown ? 1.f / kTurboTimeScale : kTurboTimeScale);
+            } else {
+                aurora_set_timescale(previousTimeScale);
+            }
+        } else if (turboActive && slowDown != previousSlowActive) {
+            aurora_set_timescale(slowDown ? 1.f / kTurboTimeScale : kTurboTimeScale);
         }
+        previousTurboActive = turboActive;
+        previousSlowActive = slowDown;
     }
 
     void ImGuiConsole::PreDraw() {
@@ -270,7 +287,7 @@ namespace dusk {
                 m_isHidden = true;
             }
         }
-        
+
         bool showMenu = !m_isHidden;
 
         // The menu bar renders with ImGuiCol_WindowBg behind it. We just want ImGuiCol_MenuBarBg,
@@ -285,7 +302,7 @@ namespace dusk {
 
         if (dusk::IsGameLaunched && !m_isLaunchInitialized) {
             m_isLaunchInitialized = true;
-            if (getSettings().game.speedrunMode && getSettings().game.liveSplitEnabled) {
+            if (dusk::speedrun::isActive() && getSettings().game.liveSplitEnabled) {
                 dusk::speedrun::connectLiveSplit();
             }
         }
@@ -357,7 +374,7 @@ namespace dusk {
 
         m_menuTools.ShowInputViewer();
 
-        if (dusk::IsGameLaunched && !dusk::getSettings().game.speedrunMode) {
+        if (dusk::IsGameLaunched && !dusk::speedrun::isActive()) {
             m_menuTools.ShowDebugOverlay();
             m_menuTools.ShowCameraOverlay();
             m_menuTools.ShowProcessManager();
diff --git a/src/dusk/imgui/ImGuiConsole.hpp b/src/dusk/imgui/ImGuiConsole.hpp
index be344afa3f..87f0b1795a 100644
--- a/src/dusk/imgui/ImGuiConsole.hpp
+++ b/src/dusk/imgui/ImGuiConsole.hpp
@@ -1,15 +1,14 @@
 #ifndef DUSK_IMGUI_HPP
 #define DUSK_IMGUI_HPP
+#include "ImGuiMenuTools.hpp"
 
-#include <deque>
-#include <string>
-#include <string_view>
+#include "dusk/main.h"
 
 #include <aurora/aurora.h>
+#include <imgui.h>
 
-#include "ImGuiMenuTools.hpp"
-#include "dusk/main.h"
-#include "imgui.h"
+#include <string>
+#include <string_view>
 
 union SDL_Event;
 struct ImGuiWindow;
diff --git a/src/dusk/imgui/ImGuiControllerOverlay.cpp b/src/dusk/imgui/ImGuiControllerOverlay.cpp
index ad07978a8b..7432c1f49f 100644
--- a/src/dusk/imgui/ImGuiControllerOverlay.cpp
+++ b/src/dusk/imgui/ImGuiControllerOverlay.cpp
@@ -1,11 +1,12 @@
-#include "m_Do/m_Do_controller_pad.h"
-
-#include "imgui.h"
-#include <imgui_internal.h>
 #include "ImGuiConsole.hpp"
+
 #include "dusk/settings.h"
 
+#include "m_Do/m_Do_controller_pad.h"
+
 #include <dolphin/pad.h>
+#include <imgui.h>
+#include <imgui_internal.h>
 
 namespace dusk {
     void ImGuiMenuTools::ShowInputViewer() {
diff --git a/src/dusk/imgui/ImGuiEngine.cpp b/src/dusk/imgui/ImGuiEngine.cpp
index b2ea1f8e1a..8c4fd16a43 100644
--- a/src/dusk/imgui/ImGuiEngine.cpp
+++ b/src/dusk/imgui/ImGuiEngine.cpp
@@ -1,17 +1,17 @@
 #include "ImGuiEngine.hpp"
 
+#include "dusk/logging.h"
+
+#include <aurora/imgui.h>
+#include <aurora/lib/window.hpp>
+#include <fmt/format.h>
 #include <SDL3/SDL_filesystem.h>
 #include <SDL3/SDL_pixels.h>
 #include <SDL3/SDL_surface.h>
 #include <SDL3/SDL_video.h>
-#include <aurora/imgui.h>
-#include <cmath>
-#include <cstring>
-#include <fmt/format.h>
-#include <string>
 
-#include "aurora/lib/window.hpp"
-#include "dusk/logging.h"
+#include <cmath>
+#include <string>
 
 #ifdef IMGUI_ENABLE_FREETYPE
 #include "misc/freetype/imgui_freetype.h"
diff --git a/src/dusk/imgui/ImGuiEngine.hpp b/src/dusk/imgui/ImGuiEngine.hpp
index 44077c9625..2c40b02c89 100644
--- a/src/dusk/imgui/ImGuiEngine.hpp
+++ b/src/dusk/imgui/ImGuiEngine.hpp
@@ -1,8 +1,8 @@
 #pragma once
 
+#include <imgui.h>
+
 #include <memory>
-#include "imgui.h"
-#include "misc/cpp/imgui_stdlib.h"
 
 namespace dusk {
 class ImGuiEngine {
diff --git a/src/dusk/imgui/ImGuiHeapOverlay.cpp b/src/dusk/imgui/ImGuiHeapOverlay.cpp
index 33209ab0d4..0d6da0b210 100644
--- a/src/dusk/imgui/ImGuiHeapOverlay.cpp
+++ b/src/dusk/imgui/ImGuiHeapOverlay.cpp
@@ -1,13 +1,15 @@
-#include <array>
-#include <optional>
-
 #include "ImGuiConsole.hpp"
 #include "ImGuiMenuTools.hpp"
+
 #include "JSystem/JFramework/JFWSystem.h"
 #include "JSystem/JKernel/JKRExpHeap.h"
 #include "JSystem/JKernel/JKRHeap.h"
-#include "absl/container/flat_hash_map.h"
-#include "imgui.h"
+
+#include <absl/container/flat_hash_map.h>
+#include <imgui.h>
+
+#include <array>
+#include <optional>
 
 struct OpenHeapData {
     bool Safe;
diff --git a/src/dusk/imgui/ImGuiMenuTools.cpp b/src/dusk/imgui/ImGuiMenuTools.cpp
index cf5b22a270..0ecfdce149 100644
--- a/src/dusk/imgui/ImGuiMenuTools.cpp
+++ b/src/dusk/imgui/ImGuiMenuTools.cpp
@@ -1,33 +1,32 @@
-#include "fmt/format.h"
-#include "imgui.h"
-#include "aurora/gfx.h"
-
-#include "ImGuiConfig.hpp"
-#include "dusk/hotkeys.h"
-#include "dusk/settings.h"
-#include "ImGuiConsole.hpp"
 #include "ImGuiMenuTools.hpp"
 
+#include "ImGuiConfig.hpp"
+#include "ImGuiConsole.hpp"
 #include "ImGuiEngine.hpp"
+
+#include "dusk/data.hpp"
+#include "dusk/dusk.h"
+#include "dusk/hotkeys.h"
+#include "dusk/main.h"
+#include "dusk/os.h"
+#include "dusk/settings.h"
+#include "dusk/speedrun.h"
+
 #include "d/actor/d_a_alink.h"
 #include "d/actor/d_a_horse.h"
 #include "d/d_com_inf_game.h"
-#include "dusk/data.hpp"
-#include "dusk/dusk.h"
-#include "dusk/main.h"
 #include "m_Do/m_Do_main.h"
 
+#include <aurora/gfx.h>
 #include <aurora/lib/internal.hpp>
+#include <fmt/format.h>
+#include <imgui.h>
 #include <SDL3/SDL_misc.h>
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
 #endif
 
-namespace aurora::gx {
-extern bool enableLodBias;
-}
-
 namespace dusk {
     ImGuiMenuTools::ImGuiMenuTools() {}
 
@@ -37,7 +36,7 @@ namespace dusk {
                 ImGui::BeginDisabled();
             }
 
-            ImGui::BeginDisabled(getSettings().game.speedrunMode);
+            ImGui::BeginDisabled(dusk::speedrun::isActive());
 
             ImGui::MenuItem("Save Editor", hotkeys::SHOW_SAVE_EDITOR, &m_showSaveEditor);
             ImGui::MenuItem("State Share", hotkeys::SHOW_STATE_SHARE, &m_showStateShare);
@@ -59,7 +58,7 @@ namespace dusk {
         }
 
         if (ImGui::BeginMenu("Debug")) {
-            ImGui::BeginDisabled(getSettings().game.speedrunMode);
+            ImGui::BeginDisabled(dusk::speedrun::isActive());
 
             bool developmentMode = mDoMain::developmentMode == 1;
             if (ImGui::Checkbox("Development Mode", &developmentMode)) {
@@ -75,7 +74,6 @@ namespace dusk {
                     getSettings().game.disableWaterRefraction.setValue(disableWaterRefraction);
                     config::save();
                 }
-                ImGui::Checkbox("Enable LOD Bias", &aurora::gx::enableLodBias);
                 ImGui::EndMenu();
             }
 
@@ -92,6 +90,26 @@ namespace dusk {
                 ImGui::EndMenu();
             }
 
+            auto& triggerView = getTransientSettings().triggerView;
+            if (ImGui::BeginMenu("Trigger View")) {
+                ImGui::Checkbox("Load Zones", &triggerView.loadZones);
+                ImGui::Checkbox("Event Areas", &triggerView.eventAreas);
+                ImGui::Checkbox("Event Tags", &triggerView.eventTags);
+                ImGui::Checkbox("Switch Areas", &triggerView.switchAreas);
+                ImGui::Checkbox("Midna Stops", &triggerView.midnaStops);
+                ImGui::Checkbox("Twilight Gates", &triggerView.twilightGates);
+                ImGui::Checkbox("Checkpoints", &triggerView.checkpoints);
+                ImGui::Checkbox("Paths", &triggerView.paths);
+                ImGui::Separator();
+                ImGui::Checkbox("Transform Distances", &triggerView.transformDists);
+                ImGui::Checkbox("Attention Distances", &triggerView.attentionDists);
+                ImGui::Checkbox("Purple Mist Avoid", &triggerView.purpleMistAvoid);
+                ImGui::Checkbox("Leever Ranges", &triggerView.leevers);
+                ImGui::Separator();
+                ImGui::SliderFloat("Opacity##triggers", &triggerView.opacity, 0.0f, 100.0f);
+                ImGui::EndMenu();
+            }
+
             if (!dusk::IsGameLaunched) {
                 ImGui::BeginDisabled();
             }
diff --git a/src/dusk/imgui/ImGuiMenuTools.hpp b/src/dusk/imgui/ImGuiMenuTools.hpp
index 61fab81f79..68b150b6d4 100644
--- a/src/dusk/imgui/ImGuiMenuTools.hpp
+++ b/src/dusk/imgui/ImGuiMenuTools.hpp
@@ -1,14 +1,10 @@
 #ifndef DUSK_IMGUI_MENUTOOLS_HPP
 #define DUSK_IMGUI_MENUTOOLS_HPP
-
-#include <aurora/aurora.h>
-#include <queue>
-#include <string>
-
-#include "imgui.h"
 #include "ImGuiSaveEditor.hpp"
 #include "ImGuiStateShare.hpp"
 
+#include <string>
+
 namespace dusk {
     class ImGuiMenuTools {
     public:
diff --git a/src/dusk/imgui/ImGuiProcessOverlay.cpp b/src/dusk/imgui/ImGuiProcessOverlay.cpp
index 5b4fff28db..03ad595ac1 100644
--- a/src/dusk/imgui/ImGuiProcessOverlay.cpp
+++ b/src/dusk/imgui/ImGuiProcessOverlay.cpp
@@ -1,19 +1,17 @@
 #define PROCS_DUMP_NAMES 1
 
-#include <cstdio>
+#include "ImGuiConsole.hpp"
+#include "ImGuiMenuTools.hpp"
 
-#include "f_pc/f_pc_name.h"
 #include "f_pc/f_pc_create_iter.h"
 #include "f_pc/f_pc_create_req.h"
 #include "f_pc/f_pc_layer.h"
 #include "f_pc/f_pc_layer_iter.h"
 #include "f_pc/f_pc_leaf.h"
+#include "f_pc/f_pc_name.h"
 #include "f_pc/f_pc_node.h"
-#include "d/d_debug_viewer.h"
-#include "imgui.h"
-#include "ImGuiConsole.hpp"
-#include "ImGuiMenuTools.hpp"
-#include "imgui_internal.h"
+
+#include <imgui.h>
 
 namespace dusk {
     static bool BeginProcTable() {
diff --git a/src/dusk/imgui/ImGuiSaveEditor.cpp b/src/dusk/imgui/ImGuiSaveEditor.cpp
index ec2802de44..866b0fe369 100644
--- a/src/dusk/imgui/ImGuiSaveEditor.cpp
+++ b/src/dusk/imgui/ImGuiSaveEditor.cpp
@@ -1,16 +1,16 @@
-#include "fmt/format.h"
-#include "imgui.h"
-#include "aurora/gfx.h"
+#include "ImGuiSaveEditor.hpp"
 
 #include "ImGuiConsole.hpp"
-#include "ImGuiSaveEditor.hpp"
 #include "ImGuiEventFlags.hpp"
 
+#include "d/actor/d_a_player.h"
 #include "d/d_com_inf_game.h"
 #include "d/d_item_data.h"
 #include "d/d_meter2_info.h"
 #include "d/d_save.h"
-#include "d/actor/d_a_player.h"
+
+#include <fmt/format.h>
+#include <imgui.h>
 
 #include <map>
 
@@ -76,7 +76,7 @@ namespace dusk {
         { dItemNo_WEAR_KOKIRI_e, {"Hero's Clothes"} },
         { dItemNo_ARMOR_e, {"Magic Armor"} },
         { dItemNo_WEAR_ZORA_e, {"Zora Armor"} },
-        { dItemNo_MAGIC_LV1_e, {"Magic Level 1"} },
+        { dItemNo_SHADOW_CRYSTAL_e, {"Shadow Crystal"} },
         { dItemNo_DUNGEON_EXIT_2_e, {"Ooccoo Sr.", ITEMTYPE_EQUIP_e} },
         { dItemNo_WALLET_LV1_e, {"Wallet"} },
         { dItemNo_WALLET_LV2_e, {"Big Wallet"} },
diff --git a/src/dusk/imgui/ImGuiSaveEditor.hpp b/src/dusk/imgui/ImGuiSaveEditor.hpp
index a18262862f..50ac7530a5 100644
--- a/src/dusk/imgui/ImGuiSaveEditor.hpp
+++ b/src/dusk/imgui/ImGuiSaveEditor.hpp
@@ -1,11 +1,6 @@
 #ifndef DUSK_IMGUI_SAVEEDITOR_HPP
 #define DUSK_IMGUI_SAVEEDITOR_HPP
 
-#include <aurora/aurora.h>
-#include <string>
-
-#include "imgui.h"
-
 namespace dusk {
 	class ImGuiSaveEditor {
 	public:
diff --git a/src/dusk/imgui/ImGuiStateShare.cpp b/src/dusk/imgui/ImGuiStateShare.cpp
index 27c6c74517..9f7ee09282 100644
--- a/src/dusk/imgui/ImGuiStateShare.cpp
+++ b/src/dusk/imgui/ImGuiStateShare.cpp
@@ -1,24 +1,26 @@
 #include "ImGuiStateShare.hpp"
-#include "ImGuiMenuTools.hpp"
+
 #include "ImGuiConsole.hpp"
+#include "ImGuiMenuTools.hpp"
 
-#include "imgui.h"
-#include "fmt/format.h"
-#include "absl/strings/escaping.h"
-#include "nlohmann/json.hpp"
-
-#include "d/d_com_inf_game.h"
-#include "dusk/main.h"
+#include "dusk/autosave.h"
 #include "dusk/io.hpp"
 #include "dusk/logging.h"
+#include "dusk/main.h"
 #include "dusk/settings.h"
+
+#include "d/d_com_inf_game.h"
 #include "f_op/f_op_overlap_mng.h"
-#include "../file_select.hpp"
-#include "aurora/lib/window.hpp"
+
+#include <absl/strings/escaping.h>
+#include <aurora/lib/window.hpp>
+#include <borealis/file_select.hpp>
+#include <fmt/format.h>
+#include <imgui.h>
+#include <nlohmann/json.hpp>
+#include <zstd.h>
 
 #include <unordered_set>
-#include <zstd.h>
-#include <dusk/autosave.h>
 
 namespace dusk {
 
@@ -40,15 +42,6 @@ static constexpr auto STATES_FILENAME = "states.json";
 
 static bool ValidateEncodedState(const std::string&);
 
-void ImGuiStateShare::onMergeFileSelected(void* userdata, const char* path, const char* /*error*/) {
-    auto* self = static_cast<ImGuiStateShare*>(userdata);
-    if (path != nullptr) {
-        self->m_pendingMergePath = path;
-    }
-}
-
-
-
 static std::filesystem::path GetStatesFilePath() {
     return ConfigPath / STATES_FILENAME;
 }
@@ -381,8 +374,18 @@ void ImGuiStateShare::draw(bool& open) {
 
     ImGui::SameLine();
     if (ImGui::Button("Load Pack")) {
-        static constexpr SDL_DialogFileFilter filter = {"State pack", "json"};
-        ShowFileSelect(&onMergeFileSelected, this, aurora::window::get_sdl_window(), &filter, 1, nullptr, false);
+        borealis::file_select::open_file(
+            {
+                .parentWindow = aurora::window::get_sdl_window(),
+                .filters = {{"State pack", "json"}},
+            },
+            [this](borealis::file_select::Result result) {
+                if (result.status == borealis::file_select::Status::Selected &&
+                    !result.locations.empty())
+                {
+                    m_pendingMergePath = std::move(result.locations.front());
+                }
+            });
     }
 
     if (!m_states.empty()) {
diff --git a/src/dusk/imgui/ImGuiStateShare.hpp b/src/dusk/imgui/ImGuiStateShare.hpp
index a2dc681833..c847a85ba3 100644
--- a/src/dusk/imgui/ImGuiStateShare.hpp
+++ b/src/dusk/imgui/ImGuiStateShare.hpp
@@ -24,8 +24,6 @@ private:
     void loadStatesFile();
     void saveStatesFile();
     void mergeFromFile(const std::string& path);
-    static void onMergeFileSelected(void* userdata, const char* path, const char* error);
-
     std::vector<SavedStateEntry> m_states;
     std::string m_statusMsg;
     std::optional<dSv_info_c>  m_pendingInfo;
diff --git a/src/dusk/imgui/ImGuiStubLog.cpp b/src/dusk/imgui/ImGuiStubLog.cpp
index 1ac510faf8..cc28bbc53d 100644
--- a/src/dusk/imgui/ImGuiStubLog.cpp
+++ b/src/dusk/imgui/ImGuiStubLog.cpp
@@ -1,9 +1,11 @@
-#include <vector>
-#include <mutex>
+#include "ImGuiMenuTools.hpp"
 
 #include "dusk/logging.h"
-#include "imgui.h"
-#include "ImGuiMenuTools.hpp"
+
+#include <imgui.h>
+
+#include <mutex>
+#include <vector>
 
 namespace dusk {
     static ImGuiTextBuffer StubLogBuffer;
@@ -11,24 +13,8 @@ namespace dusk {
     static bool StubLogPaused;
     static std::mutex StubLogMutex;
 
-    const char* LogLevelName(const AuroraLogLevel level) {
-        switch (level) {
-        case LOG_DEBUG:
-            return "DEBUG";
-        case LOG_INFO:
-            return "INFO";
-        case LOG_WARNING:
-            return "WARNING";
-        case LOG_ERROR:
-            return "ERROR";
-        case LOG_FATAL:
-            return "FATAL";
-        default:
-            return "UNKNOWN";
-        }
-    }
-
-    void SendToStubLog(AuroraLogLevel level, const char* module, const char* message) {
+    void SendToStubLog(
+        borealis::LogLevel level, std::string_view module, std::string_view message) {
         if (StubLogPaused) {
             return;
         }
@@ -41,8 +27,10 @@ namespace dusk {
         }
 
         LineOffsets.push_back(StubLogBuffer.size());
-        const auto levelName = LogLevelName(level);
-        StubLogBuffer.appendf("[%s | %s] %s\n", levelName, module, message);
+        const auto levelName = borealis::to_string(level);
+        StubLogBuffer.appendf("[%.*s | %.*s] %.*s\n", static_cast<int>(levelName.size()),
+            levelName.data(), static_cast<int>(module.size()), module.data(),
+            static_cast<int>(message.size()), message.data());
     }
 
     void ImGuiMenuTools::ShowStubLog() {
diff --git a/src/dusk/interp/camera.cpp b/src/dusk/interp/camera.cpp
new file mode 100644
index 0000000000..19ab197214
--- /dev/null
+++ b/src/dusk/interp/camera.cpp
@@ -0,0 +1,218 @@
+#include "dusk/interp/camera.h"
+
+#include "dusk/game_clock.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/interp/lerp.h"
+
+#include "d/d_com_inf_game.h"
+#include "f_op/f_op_camera_mng.h"
+#include "m_Do/m_Do_graphic.h"
+
+#include <cstring>
+#include <utility>
+
+namespace {
+
+struct CameraSnapshot {
+    cXyz eye{};
+    cXyz center{};
+    cXyz up{};
+    s16 bank{};
+    f32 fovy{};
+    f32 aspect{};
+    f32 near_{};
+    f32 far_{};
+    bool wideZoom{};
+    bool valid{};
+};
+
+CameraSnapshot s_camPrev{};
+CameraSnapshot s_camCurr{};
+
+view_class s_presentationViewBackup{};
+
+void copy_view_to_snap(CameraSnapshot* dst, const view_class& v) {
+    dst->eye = v.lookat.eye;
+    dst->center = v.lookat.center;
+    dst->up = v.lookat.up;
+    dst->bank = v.bank;
+    dst->fovy = v.fovy;
+    dst->aspect = v.aspect;
+    dst->near_ = v.near_;
+    dst->far_ = v.far_;
+    dst->valid = true;
+}
+
+void apply_presented_view(view_class* view) {
+    // FRAME INTERP TODO: Largely copied from d_camera's camera_draw function from this point, got any
+    // better ideas?
+    C_MTXPerspective(view->projMtx, view->fovy, view->aspect, view->near_, view->far_);
+    mDoMtx_lookAt(view->viewMtx, &view->lookat.eye, &view->lookat.center, &view->lookat.up,
+                  view->bank);
+#if WIDESCREEN_SUPPORT
+    mDoGph_gInf_c::setWideZoomProjection(view->projMtx);
+#endif
+    j3dSys.setViewMtx(view->viewMtx);
+    cMtx_inverse(view->viewMtx, view->invViewMtx);
+
+    bool camera_attention_status = dComIfGp_getCameraAttentionStatus(0) & 0x80;
+    Z2GetAudience()->setAudioCamera(view->viewMtx, view->lookat.eye, view->lookat.center, view->fovy,
+                                    view->aspect, camera_attention_status, 0, false);
+
+    dBgS_GndChk gndchk;
+    gndchk.OnWaterGrp();
+    gndchk.SetPos(&view->lookat.eye);
+    f32 cross = dComIfG_Bgsp().GroundCross(&gndchk);
+    if (cross != -G_CM3D_F_INF) {
+        if (dComIfG_Bgsp().ChkGrpInf(gndchk, 0x100)) {
+            mDoAud_getCameraMapInfo(6);
+        } else {
+            mDoAud_getCameraMapInfo(dComIfG_Bgsp().GetMtrlSndId(gndchk));
+        }
+        mDoAud_setCameraGroupInfo(dComIfG_Bgsp().GetGrpSoundId(gndchk));
+        Vec spDC;
+        spDC.x = view->lookat.eye.x;
+        spDC.y = cross;
+        spDC.z = view->lookat.eye.z;
+        Z2AudioMgr::getInterface()->setCameraPolygonPos(&spDC);
+    } else {
+        Z2AudioMgr::getInterface()->setCameraPolygonPos(nullptr);
+    }
+
+    MTXCopy(view->viewMtx, view->viewMtxNoTrans);
+    view->viewMtxNoTrans[0][3] = 0.0f;
+    view->viewMtxNoTrans[1][3] = 0.0f;
+    view->viewMtxNoTrans[2][3] = 0.0f;
+    cMtx_concatProjView(view->projMtx, view->viewMtx, view->projViewMtx);
+
+    f32 far_;
+    f32 var_f30;
+    if (dComIfGp_getCameraAttentionStatus(0) & 8) {
+        far_ = view->far_;
+    } else {
+#if DEBUG
+        if (g_envHIO.mOther.mAdjustCullFar != 0) {
+            var_f30 = g_envHIO.mOther.mCullFarValue;
+        } else
+#endif
+        {
+            var_f30 = dStage_stagInfo_GetCullPoint(dComIfGp_getStageStagInfo());
+        }
+        far_ = var_f30;
+    }
+
+    mDoLib_clipper::setup(view->fovy, view->aspect, view->near_, far_);
+
+    // FRAME INTERP NOTE: Removed the call to offWideZoom that was here, it causes problems with
+    // presentation during cutscenes.
+}
+
+}  // namespace
+
+namespace dusk::interp {
+
+void record_camera(::camera_process_class* cam, int camera_id) {
+    if (!is_enabled() || camera_id != 0 || cam == nullptr) {
+        return;
+    }
+    copy_view_to_snap(&s_camCurr, cam->view);
+#if WIDESCREEN_SUPPORT
+    s_camCurr.wideZoom = mDoGph_gInf_c::isWideZoom();
+#endif
+}
+
+void interp_view(::view_class* view) {
+    if (!is_enabled())
+        return;
+
+    if (!s_camPrev.valid || !s_camCurr.valid)
+        return;
+
+    const f32 step = get_interpolation_step();
+    const bool is_cam_curr_authoritative = game_clock::is_sim_frame() && step <= 0.0f;
+
+    cXyz eye;
+    cXyz center;
+    cXyz up;
+    if (is_cam_curr_authoritative) {
+        eye = s_camCurr.eye;
+        center = s_camCurr.center;
+        up = s_camCurr.up;
+    } else {
+        lerp(eye, s_camPrev.eye, s_camCurr.eye, step);
+        lerp(center, s_camPrev.center, s_camCurr.center, step);
+        lerp(up, s_camPrev.up, s_camCurr.up, step);
+    }
+    if (!up.normalizeRS()) {
+        up = s_camCurr.up;
+        up.normalizeRS();
+    }
+
+    view->lookat.eye = eye;
+    view->lookat.center = center;
+    view->lookat.up = up;
+    if (is_cam_curr_authoritative) {
+        view->bank = s_camCurr.bank;
+        view->fovy = s_camCurr.fovy;
+        view->aspect = s_camCurr.aspect;
+        view->near_ = s_camCurr.near_;
+        view->far_ = s_camCurr.far_;
+    } else {
+        view->bank = lerp(s_camPrev.bank, s_camCurr.bank, step);
+        view->fovy = s_camPrev.fovy + (s_camCurr.fovy - s_camPrev.fovy) * step;
+        view->aspect = s_camPrev.aspect + (s_camCurr.aspect - s_camPrev.aspect) * step;
+        view->near_ = s_camPrev.near_ + (s_camCurr.near_ - s_camPrev.near_) * step;
+        view->far_ = s_camPrev.far_ + (s_camCurr.far_ - s_camPrev.far_) * step;
+    }
+
+    // FRAME INTERP TODO: It might be better if I rewired the game to not clear this flag until the
+    // next sim frame, but I don't care enough to right now
+#if WIDESCREEN_SUPPORT
+    const f32 wide_step = is_cam_curr_authoritative ? 1.0f : step;
+    if (mDoGph_gInf_c::isWide() && !mDoGph_gInf_c::isWideZoom() &&
+        wide_step >= 0.5f ? s_camCurr.wideZoom : s_camPrev.wideZoom)
+    {
+        mDoGph_gInf_c::onWideZoom();
+    }
+#endif
+}
+
+void camera_on_sim_tick() {
+    s_camPrev = std::move(s_camCurr);
+}
+
+void camera_invalidate_snapshots() {
+    s_camPrev.valid = false;
+    s_camCurr.valid = false;
+}
+
+void camera_on_begin_record() {
+    if (dComIfGp_getCamera(0) == nullptr) {
+        camera_invalidate_snapshots();
+    }
+}
+
+bool camera_apply_presentation() {
+    if (!s_camPrev.valid || !s_camCurr.valid) {
+        return false;
+    }
+
+    view_class* const view = dComIfGd_getView();
+    if (view == nullptr) {
+        return false;
+    }
+
+    std::memcpy(&s_presentationViewBackup, view, sizeof(view_class));
+    interp_view(view);
+    apply_presented_view(view);
+    return true;
+}
+
+void camera_restore_presentation() {
+    view_class* const view = dComIfGd_getView();
+    if (view != nullptr) {
+        std::memcpy(view, &s_presentationViewBackup, sizeof(view_class));
+    }
+}
+
+}  // namespace dusk::interp
diff --git a/src/dusk/interp/camera.h b/src/dusk/interp/camera.h
new file mode 100644
index 0000000000..e4a1824979
--- /dev/null
+++ b/src/dusk/interp/camera.h
@@ -0,0 +1,13 @@
+#pragma once
+
+class camera_process_class;
+class view_class;
+
+#ifdef __cplusplus
+namespace dusk::interp {
+
+void record_camera(::camera_process_class* cam, int camera_id);
+void interp_view(::view_class* view);
+
+}  // namespace dusk::interp
+#endif
diff --git a/src/dusk/interp/dual_buffer.cpp b/src/dusk/interp/dual_buffer.cpp
new file mode 100644
index 0000000000..be1160e6a6
--- /dev/null
+++ b/src/dusk/interp/dual_buffer.cpp
@@ -0,0 +1,65 @@
+#include "dusk/interp/dual_buffer.h"
+
+#include <absl/container/flat_hash_map.h>
+#include <vector>
+
+namespace dusk::interp {
+namespace {
+
+struct Slot {
+    const void* type;
+    void* ptr;
+    void (*destroy)(void*);
+};
+
+using OwnerMap = absl::flat_hash_map<uintptr_t, std::vector<Slot>>;
+
+OwnerMap& owner_map() {
+    static OwnerMap s_map;
+    return s_map;
+}
+
+}  // namespace
+
+void* detail::acquire(const void* key, const void* type, void* (*make)(), void (*destroy)(void*)) {
+    const uintptr_t id = reinterpret_cast<uintptr_t>(key);
+    auto& slots = owner_map()[id];
+    for (Slot& slot : slots) {
+        if (slot.type == type) {
+            return slot.ptr;
+        }
+    }
+
+    void* ptr = make();
+    slots.push_back({type, ptr, destroy});
+    return ptr;
+}
+
+void erase_owned_buffers(const void* key) {
+    if (key == nullptr) {
+        return;
+    }
+
+    OwnerMap& stored = owner_map();
+    auto it = stored.find(reinterpret_cast<uintptr_t>(key));
+    if (it == stored.end()) {
+        return;
+    }
+
+    for (Slot& slot : it->second) {
+        slot.destroy(slot.ptr);
+    }
+    stored.erase(it);
+}
+
+void clear_owned_buffers() {
+    OwnerMap& stored = owner_map();
+    for (auto& entry : stored) {
+        for (Slot& slot : entry.second) {
+            slot.destroy(slot.ptr);
+        }
+    }
+    stored.clear();
+}
+
+}  // namespace dusk::interp
diff --git a/src/dusk/interp/dual_buffer.h b/src/dusk/interp/dual_buffer.h
new file mode 100644
index 0000000000..bbae6a3a01
--- /dev/null
+++ b/src/dusk/interp/dual_buffer.h
@@ -0,0 +1,123 @@
+#pragma once
+
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/interp/lerp.h"
+
+#include <cstring>
+
+#ifdef __cplusplus
+namespace dusk::interp {
+
+template <typename T, int capacity>
+class DualBuffer {
+public:
+    explicit DualBuffer(T* dst = NULL)
+        : m_prev_valid(false),
+          m_curr_valid(false),
+          m_count(0),
+          m_dst(dst),
+          m_post(NULL),
+          m_post_user(NULL) {}
+
+    void bind(T* dst) { m_dst = dst; }
+
+    void reset() {
+        m_prev_valid = false;
+        m_curr_valid = false;
+        m_count = 0;
+    }
+
+    bool ready() const { return m_prev_valid && m_curr_valid; }
+
+    void capture_and_schedule(const T* src, int count, void (*post)(void*) = NULL,
+                              void* post_user = NULL) {
+        roll();
+        capture(src, count);
+        schedule(post, post_user);
+    }
+
+    void writeback(T* src_and_dst, int count, void (*post)(void*) = NULL, void* post_user = NULL) {
+        bind(src_and_dst);
+        capture_and_schedule(src_and_dst, count, post, post_user);
+    }
+
+private:
+    bool fits(int count) const {
+        if (count > capacity) {
+            return false;
+        }
+        return count > 0;
+    }
+
+    void roll() {
+        if (!is_enabled() || !m_curr_valid || m_count <= 0) {
+            return;
+        }
+        std::memcpy(m_prev, m_curr, static_cast<size_t>(m_count) * sizeof(T));
+        m_prev_valid = true;
+    }
+
+    void capture(const T* src, int count) {
+        if (!fits(count) || !is_enabled() || src == NULL) {
+            return;
+        }
+        std::memcpy(m_curr, src, static_cast<size_t>(count) * sizeof(T));
+        m_count = count;
+        m_curr_valid = true;
+    }
+
+    void apply(T* dst, int count) const {
+        if (!fits(count) || dst == NULL || !ready()) {
+            return;
+        }
+        const f32 step = get_interpolation_step();
+        for (int i = 0; i < count; ++i) {
+            lerp(dst[i], m_prev[i], m_curr[i], step);
+        }
+    }
+
+    void schedule(void (*post)(void*) = NULL, void* post_user = NULL) {
+        if (!is_enabled() || m_dst == NULL || !fits(m_count)) {
+            return;
+        }
+        m_post = post;
+        m_post_user = post_user;
+        add_interpolation_callback(&present_trampoline, this);
+    }
+
+    static void present_trampoline(void* user) { static_cast<DualBuffer*>(user)->present(); }
+
+    void present() {
+        apply(m_dst, m_count);
+        if (m_post != NULL) {
+            m_post(m_post_user);
+        }
+    }
+
+    T m_prev[capacity];
+    T m_curr[capacity];
+    bool m_prev_valid;
+    bool m_curr_valid;
+    int m_count;
+    T* m_dst;
+    void (*m_post)(void*);
+    void* m_post_user;
+};
+
+namespace detail {
+void* acquire(const void* key, const void* type, void* (*make)(), void (*destroy)(void*));
+}
+
+template <typename Record>
+Record& get(const void* key) {
+    static const char token{};
+    return *static_cast<Record*>(detail::acquire(
+        key, &token, []() -> void* { return new Record; },
+        [](void* p) { delete static_cast<Record*>(p); }));
+}
+
+void erase_owned_buffers(const void* key);
+void clear_owned_buffers();
+
+}  // namespace dusk::interp
+#endif
diff --git a/src/dusk/interp/frame_interpolation.cpp b/src/dusk/interp/frame_interpolation.cpp
new file mode 100644
index 0000000000..4edfee234a
--- /dev/null
+++ b/src/dusk/interp/frame_interpolation.cpp
@@ -0,0 +1,293 @@
+#include "dusk/interp/frame_interpolation.h"
+
+#include "dusk/game_clock.h"
+#include "dusk/interp/dual_buffer.h"
+#include "dusk/interp/lerp.h"
+
+#include "mtx.h"
+
+#include <absl/container/flat_hash_map.h>
+#include <algorithm>
+#include <vector>
+
+namespace dusk::interp {
+void camera_on_sim_tick();
+void camera_on_begin_record();
+bool camera_apply_presentation();
+void camera_restore_presentation();
+void camera_invalidate_snapshots();
+}  // namespace dusk::interp
+
+namespace {
+
+struct Recording {
+    absl::flat_hash_map<uintptr_t, Mtx> matrix_values;
+};
+
+bool s_recording = false;
+bool s_replacementsActive = false;
+bool s_syncPresentation = false;
+
+float s_step = 0.0f;
+bool s_uiTickPending = false;
+uint64_t s_simTickSeq = 0;
+uint64_t s_observedPresentationEpoch = 0;
+
+Recording s_currentRecording;
+Recording s_previousRecording;
+
+absl::flat_hash_map<uintptr_t, Mtx> g_replacements;
+
+int s_presentationDepth = 0;
+
+const Mtx* resolve_replacement(const Mtx* source, Mtx* scratch) {
+    if (!s_replacementsActive || source == nullptr || dusk::interp::presentation_sync_active()) {
+        return source;
+    }
+
+    auto it = g_replacements.find(reinterpret_cast<uintptr_t>(source));
+    if (it == g_replacements.end()) {
+        return source;
+    }
+
+    MTXCopy(it->second, *scratch);
+    return scratch;
+}
+
+bool has_recording_data(const Recording& recording) {
+    return !recording.matrix_values.empty();
+}
+
+void clear_replacements() {
+    g_replacements.clear();
+}
+
+void interpolate_replacements() {
+    clear_replacements();
+    s_replacementsActive = dusk::interp::is_enabled() && !s_recording && !s_syncPresentation &&
+                           has_recording_data(s_currentRecording);
+    if (!s_replacementsActive) {
+        return;
+    }
+    for (auto const& old : s_previousRecording.matrix_values) {
+        if (auto it = s_currentRecording.matrix_values.find(old.first);
+            it != s_currentRecording.matrix_values.end())
+        {
+            dusk::interp::lerp(g_replacements[old.first], old.second, it->second, s_step);
+        }
+    }
+}
+
+struct InterpolationCallBackWork {
+    dusk::interp::InterpolationCallBack pCallBack;
+    void* pUserWork;
+};
+
+std::vector<InterpolationCallBackWork> s_interpolationCallBackWork;
+
+void clear_callbacks() {
+    s_interpolationCallBackWork.clear();
+}
+
+void callbacks_run() {
+    for (const auto& work : s_interpolationCallBackWork) {
+        if (work.pCallBack != nullptr) {
+            work.pCallBack(work.pUserWork);
+        }
+    }
+}
+
+void clear_interpolation_history() {
+    s_recording = false;
+    s_replacementsActive = false;
+    s_syncPresentation = false;
+    s_previousRecording = {};
+    s_currentRecording = {};
+    clear_replacements();
+    dusk::interp::clear_owned_buffers();
+    clear_callbacks();
+    dusk::interp::camera_invalidate_snapshots();
+    s_presentationDepth = 0;
+}
+
+}  // namespace
+
+namespace dusk::interp {
+
+void begin_sim_tick() {
+    if (!is_enabled()) {
+        return;
+    }
+
+    clear_callbacks();
+    camera_on_sim_tick();
+    ++s_simTickSeq;
+}
+
+uint64_t sim_tick_seq() {
+    return s_simTickSeq;
+}
+
+void begin_frame(float step) {
+    const game_clock::FrameTiming& timing = game_clock::g_frameTiming;
+    if (s_observedPresentationEpoch != timing.presentationEpoch) {
+        s_observedPresentationEpoch = timing.presentationEpoch;
+        clear_interpolation_history();
+    }
+
+    s_step = std::clamp(step, 0.0f, 1.0f);
+    if (!is_enabled()) {
+        clear_interpolation_history();
+    }
+}
+
+bool is_enabled() {
+    return game_clock::g_frameTiming.interpolating;
+}
+
+bool should_capture() {
+    return is_enabled() && game_clock::is_sim_frame();
+}
+
+void begin_record() {
+    if (!is_enabled()) {
+        clear_interpolation_history();
+        return;
+    }
+
+    s_syncPresentation = false;
+    s_previousRecording = std::move(s_currentRecording);
+    s_currentRecording = {};
+    s_recording = true;
+    s_replacementsActive = false;
+    clear_replacements();
+    camera_on_begin_record();
+}
+
+void end_record() {
+    s_recording = false;
+}
+
+void request_presentation_sync() {
+    if (!is_enabled()) {
+        return;
+    }
+    s_syncPresentation = true;
+}
+
+bool presentation_sync_active() {
+    if (!is_enabled()) {
+        return false;
+    }
+    return s_syncPresentation;
+}
+
+float get_interpolation_step() {
+    return presentation_sync_active() ? 1.0f : s_step;
+}
+
+void set_ui_tick_pending(bool value) {
+    if (s_uiTickPending == value) {
+        return;
+    }
+    s_uiTickPending = value;
+}
+
+bool get_ui_tick_pending() {
+    return is_enabled() ? s_uiTickPending : true;
+}
+
+void record_final_mtx(Mtx m, const void* key) {
+    if (!s_recording || m == nullptr) {
+        return;
+    }
+
+    auto& it = s_currentRecording.matrix_values[reinterpret_cast<uintptr_t>(key)];
+    MTXCopy(m, it);
+}
+
+void record_final_mtx(Mtx m) {
+    record_final_mtx(m, m);
+}
+
+bool lookup_replacement(const void* key, Mtx out) {
+    if (presentation_sync_active() || !s_replacementsActive || key == nullptr) {
+        return false;
+    }
+
+    auto it = g_replacements.find(reinterpret_cast<uintptr_t>(key));
+    if (it == g_replacements.end()) {
+        return false;
+    }
+
+    MTXCopy(it->second, out);
+    return true;
+}
+
+bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out) {
+    if (presentation_sync_active() || !s_replacementsActive || lhs == nullptr || rhs == nullptr) {
+        return false;
+    }
+
+    Mtx lhs_scratch;
+    Mtx rhs_scratch;
+    const Mtx* resolved_lhs = resolve_replacement(reinterpret_cast<const Mtx*>(lhs), &lhs_scratch);
+    const Mtx* resolved_rhs = resolve_replacement(reinterpret_cast<const Mtx*>(rhs), &rhs_scratch);
+    if (resolved_lhs == reinterpret_cast<const Mtx*>(lhs) &&
+        resolved_rhs == reinterpret_cast<const Mtx*>(rhs))
+    {
+        return false;
+    }
+
+    MTXConcat(*resolved_lhs, *resolved_rhs, out);
+    return true;
+}
+
+void begin_presentation(float step) {
+    begin_frame(step);
+    if (!is_enabled()) {
+        return;
+    }
+
+    interpolate_replacements();
+
+    if (s_presentationDepth > 0) {
+        s_presentationDepth++;
+        return;
+    }
+    if (!camera_apply_presentation()) {
+        return;
+    }
+
+    s_presentationDepth = 1;
+    callbacks_run();
+}
+
+void end_presentation() {
+    if (s_presentationDepth == 0) {
+        return;
+    }
+    s_presentationDepth--;
+    if (s_presentationDepth > 0) {
+        return;
+    }
+
+    camera_restore_presentation();
+}
+
+bool is_presentation_active() {
+    return s_presentationDepth > 0;
+}
+
+void add_interpolation_callback(InterpolationCallBack pCallBack, void* pUserWork) {
+    if (!is_enabled() || is_presentation_active() || !game_clock::is_sim_frame()) {
+        return;
+    }
+    if (pCallBack == nullptr) {
+        return;
+    }
+
+    s_interpolationCallBackWork.push_back({pCallBack, pUserWork});
+}
+
+}  // namespace dusk::interp
diff --git a/src/dusk/interp/frame_interpolation.h b/src/dusk/interp/frame_interpolation.h
new file mode 100644
index 0000000000..64ae2acec4
--- /dev/null
+++ b/src/dusk/interp/frame_interpolation.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <dolphin/mtx.h>
+
+#include <cstdint>
+
+#ifdef __cplusplus
+namespace dusk::interp {
+
+void begin_record();
+void end_record();
+void begin_sim_tick();
+uint64_t sim_tick_seq();
+void begin_frame(float step);
+float get_interpolation_step();
+
+void request_presentation_sync();
+bool presentation_sync_active();
+
+bool is_enabled();
+
+bool should_capture();
+
+// TODO: These should be phased out as UI is progressively updated to use game_clock
+void set_ui_tick_pending(bool value);
+bool get_ui_tick_pending();
+
+void record_final_mtx(Mtx m, const void* key);
+void record_final_mtx(Mtx m);
+
+bool lookup_replacement(const void* key, Mtx out);
+bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out);
+
+void begin_presentation(float step);
+void end_presentation();
+bool is_presentation_active();
+
+typedef void (*InterpolationCallBack)(void* pUserWork);
+void add_interpolation_callback(InterpolationCallBack pCallBack, void* pUserWork);
+
+}  // namespace dusk::interp
+#endif
diff --git a/src/dusk/interp/lerp.h b/src/dusk/interp/lerp.h
new file mode 100644
index 0000000000..1f05f070fa
--- /dev/null
+++ b/src/dusk/interp/lerp.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include "SSystem/SComponent/c_angle.h"
+#include "SSystem/SComponent/c_sxyz.h"
+#include "SSystem/SComponent/c_xyz.h"
+
+#include <cmath>
+#include <dolphin/mtx.h>
+
+#ifdef __cplusplus
+namespace dusk::interp {
+
+inline s16 lerp(s16 lhs, s16 rhs, float step) {
+    const f32 ra = S2RAD(lhs);
+    const f32 d = remainderf(S2RAD(rhs) - ra, 2.0f * M_PI);
+    return cAngle::Radian_to_SAngle(ra + d * step);
+}
+
+inline u16 lerp(u16 lhs, u16 rhs, float step) {
+    return static_cast<u16>(lerp(static_cast<s16>(lhs), static_cast<s16>(rhs), step));
+}
+
+inline f32 lerp(f32 lhs, f32 rhs, float step) {
+    return lhs + (rhs - lhs) * step;
+}
+
+inline u8 lerp(u8 lhs, u8 rhs, float step) {
+    return static_cast<u8>(std::lround(lerp(static_cast<f32>(lhs), static_cast<f32>(rhs), step)));
+}
+
+inline void lerp(cXyz& out, const cXyz& lhs, const cXyz& rhs, float step) {
+    out.x = lerp(lhs.x, rhs.x, step);
+    out.y = lerp(lhs.y, rhs.y, step);
+    out.z = lerp(lhs.z, rhs.z, step);
+}
+
+inline void lerp(csXyz& out, const csXyz& lhs, const csXyz& rhs, float step) {
+    out.x = lerp(lhs.x, rhs.x, step);
+    out.y = lerp(lhs.y, rhs.y, step);
+    out.z = lerp(lhs.z, rhs.z, step);
+}
+
+inline void lerp(Mtx& out, const Mtx& lhs, const Mtx& rhs, float step) {
+    for (size_t row = 0; row < 3; ++row) {
+        for (size_t col = 0; col < 4; ++col) {
+            const float l = lhs[row][col];
+            out[row][col] = l + (rhs[row][col] - l) * step;
+        }
+    }
+}
+
+}  // namespace dusk::interp
+#endif
diff --git a/src/dusk/interp/line.cpp b/src/dusk/interp/line.cpp
new file mode 100644
index 0000000000..3d509debea
--- /dev/null
+++ b/src/dusk/interp/line.cpp
@@ -0,0 +1,159 @@
+#include "dusk/interp/line.h"
+
+#include "dusk/interp/dual_buffer.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/interp/lerp.h"
+
+#include "m_Do/m_Do_ext.h"
+
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <new>
+
+namespace {
+
+struct Record {
+    Record()
+        : store(nullptr), previous(nullptr), current(nullptr), sample_capacity(0), tick(0),
+          strand_count(0), point_count(0), previous_valid(false), current_valid(false) {}
+
+    ~Record() { delete[] store; }
+
+    Record(const Record&) = delete;
+    Record& operator=(const Record&) = delete;
+
+    void invalidate() {
+        previous_valid = false;
+        current_valid = false;
+    }
+
+    bool ensure(size_t required) {
+        if (required <= sample_capacity) {
+            return store != nullptr;
+        }
+        if (required > std::numeric_limits<size_t>::max() / (2 * sizeof(cXyz))) {
+            return false;
+        }
+
+        cXyz* next = new (std::nothrow) cXyz[required * 2];
+        if (next == nullptr) {
+            return false;
+        }
+
+        delete[] store;
+        store = next;
+        previous = store;
+        current = store + required;
+        sample_capacity = required;
+        invalidate();
+        return true;
+    }
+
+    cXyz* store;
+    cXyz* previous;
+    cXyz* current;
+    size_t sample_capacity;
+    uint64_t tick;
+    u16 strand_count;
+    u16 point_count;
+    bool previous_valid;
+    bool current_valid;
+};
+
+bool valid(const dusk::interp::line::Points& points) {
+    if (points.strands == nullptr || points.strand_count == 0 || points.point_count == 0) {
+        return false;
+    }
+    for (u16 strand = 0; strand < points.strand_count; ++strand) {
+        if (points.strands[strand].field_0x0 == nullptr) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool same_layout(const Record& record, const dusk::interp::line::Points& points) {
+    return record.current_valid && record.strand_count == points.strand_count &&
+           record.point_count == points.point_count;
+}
+
+void copy_points(cXyz* destination, const dusk::interp::line::Points& points) {
+    const size_t points_size = static_cast<size_t>(points.point_count) * sizeof(cXyz);
+    for (u16 strand = 0; strand < points.strand_count; ++strand) {
+        std::memcpy(destination + static_cast<size_t>(strand) * points.point_count,
+            points.strands[strand].field_0x0, points_size);
+    }
+}
+
+}  // namespace
+
+namespace dusk::interp::line {
+
+void reset(const void* owner) {
+    erase_owned_buffers(owner);
+}
+
+void capture(const void* owner, Points points) {
+    if (owner == nullptr || !should_capture()) {
+        return;
+    }
+
+    Record& record = get<Record>(owner);
+    if (!valid(points)) {
+        record.invalidate();
+        return;
+    }
+
+    const size_t required = static_cast<size_t>(points.strand_count) * points.point_count;
+    if (!record.ensure(required)) {
+        record.invalidate();
+        return;
+    }
+
+    const uint64_t tick = sim_tick_seq();
+    const bool layout_matches = same_layout(record, points);
+
+    if (layout_matches && tick == record.tick) {
+        copy_points(record.current, points);
+        return;
+    }
+
+    if (layout_matches && tick == record.tick + 1) {
+        std::swap(record.previous, record.current);
+        record.previous_valid = true;
+    } else {
+        record.previous_valid = false;
+    }
+
+    copy_points(record.current, points);
+    record.tick = tick;
+    record.strand_count = points.strand_count;
+    record.point_count = points.point_count;
+    record.current_valid = true;
+}
+
+void write(const void* owner, Points points) {
+    if (owner == nullptr || !is_enabled() || !valid(points)) {
+        return;
+    }
+
+    Record& record = get<Record>(owner);
+    if (!record.previous_valid || !same_layout(record, points) ||
+        record.tick != sim_tick_seq())
+    {
+        return;
+    }
+
+    const f32 step = get_interpolation_step();
+    for (u16 strand = 0; strand < points.strand_count; ++strand) {
+        cXyz* destination = points.strands[strand].field_0x0;
+        const size_t offset = static_cast<size_t>(strand) * points.point_count;
+        for (u16 point = 0; point < points.point_count; ++point) {
+            lerp(destination[point], record.previous[offset + point],
+                record.current[offset + point], step);
+        }
+    }
+}
+
+}  // namespace dusk::interp::line
diff --git a/src/dusk/interp/line.h b/src/dusk/interp/line.h
new file mode 100644
index 0000000000..7b4f3b56bc
--- /dev/null
+++ b/src/dusk/interp/line.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "dolphin/types.h"
+
+class mDoExt_3Dline_c;
+
+namespace dusk::interp::line {
+
+struct Points {
+    mDoExt_3Dline_c* strands;
+    u16 strand_count;
+    u16 point_count;
+};
+
+void reset(const void* owner);
+void capture(const void* owner, Points points);
+void write(const void* owner, Points points);
+
+}  // namespace dusk::interp::line
diff --git a/src/dusk/io.cpp b/src/dusk/io.cpp
index 88bd04ae8f..7638194d35 100644
--- a/src/dusk/io.cpp
+++ b/src/dusk/io.cpp
@@ -5,8 +5,6 @@
 
 #include "dusk/io.hpp"
 
-using namespace dusk::io;
-
 #if _WIN32
 #define MODE_TYPE wchar_t
 #define MODE(val) L##val
@@ -23,7 +21,10 @@ using namespace dusk::io;
 #define _SH_DENYWR 0
 #endif
 
-static FILE* ThrowIfNotOpen(const FileStream& file) {
+namespace dusk::io {
+namespace {
+
+FILE* ThrowIfNotOpen(const FileStream& file) {
     if (!file.GetFileHandle()) {
         throw std::runtime_error("Invalid file handle!");
     }
@@ -31,14 +32,14 @@ static FILE* ThrowIfNotOpen(const FileStream& file) {
     return static_cast<FILE*>(file.GetFileHandle());
 }
 
-[[noreturn]] static void ThrowForError(int code) {
+[[noreturn]] void ThrowForError(int code) {
     if (code == 0) {
         throw std::system_error(std::make_error_code(std::errc::io_error));
     }
     throw std::system_error(std::make_error_code(static_cast<std::errc>(code)));
 }
 
-static FILE* OpenCore(const std::filesystem::path& path, const MODE_TYPE* mode, int shareFlag) {
+FILE* OpenCore(const std::filesystem::path& path, const MODE_TYPE* mode, int shareFlag) {
     FILE* file;
 
     int err;
@@ -59,12 +60,13 @@ static FILE* OpenCore(const std::filesystem::path& path, const MODE_TYPE* mode,
     return file;
 }
 
-static FILE* OpenCore(const char* path, const MODE_TYPE* mode, int shareFlag) {
+FILE* OpenCore(const char* path, const MODE_TYPE* mode, int shareFlag) {
     return OpenCore(reinterpret_cast<const char8_t*>(path), mode, shareFlag);
 }
 
-FileStream::FileStream() noexcept : file(nullptr) {
-}
+}  // namespace
+
+FileStream::FileStream() noexcept : file(nullptr) {}
 
 FileStream::FileStream(FILE* file) : file(file) {
     if (!file) {
@@ -184,3 +186,5 @@ FILE* FileStream::ToInner() {
     file = nullptr;
     return handle;
 }
+
+}  // namespace dusk::io
diff --git a/include/dusk/io.hpp b/src/dusk/io.hpp
similarity index 88%
rename from include/dusk/io.hpp
rename to src/dusk/io.hpp
index aba6bf8a48..5fe5535f35 100644
--- a/include/dusk/io.hpp
+++ b/src/dusk/io.hpp
@@ -1,5 +1,4 @@
-#ifndef DUSK_IO_HPP
-#define DUSK_IO_HPP
+#pragma once
 
 #include <filesystem>
 #include <vector>
@@ -97,14 +96,4 @@ public:
     FILE* ToInner();
 };
 
-/**
- * Converts a std::filesystem::path to a std::string, UTF-8, without exploding on Windows.
- */
-inline std::string fs_path_to_string(const std::filesystem::path& path) {
-    const auto u8str = path.u8string();
-    return {reinterpret_cast<const char*>(u8str.c_str())};
-}
-
 }  // namespace dusk::io
-
-#endif  // DUSK_IO_HPP
diff --git a/src/dusk/ios/FileSelectDialog.h b/src/dusk/ios/FileSelectDialog.h
deleted file mode 100644
index 0495b397b1..0000000000
--- a/src/dusk/ios/FileSelectDialog.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-
-#include <SDL3/SDL_dialog.h>
-
-struct SDL_Window;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void (*IOSFileCallback)(void* userdata, const char* path, const char* error);
-
-void Dusk_iOS_ShowFileSelect(IOSFileCallback callback, void* userdata, SDL_Window* window,
-                             const SDL_DialogFileFilter* filters, int nfilters,
-                             const char* default_location, bool allow_many);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/src/dusk/ios/FileSelectDialog.m b/src/dusk/ios/FileSelectDialog.m
deleted file mode 100644
index 8b32df3705..0000000000
--- a/src/dusk/ios/FileSelectDialog.m
+++ /dev/null
@@ -1,151 +0,0 @@
-#include "FileSelectDialog.h"
-
-#import <Foundation/Foundation.h>
-#import <UIKit/UIKit.h>
-#import <UniformTypeIdentifiers/UniformTypeIdentifiers.h>
-#import <objc/runtime.h>
-
-#include <SDL3/SDL_error.h>
-#include <SDL3/SDL_properties.h>
-#include <SDL3/SDL_stdinc.h>
-#include <SDL3/SDL_video.h>
-
-static void *g_picker_delegate_key = &g_picker_delegate_key;
-
-static void RunOnMainThread(void (^block)(void))
-{
-    if ([NSThread isMainThread]) {
-        block();
-    } else {
-        dispatch_sync(dispatch_get_main_queue(), block);
-    }
-}
-
-static NSError *MakeError(NSString *message)
-{
-    return [NSError errorWithDomain:@"dev.twilitrealm.dusk.file-select"
-                               code:1
-                           userInfo:@{NSLocalizedDescriptionKey: message}];
-}
-
-static UIViewController *FindTopViewController(UIViewController *controller)
-{
-    UIViewController *current = controller;
-    while (current.presentedViewController != nil) {
-        current = current.presentedViewController;
-    }
-    return current;
-}
-
-static UIViewController *PresenterFromWindow(SDL_Window *window)
-{
-    if (window == nil) {
-        return nil;
-    }
-
-    const SDL_PropertiesID props = SDL_GetWindowProperties(window);
-    if (props == 0) {
-        return nil;
-    }
-
-    UIWindow *uiwindow = (__bridge UIWindow *)SDL_GetPointerProperty(
-        props, SDL_PROP_WINDOW_UIKIT_WINDOW_POINTER, NULL);
-    if (uiwindow == nil || uiwindow.rootViewController == nil) {
-        return nil;
-    }
-
-    return FindTopViewController(uiwindow.rootViewController);
-}
-
-static NSURL *InitialDirectoryURL(const char *default_location)
-{
-    if (default_location == NULL || *default_location == '\0') {
-        return nil;
-    }
-
-    NSString *path = [NSString stringWithUTF8String:default_location];
-    NSURL *url = [NSURL fileURLWithPath:path];
-    if ([path hasSuffix:@"/"]) {
-        return url;
-    }
-
-    return [url URLByDeletingLastPathComponent];
-}
-
-@interface DocumentPickerDelegate : NSObject <UIDocumentPickerDelegate>
-
-@property(nonatomic, assign) IOSFileCallback callback;
-@property(nonatomic, assign) void *userdata;
-
-@end
-
-@implementation DocumentPickerDelegate
-
-- (void)finishWithPath:(const char *)path error:(const char *)error {
-    if (self.callback != NULL) {
-        self.callback(self.userdata, path, error);
-    }
-}
-
-- (void)documentPicker:(UIDocumentPickerViewController *)controller
-didPickDocumentsAtURLs:(NSArray<NSURL *> *)urls
-{
-    NSURL *url = urls.firstObject;
-    if (url == nil) {
-        [self finishWithPath:NULL error:NULL];
-        return;
-    }
-
-    [self finishWithPath:url.path.UTF8String error:NULL];
-    (void)controller;
-}
-
-- (void)documentPickerWasCancelled:(UIDocumentPickerViewController *)controller
-{
-    [self finishWithPath:NULL error:NULL];
-    (void)controller;
-}
-
-@end
-
-void Dusk_iOS_ShowFileSelect(IOSFileCallback callback, void *userdata,
-                               SDL_Window *window,
-                               const SDL_DialogFileFilter *filters, int nfilters,
-                               const char *default_location,
-                               bool allow_many)
-{
-    RunOnMainThread(^{
-        @autoreleasepool {
-            UIViewController *presenter = PresenterFromWindow(window);
-            if (presenter == nil) {
-                callback(userdata, NULL, "Failed to find an iOS view controller for the file picker.");
-                return;
-            }
-
-            NSLog(@"[ShowFileSelect] presenting picker from %@", NSStringFromClass([presenter class]));
-
-            UIDocumentPickerViewController *picker =
-                [[UIDocumentPickerViewController alloc]
-                    initForOpeningContentTypes:@[ UTTypeItem ]
-                                         asCopy:YES];
-            picker.allowsMultipleSelection = allow_many ? YES : NO;
-            picker.shouldShowFileExtensions = YES;
-
-            NSURL *directory_url = InitialDirectoryURL(default_location);
-            if (directory_url != nil) {
-                picker.directoryURL = directory_url;
-            }
-
-            DocumentPickerDelegate *delegate = [DocumentPickerDelegate new];
-            delegate.callback = callback;
-            delegate.userdata = userdata;
-            picker.delegate = delegate;
-            objc_setAssociatedObject(picker, g_picker_delegate_key, delegate,
-                                     OBJC_ASSOCIATION_RETAIN_NONATOMIC);
-
-            [presenter presentViewController:picker animated:YES completion:nil];
-            (void)filters;
-            (void)nfilters;
-        }
-    });
-}
diff --git a/src/dusk/iso_validate.cpp b/src/dusk/iso_validate.cpp
index 00cd365ca9..26fdef11e9 100644
--- a/src/dusk/iso_validate.cpp
+++ b/src/dusk/iso_validate.cpp
@@ -1,49 +1,15 @@
 #include "iso_validate.hpp"
 
-#include <SDL3/SDL_iostream.h>
-#include <nod.h>
-#include <xxhash.h>
+#include <borealis/disc.hpp>
 
 #include <array>
-#include <memory>
-#include <stdexcept>
 #include <string_view>
 
 #include "dusk/logging.h"
+#include "dusk/settings.h"
 
 namespace {
 
-constexpr uint8_t hex_nibble_to_u8(char c) {
-    if (c >= '0' && c <= '9')
-        return c - '0';
-    if (c >= 'a' && c <= 'f')
-        return c - 'a' + 10;
-    if (c >= 'A' && c <= 'F')
-        return c - 'A' + 10;
-    throw std::invalid_argument("invalid hex character");
-}
-
-constexpr uint64_t parse_u64_hex(std::string_view s) {
-    if (s.size() != 16)
-        throw std::invalid_argument("expected 16 hex chars for uint64");
-
-    uint64_t value = 0;
-    for (char c : s) {
-        value = (value << 4) | hex_nibble_to_u8(c);
-    }
-    return value;
-}
-
-constexpr XXH128_hash_t parse_xxh128(std::string_view hex) {
-    if (hex.size() != 32)
-        throw std::invalid_argument("expected 32 hex chars for XXH128");
-
-    return XXH128_hash_t{
-        .low64 = parse_u64_hex(hex.substr(16, 16)),
-        .high64 = parse_u64_hex(hex.substr(0, 16)),
-    };
-}
-
 const char* verification_state_name(dusk::DiscVerificationState state) noexcept {
     switch (state) {
     case dusk::DiscVerificationState::Success:
@@ -59,208 +25,111 @@ const char* verification_state_name(dusk::DiscVerificationState state) noexcept
 }  // namespace
 
 namespace dusk::iso {
+namespace {
 
-enum class Platform : u8 {
-    GameCube,
-    Wii,
-};
-
-enum class Region : u8 {
-    NorthAmerica,
-    Europe,
-    Japan,
-    Korea,
-};
-
-struct KnownDisc {
-    std::string_view id;
-    Platform platform;
-    Region region;
-    bool supported = false;
-    XXH128_hash_t hash{};
-
-    constexpr KnownDisc(std::string_view id, Platform platform, Region region)
-        : id(id), platform(platform), region(region) {}
-    constexpr KnownDisc(
-        std::string_view id, Platform platform, Region region, const std::string_view hash)
-        : id(id), platform(platform), region(region), supported(true), hash(parse_xxh128(hash)) {}
-};
-
-constexpr auto KNOWN_DISCS = std::to_array<KnownDisc>({
-    {"GZ2E01", Platform::GameCube, Region::NorthAmerica, "14e886f08e548a000afde98a3195e788"},
-    {"GZ2J01", Platform::GameCube, Region::Japan},
-    {"GZ2P01", Platform::GameCube, Region::Europe, "9ef597588b0035ca9e91b333fa9a8a7e"},
-    {"RZDE01", Platform::Wii, Region::NorthAmerica},
-    {"RZDJ01", Platform::Wii, Region::Japan},
-    {"RZDK01", Platform::Wii, Region::Korea},
-    {"RZDP01", Platform::Wii, Region::Europe},
+constexpr auto AcceptedDiscs = std::to_array<borealis::disc::AcceptedDisc>({
+    {
+        .gameId = "GZ2E01",
+        .expectedHash = borealis::disc::parse_xxh3_128("14e886f08e548a000afde98a3195e788"),
+    },
+    {
+        .gameId = "GZ2J01",
+        .expectedHash = borealis::disc::parse_xxh3_128("5967dc7a6a553652f4d2050aeef6f368"),
+    },
+    {
+        .gameId = "GZ2P01",
+        .expectedHash = borealis::disc::parse_xxh3_128("9ef597588b0035ca9e91b333fa9a8a7e"),
+    },
+    {
+        .gameId = "RZDE01", .revision = 0,
+        .expectedHash = borealis::disc::parse_xxh3_128("b3d91fbea59e5c66934d04c01566728e"),
+    },
+    {
+        .gameId = "RZDE01", .revision = 2,
+        .expectedHash = borealis::disc::parse_xxh3_128("c3ec420921a1b36d6ae43f576491d25c"),
+    },
+    {
+        .gameId = "RZDJ01",
+        .expectedHash = borealis::disc::parse_xxh3_128("d3866821c7fc6999e6e8bbef8b6875aa"),
+    },
+    {
+        .gameId = "RZDP01",
+        .expectedHash = borealis::disc::parse_xxh3_128("6095a924a57e5fb4294ac96fb85a09a1"),
+    },
 });
 
-constexpr const KnownDisc* find_disc(std::string_view id) {
-    for (const auto& disc : KNOWN_DISCS) {
-        if (disc.id == id)
-            return &disc;
-    }
-    return nullptr;
-}
+constexpr auto RecognizedGameIds = std::to_array<std::string_view>({"RZDK01"});
 
-struct NodHandleWrapper {
-    NodHandle* handle;
-
-    NodHandleWrapper() : handle(nullptr) {}
-    ~NodHandleWrapper() {
-        if (handle != nullptr) {
-            nod_free(handle);
-            handle = nullptr;
-        }
-    }
+constexpr borealis::disc::Catalog DiscCatalog{
+    .acceptedDiscs = AcceptedDiscs,
+    .recognizedGameIds = RecognizedGameIds,
 };
 
-static ValidationError convert_nod_error(NodResult result) {
-    switch (result) {
-    case NOD_RESULT_ERR_IO:
+ValidationError validation_error(borealis::disc::Status status) noexcept {
+    switch (status) {
+    case borealis::disc::Status::Success:
+        return ValidationError::Success;
+    case borealis::disc::Status::IOError:
         return ValidationError::IOError;
-    case NOD_RESULT_ERR_FORMAT:
+    case borealis::disc::Status::InvalidImage:
         return ValidationError::InvalidImage;
+    case borealis::disc::Status::UnknownGame:
+        return ValidationError::WrongGame;
+    case borealis::disc::Status::UnsupportedVersion:
+        return ValidationError::WrongVersion;
+    case borealis::disc::Status::Canceled:
+        return ValidationError::Canceled;
+    case borealis::disc::Status::HashMismatch:
+        return ValidationError::HashMismatch;
+    case borealis::disc::Status::Failed:
     default:
         return ValidationError::Unknown;
     }
 }
 
-s64 StreamReadAt(void* user_data, u64 offset, void* out, size_t len) {
-    if (len == 0) {
-        return 0;
-    }
-    auto* io = static_cast<SDL_IOStream*>(user_data);
-    const auto ret = SDL_SeekIO(io, static_cast<s64>(offset), SDL_IO_SEEK_SET);
-    if (ret < 0) {
-        return -1;
-    }
-    const auto read = SDL_ReadIO(io, out, len);
-    if (read == 0) {
-        if (SDL_GetIOStatus(io) == SDL_IO_STATUS_EOF) {
-            return 0;
-        }
-        return -1;
-    }
-    return static_cast<s64>(read);
-}
-
-s64 StreamLength(void* user_data) {
-    return SDL_GetIOSize(static_cast<SDL_IOStream*>(user_data));
-}
-
-void StreamClose(void* user_data) {
-    SDL_CloseIO(static_cast<SDL_IOStream*>(user_data));
-}
-
-ValidationError verify_disc(NodHandle* disc, VerificationStatus& status) {
-    std::unique_ptr<XXH3_state_t, decltype(&XXH3_freeState)> hashState(
-        XXH3_createState(), XXH3_freeState);
-    if (!hashState) {
-        return ValidationError::Unknown;
-    }
-    XXH3_128bits_reset(hashState.get());
-
-    while (true) {
-        if (status.shouldCancel.load(std::memory_order_relaxed)) {
-            return ValidationError::Canceled;
-        }
-
-        size_t bytesAvail;
-        const auto buf = nod_buf_read(disc, &bytesAvail);
-        if (!bytesAvail)
+Region region_from_game_id(std::string_view gameId) noexcept {
+    if (gameId.size() >= 4) {
+        switch (gameId[3]) {
+        case 'P':
+            return Region::Europe;
+        case 'J':
+            return Region::Japan;
+        case 'K':
+            return Region::Korea;
+        default:
             break;
-
-        XXH3_128bits_update(hashState.get(), buf, bytesAvail);
-
-        status.bytesRead.fetch_add(bytesAvail, std::memory_order_relaxed);
-        nod_buf_consume(disc, bytesAvail);
+        }
     }
-
-    const auto hash = XXH3_128bits_digest(hashState.get());
-    if (!XXH128_isEqual(hash, status.knownDisc->hash)) {
-        return ValidationError::HashMismatch;
-    }
-    return ValidationError::Success;
+    return Region::NorthAmerica;
 }
 
+void update_info(const borealis::disc::Result& result, DiscInfo& info) noexcept {
+    if (!result.metadata.gameId.empty()) {
+        info.platform = result.metadata.platform;
+        info.region = region_from_game_id(result.metadata.gameId);
+        info.revision = result.metadata.revision;
+    }
+}
+
+}  // namespace
+
 ValidationError validate(const char* path, VerificationStatus& status, DiscInfo& info) {
-    const auto sdlStream = SDL_IOFromFile(path, "rb");
-    if (sdlStream == nullptr) {
-        return ValidationError::IOError;
-    }
-
-    NodHandleWrapper disc;
-    const NodDiscStream nod_stream{
-        .user_data = sdlStream,
-        .read_at = StreamReadAt,
-        .stream_len = StreamLength,
-        .close = StreamClose,
-    };
-    auto result = nod_disc_open_stream(&nod_stream, nullptr, &disc.handle);
-    if (disc.handle == nullptr || result != NOD_RESULT_OK) {
-        return convert_nod_error(result);
-    }
-
-    status.bytesTotal.store(nod_disc_size(disc.handle), std::memory_order_relaxed);
-
-    NodDiscHeader header{};
-    result = nod_disc_header(disc.handle, &header);
-    if (result != NOD_RESULT_OK) {
-        return convert_nod_error(result);
-    }
-
-    const auto knownDisc = find_disc(std::string_view(header.game_id, 6));
-    if (!knownDisc) {
-        return ValidationError::WrongGame;
-    }
-    status.knownDisc = knownDisc;
-    info.isPal = knownDisc->region == Region::Europe;
-    if (!knownDisc->supported) {
-        return ValidationError::WrongVersion;
-    }
-    return verify_disc(disc.handle, status);
+    const auto result = borealis::disc::verify(
+        path == nullptr ? std::string_view{} : std::string_view{path}, DiscCatalog, &status);
+    update_info(result, info);
+    return validation_error(result.status);
 }
 
 ValidationError inspect(const char* path, DiscInfo& info) {
-    const auto sdlStream = SDL_IOFromFile(path, "rb");
-    if (sdlStream == nullptr) {
-        return ValidationError::IOError;
-    }
-
-    NodHandleWrapper disc;
-    const NodDiscStream nod_stream{
-        .user_data = sdlStream,
-        .read_at = StreamReadAt,
-        .stream_len = StreamLength,
-        .close = StreamClose,
-    };
-    auto result = nod_disc_open_stream(&nod_stream, nullptr, &disc.handle);
-    if (disc.handle == nullptr || result != NOD_RESULT_OK) {
-        return convert_nod_error(result);
-    }
-
-    NodDiscHeader header{};
-    result = nod_disc_header(disc.handle, &header);
-    if (result != NOD_RESULT_OK) {
-        return convert_nod_error(result);
-    }
-
-    const auto knownDisc = find_disc(std::string_view(header.game_id, 6));
-    if (!knownDisc) {
-        return ValidationError::WrongGame;
-    }
-    info.isPal = knownDisc->region == Region::Europe;
-    if (!knownDisc->supported) {
-        return ValidationError::WrongVersion;
-    }
-    return ValidationError::Success;
+    const auto result = borealis::disc::inspect(
+        path == nullptr ? std::string_view{} : std::string_view{path}, DiscCatalog);
+    update_info(result, info);
+    return validation_error(result.status);
 }
 
 bool isPal(const char* path) {
     DiscInfo info{};
-    return inspect(path, info) == ValidationError::Success && info.isPal;
+    return inspect(path, info) == ValidationError::Success && info.region == Region::Europe;
 }
 
 void log_verification_state(std::string_view path, DiscVerificationState state) {
diff --git a/src/dusk/iso_validate.hpp b/src/dusk/iso_validate.hpp
index 176284fd02..b7740b636f 100644
--- a/src/dusk/iso_validate.hpp
+++ b/src/dusk/iso_validate.hpp
@@ -1,12 +1,19 @@
 #ifndef DUSK_ISO_VALIDATE_HPP
 #define DUSK_ISO_VALIDATE_HPP
 
-#include <atomic>
+#include "dusk/settings.h"
+#include <borealis/disc.hpp>
+
+#include <cstdint>
+#include <string_view>
+
+namespace dusk {
+enum class DiscVerificationState : uint8_t;
+}
 
 namespace dusk::iso {
-struct KnownDisc;
 
-enum class ValidationError : u8 {
+enum class ValidationError : uint8_t {
     Unknown = 0,
     IOError,
     InvalidImage,
@@ -17,15 +24,21 @@ enum class ValidationError : u8 {
     Success
 };
 
-struct VerificationStatus {
-    std::atomic_size_t bytesRead = 0;
-    std::atomic_size_t bytesTotal = 0;
-    const KnownDisc* knownDisc = nullptr;
-    std::atomic_bool shouldCancel = false;
+using Platform = borealis::disc::Platform;
+
+enum class Region : uint8_t {
+    NorthAmerica,
+    Europe,
+    Japan,
+    Korea,
 };
 
+using VerificationStatus = borealis::disc::Progress;
+
 struct DiscInfo {
-    bool isPal = false;
+    Platform platform = Platform::Unknown;
+    Region region = Region::NorthAmerica;
+    uint8_t revision = 0;
 };
 
 ValidationError inspect(const char* path, DiscInfo& info);
diff --git a/src/dusk/language.cpp b/src/dusk/language.cpp
new file mode 100644
index 0000000000..62d30df816
--- /dev/null
+++ b/src/dusk/language.cpp
@@ -0,0 +1,79 @@
+#include "dusk/language.hpp"
+
+#include "dusk/version.hpp"
+
+namespace dusk::language {
+namespace {
+
+constexpr GameLanguage kEnglishOnly[] = {GameLanguage::English};
+constexpr GameLanguage kJapaneseOnly[] = {GameLanguage::Japanese};
+constexpr GameLanguage kPalLanguages[] = {
+    GameLanguage::English,
+    GameLanguage::German,
+    GameLanguage::French,
+    GameLanguage::Spanish,
+    GameLanguage::Italian,
+};
+constexpr GameLanguage kWiiUsaLanguages[] = {
+    GameLanguage::English,
+    GameLanguage::French,
+    GameLanguage::Spanish,
+};
+
+}  // namespace
+
+std::span<const GameLanguage> available_languages(const iso::DiscInfo& info) noexcept {
+    switch (info.region) {
+    case iso::Region::Japan:
+        return kJapaneseOnly;
+    case iso::Region::Europe:
+        return kPalLanguages;
+    case iso::Region::NorthAmerica:
+        if (info.platform == iso::Platform::Wii && info.revision == 2) {
+            return kWiiUsaLanguages;
+        }
+        return kEnglishOnly;
+    default:
+        return kEnglishOnly;
+    }
+}
+
+const char* language_name(GameLanguage language) noexcept {
+    switch (language) {
+    case GameLanguage::English:
+        return "English";
+    case GameLanguage::German:
+        return "German";
+    case GameLanguage::French:
+        return "French";
+    case GameLanguage::Spanish:
+        return "Spanish";
+    case GameLanguage::Italian:
+        return "Italian";
+    case GameLanguage::Japanese:
+        return "Japanese";
+    }
+    return "English";
+}
+
+const char* msg_folder() noexcept {
+    using namespace version;
+
+    switch (getSettings().game.language.getValue()) {
+    case GameLanguage::German:
+        return "Msgde";
+    case GameLanguage::French:
+        return "Msgfr";
+    case GameLanguage::Spanish:
+        return "Msgsp";
+    case GameLanguage::Italian:
+        return "Msgit";
+    case GameLanguage::Japanese:
+        return "Msgjp";
+    case GameLanguage::English:
+    default:
+        return isRegionPal() ? "Msguk" : "Msgus";
+    }
+}
+
+}  // namespace dusk::language
diff --git a/src/dusk/language.hpp b/src/dusk/language.hpp
new file mode 100644
index 0000000000..3da488b538
--- /dev/null
+++ b/src/dusk/language.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "dusk/iso_validate.hpp"
+#include "dusk/settings.h"
+
+#include <span>
+
+namespace dusk::language {
+
+std::span<const GameLanguage> available_languages(const iso::DiscInfo& info) noexcept;
+
+const char* language_name(GameLanguage language) noexcept;
+const char* msg_folder() noexcept;
+
+}  // namespace dusk::language
diff --git a/include/dusk/layout.hpp b/src/dusk/layout.hpp
similarity index 90%
rename from include/dusk/layout.hpp
rename to src/dusk/layout.hpp
index 78316d2e09..bb207c2000 100644
--- a/include/dusk/layout.hpp
+++ b/src/dusk/layout.hpp
@@ -1,5 +1,4 @@
-#ifndef DUSK_LAYOUT_H
-#define DUSK_LAYOUT_H
+#pragma once
 
 #include "dolphin/types.h"
 
@@ -33,5 +32,3 @@ struct LayoutRect {
         f32 heightInner);
 };
 }
-
-#endif  // DUSK_LAYOUT_H
diff --git a/src/dusk/livesplit.cpp b/src/dusk/livesplit.cpp
index 80c29379e5..2bf01dada1 100644
--- a/src/dusk/livesplit.cpp
+++ b/src/dusk/livesplit.cpp
@@ -1,105 +1,80 @@
-#if _WIN32
-    #include <winsock2.h>
-    #include <ws2tcpip.h>
-    using socket_t = SOCKET;
-    static void closeSocket(socket_t s) {
-        LINGER li{1, 0};
-        setsockopt(s, SOL_SOCKET, SO_LINGER, reinterpret_cast<const char*>(&li), sizeof(li));
-        closesocket(s);
-    }
-    static int socketError(socket_t s) {
-        int err = 0; int len = sizeof(err);
-        getsockopt(s, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&err), &len);
-        return err;
-    }
-    static constexpr int kSendFlags = 0;
-#else
-    #include <sys/socket.h>
-    #include <sys/select.h>
-    #include <netinet/in.h>
-    #include <arpa/inet.h>
-    #include <unistd.h>
-    #include <fcntl.h>
-    #include <errno.h>
-    using socket_t = int;
-    static void closeSocket(socket_t s) {
-        struct linger li{1, 0};
-        setsockopt(s, SOL_SOCKET, SO_LINGER, &li, sizeof(li));
-        close(s);
-    }
-    static int socketError(socket_t s) {
-        int err = 0; socklen_t len = sizeof(err);
-        getsockopt(s, SOL_SOCKET, SO_ERROR, &err, &len);
-        return err;
-    }
-    #ifndef INVALID_SOCKET
-        #define INVALID_SOCKET -1
-    #endif
-
-    #if defined(__APPLE__)
-        static constexpr int kSendFlags = 0;
-    #else
-        static constexpr int kSendFlags = MSG_NOSIGNAL;
-    #endif
-#endif
-
-#include <cstdio>
 #include "dusk/livesplit.h"
+
+#include "borealis/net.hpp"
+
 #include "f_op/f_op_overlap_mng.h"
 
+#include <cstdio>
+#include <memory>
+#include <span>
+#include <string>
+
 namespace dusk::speedrun {
+namespace {
 
-static bool     running           = false;
-static bool     startPending      = false;
-static uint64_t frameCount        = 0;
-static socket_t sock              = INVALID_SOCKET;
-static bool     wasLoading        = false;
-static bool     connected         = false;
-static bool     connectPending    = false;
-static bool     disconnectPending = false;
-static uint32_t idleProbeCounter  = 0;
-static uint32_t reconnectCounter  = 0;
-static char     storedHost[64]    = "127.0.0.1";
-static int      storedPort        = 16834;
+bool running = false;
+bool startPending = false;
+uint64_t frameCount = 0;
+bool wasLoading = false;
+bool connected = false;
+bool connectPending = false;
+bool disconnectPending = false;
+uint32_t reconnectCounter = 0;
+std::string storedEndpoint = "tcp://127.0.0.1:16834";
+std::unique_ptr<borealis::net::Context> netContext;
+borealis::net::SocketId socketId = 0;
 
-static void sendCmd(const char* cmd) {
-    if (sock == INVALID_SOCKET) {
+void send_cmd(const char* command) {
+    if (!netContext || !connected || socketId == 0) {
         return;
     }
 
-    char msg[64];
-    const int len = snprintf(msg, sizeof(msg), "%s\r\n", cmd);
-    if (len <= 0 || len >= static_cast<int>(sizeof(msg))) {
+    char message[64];
+    const int length = snprintf(message, sizeof(message), "%s\r\n", command);
+    if (length <= 0 || length >= static_cast<int>(sizeof(message))) {
         return;
     }
 
-    if (send(sock, msg, len, kSendFlags) >= 0) {
-        if (!connected) {
-            connected = connectPending = true;
-        }
-        return;
-    }
-
-#if _WIN32
-    const int err = WSAGetLastError();
-    if (err == WSAEWOULDBLOCK || err == WSAENOTCONN) {
-        return;
-    }
-#else
-    if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOTCONN) {
-        return;
-    }
-#endif
-
-    if (connected) {
-        disconnectPending = true;
-    }
-    closeSocket(sock);
-    sock = INVALID_SOCKET;
-    connected = connectPending = false;
-    reconnectCounter = 0;
+    const auto chars = std::span<const char>{message, static_cast<size_t>(length)};
+    netContext->send(socketId, std::as_bytes(chars));
 }
 
+void reconnect() {
+    netContext.reset();
+    netContext = std::make_unique<borealis::net::Context>();
+    connected = false;
+    connectPending = false;
+    socketId = netContext->connect(storedEndpoint);
+}
+
+void poll_network() {
+    if (!netContext) {
+        return;
+    }
+
+    borealis::net::Event event;
+    while (netContext->poll(event)) {
+        if (event.id != socketId) {
+            continue;
+        }
+        if (event.kind == borealis::net::Event::Kind::Connected) {
+            connected = true;
+            connectPending = true;
+            send_cmd("initgametime");
+        } else if (event.kind == borealis::net::Event::Kind::Closed) {
+            if (connected) {
+                disconnectPending = true;
+            }
+            connected = false;
+            connectPending = false;
+            socketId = 0;
+            reconnectCounter = 0;
+        }
+    }
+}
+
+}  // namespace
+
 uint64_t getFrameCount() {
     return frameCount;
 }
@@ -109,10 +84,9 @@ void onGameFrame() {
         return;
     }
 
-    bool loading = fopOvlpM_IsDoingReq() != 0;
-
+    const bool loading = fopOvlpM_IsDoingReq() != 0;
     if (loading != wasLoading) {
-        sendCmd(loading ? "pausegametime" : "unpausegametime");
+        send_cmd(loading ? "pausegametime" : "unpausegametime");
         wasLoading = loading;
     }
 
@@ -122,9 +96,11 @@ void onGameFrame() {
 }
 
 void start() {
-    if (running) {
+    if (g_speedrunInfo.m_isRunStarted || running) {
         return;
     }
+    resetForSpeedrunMode();
+    g_speedrunInfo.startRun();
 
     running = true;
     startPending = true;
@@ -137,166 +113,74 @@ void reset() {
     startPending = false;
     frameCount = 0;
     wasLoading = false;
-    sendCmd("reset");
-}
-
-static void reconnect() {
-    if (sock != INVALID_SOCKET) {
-        closeSocket(sock);
-        sock = INVALID_SOCKET;
-    }
-    connected = connectPending = false;
-
-    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    if (sock == INVALID_SOCKET) {
-        return;
-    }
-
-#if _WIN32
-    u_long nb = 1;
-    if (ioctlsocket(sock, FIONBIO, &nb) != 0) {
-        closeSocket(sock);
-        sock = INVALID_SOCKET;
-        return;
-    }
-#else
-    const int fl = fcntl(sock, F_GETFL, 0);
-    if (fl < 0 || fcntl(sock, F_SETFL, fl | O_NONBLOCK) < 0) {
-        closeSocket(sock);
-        sock = INVALID_SOCKET;
-        return;
-    }
-#endif
-
-#if defined(__APPLE__)
-    {
-        int opt = 1;
-        setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof(opt));
-    }
-#endif
-
-    sockaddr_in addr{};
-    addr.sin_family = AF_INET;
-    addr.sin_port = htons(static_cast<uint16_t>(storedPort));
-    if (inet_pton(AF_INET, storedHost, &addr.sin_addr) != 1) {
-        closeSocket(sock);
-        sock = INVALID_SOCKET;
-        return;
-    }
-
-    const int cr = connect(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
-#if _WIN32
-    const bool connectPending_ = cr < 0 && WSAGetLastError() == WSAEWOULDBLOCK;
-#else
-    const bool connectPending_ = cr < 0 && errno == EINPROGRESS;
-#endif
-    if (cr != 0 && !connectPending_) {
-        closeSocket(sock);
-        sock = INVALID_SOCKET;
-    }
+    send_cmd("reset");
 }
 
 void connectLiveSplit(const char* host, int port) {
-#if _WIN32
-    WSADATA wd{};
-    WSAStartup(MAKEWORD(2, 2), &wd);
-#endif
-    snprintf(storedHost, sizeof(storedHost), "%s", host);
-    storedPort = port;
+    std::string endpointHost = host;
+    if (endpointHost.find(':') != std::string::npos &&
+        !(endpointHost.starts_with('[') && endpointHost.ends_with(']')))
+    {
+        endpointHost = '[' + endpointHost + ']';
+    }
+    storedEndpoint = "tcp://" + endpointHost + ':' + std::to_string(port);
     reconnect();
 }
 
 void disconnectLiveSplit() {
-    if (sock != INVALID_SOCKET) {
-        closeSocket(sock);
-        sock = INVALID_SOCKET;
-    }
-    connected = connectPending = disconnectPending = false;
+    netContext.reset();
+    socketId = 0;
+    connected = false;
+    connectPending = false;
+    disconnectPending = false;
 }
 
-bool consumeConnectedEvent()    { bool v = connectPending;    connectPending    = false; return v; }
-bool consumeDisconnectedEvent() { bool v = disconnectPending; disconnectPending = false; return v; }
+bool consumeConnectedEvent() {
+    const bool value = connectPending;
+    connectPending = false;
+    return value;
+}
+
+bool consumeDisconnectedEvent() {
+    const bool value = disconnectPending;
+    disconnectPending = false;
+    return value;
+}
 
 void updateLiveSplit() {
-    if (sock == INVALID_SOCKET) {
+    poll_network();
+    if (socketId == 0) {
         if ((reconnectCounter++ % 30) == 0) {
             reconnect();
         }
         return;
     }
-
     if (!connected) {
-        fd_set writefds, errorfds;
-        FD_ZERO(&writefds);
-        FD_ZERO(&errorfds);
-        FD_SET(sock, &writefds);
-        FD_SET(sock, &errorfds);
-        timeval tv{0, 0};
-#if _WIN32
-        const int r = select(0, nullptr, &writefds, &errorfds, &tv);
-#else
-        const int r = select(sock + 1, nullptr, &writefds, &errorfds, &tv);
-#endif
-        if (r < 0 || FD_ISSET(sock, &errorfds) || socketError(sock) != 0) {
-            closeSocket(sock);
-            sock = INVALID_SOCKET;
-            reconnectCounter = 0;
-            return;
-        }
-        if (!FD_ISSET(sock, &writefds)) {
-            return;
-        }
-        sendCmd("initgametime");
         return;
     }
 
     if (startPending) {
         startPending = false;
-        sendCmd("initgametime");
-        sendCmd("reset");
-        sendCmd("starttimer");
+        send_cmd("initgametime");
+        send_cmd("reset");
+        send_cmd("starttimer");
     }
 
     if (!running) {
-        if ((idleProbeCounter++ % 60) == 0) {
-            char buf;
-            const int r = recv(sock, &buf, 1, 0);
-            if (r == 0
-#if _WIN32
-                || (r < 0 && WSAGetLastError() != WSAEWOULDBLOCK)
-#else
-                || (r < 0 && errno != EAGAIN && errno != EWOULDBLOCK)
-#endif
-            ) {
-                if (connected) {
-                    disconnectPending = true;
-                }
-                closeSocket(sock);
-                sock = INVALID_SOCKET;
-                connected = connectPending = false;
-                reconnectCounter = 0;
-            }
-        }
         return;
     }
 
-    const uint64_t totalMs  = frameCount * 1000 / 30;
+    const uint64_t totalMs = frameCount * 1000 / 30;
     const uint64_t totalSec = totalMs / 1000;
-    char cmd[32];
-    snprintf(cmd, sizeof(cmd), "setgametime %u:%02u:%02u.%03u",
-        static_cast<uint32_t>(totalSec / 3600),
-        static_cast<uint32_t>((totalSec / 60) % 60),
-        static_cast<uint32_t>(totalSec % 60),
-        static_cast<uint32_t>(totalMs % 1000)
-    );
-    sendCmd(cmd);
+    char command[32];
+    snprintf(command, sizeof(command), "setgametime %u:%02u:%02u.%03u",
+        static_cast<uint32_t>(totalSec / 3600), static_cast<uint32_t>((totalSec / 60) % 60),
+        static_cast<uint32_t>(totalSec % 60), static_cast<uint32_t>(totalMs % 1000));
+    send_cmd(command);
 }
 
 void shutdown() {
     disconnectLiveSplit();
-#if _WIN32
-    WSACleanup();
-#endif
 }
 
-}
+}  // namespace dusk::speedrun
diff --git a/include/dusk/livesplit.h b/src/dusk/livesplit.h
similarity index 85%
rename from include/dusk/livesplit.h
rename to src/dusk/livesplit.h
index b283a29af4..3196956be6 100644
--- a/include/dusk/livesplit.h
+++ b/src/dusk/livesplit.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include <cstdint>
+#include "dusk/game_mode.hpp"
+#include "dusk/speedrun.h"
 
 namespace dusk::speedrun {
 void onGameFrame();
diff --git a/src/dusk/logging.cpp b/src/dusk/logging.cpp
index 1303515e5a..b85635f1a5 100644
--- a/src/dusk/logging.cpp
+++ b/src/dusk/logging.cpp
@@ -1,390 +1,50 @@
 #include "dusk/logging.h"
-#include <algorithm>
-#include <array>
-#include <atomic>
-#include <chrono>
-#include <cctype>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <filesystem>
-#include <mutex>
-#include <string>
-#include <vector>
 
-#include "dusk/io.hpp"
-#include "tracy/Tracy.hpp"
+#include <tracy/Tracy.hpp>
 
-#if TARGET_ANDROID
-#include "android/log.h"
-#include <vector>
-#include <sstream>
-#endif
+#include <string_view>
 
 bool StubLogEnabled = true;
 
 using namespace std::literals::string_view_literals;
 
-// MSVC is broken and seemingly miscompiles std::string_view::npos without this.
-// I wish I was joking.
-constexpr size_t npos = std::string_view::npos;
-
-static constexpr std::string_view StubFragments[] = {
+namespace {
+constexpr std::string_view kStubFragments[] = {
     "is a stub"sv,
     "Unimplemented: BP register"sv,
     "Unhandled BP register"sv,
     "Unhandled XF register"sv,
+    "Unhandled XF memory write"sv,
     "but selective updates are not implemented"sv,
 };
 
-#if _WIN32
-#define DUSK_FILENO _fileno
-#else
-#define DUSK_FILENO fileno
-#endif
-
-namespace {
-// On macOS, std::mutex becomes poisoned when its dtor is run.
-// We use this to check if the LogState is destroyed before attempting to acquire it.
-std::atomic g_logStateAlive(true);
-std::atomic<int> g_logFd(-1);
-constexpr size_t MaxRetainedLogCount = 10;
-constexpr size_t MaxRetainedOldLogCount = MaxRetainedLogCount - 1;
-constexpr uintmax_t MaxRetainedOldLogBytes = 100ull * 1024ull * 1024ull;
-
-struct LogState {
-    std::mutex mutex;
-    FILE* file = nullptr;
-    std::u8string filePath;
-
-    ~LogState() {
-        CloseFile();
-        g_logStateAlive.store(false, std::memory_order_release);
-    }
-
-    void CloseFile() {
-        if (!g_logStateAlive.load(std::memory_order_acquire)) {
-            return;
-        }
-        std::lock_guard lock(mutex);
-        if (file != nullptr) {
-            g_logFd.store(-1, std::memory_order_release);
-            std::fflush(file);
-            std::fclose(file);
-            file = nullptr;
-        }
-    }
-};
-LogState g_logState;
-
-const char* LogLevelString(AuroraLogLevel level) {
-    switch (level) {
-    case LOG_DEBUG:
-        return "DEBUG";
-    case LOG_INFO:
-        return "INFO";
-    case LOG_WARNING:
-        return "WARNING";
-    case LOG_ERROR:
-        return "ERROR";
-    case LOG_FATAL:
-        return "FATAL";
-    }
-
-    return "??";
-}
-
-FILE* LogStreamForLevel(AuroraLogLevel level) {
-    return level >= LOG_ERROR ? stderr : stdout;
-}
-
-struct LogFileCandidate {
-    std::filesystem::path path;
-    std::string filename;
-    uintmax_t size;
-};
-
-void warn_log_cleanup_failure(
-    const char* action, const std::filesystem::path& path, const std::error_code& ec) {
-    std::fprintf(stderr, "[WARNING | dusk] Failed to %s '%s': %s\n", action,
-        dusk::io::fs_path_to_string(path).c_str(), ec.message().c_str());
-}
-
-bool is_digit_at(const std::string_view value, size_t index) {
-    return std::isdigit(static_cast<unsigned char>(value[index])) != 0;
-}
-
-bool is_generated_log_file_name(const std::filesystem::path& path) {
-    const std::string filename = path.filename().string();
-    constexpr std::string_view currentPrefix = "dusklight-"sv;
-    constexpr std::string_view legacyPrefix = "dusk-"sv;
-    constexpr std::string_view suffix = ".log"sv;
-    size_t timestampOffset = 0;
-
-    if (filename.starts_with(currentPrefix)) {
-        timestampOffset = currentPrefix.size();
-    } else if (filename.starts_with(legacyPrefix)) {
-        timestampOffset = legacyPrefix.size();
-    } else {
-        return false;
-    }
-
-    if (filename.size() != timestampOffset + 19 || !filename.ends_with(suffix) ||
-        filename[timestampOffset + 8] != '-') {
-        return false;
-    }
-
-    for (size_t i = timestampOffset; i < timestampOffset + 8; ++i) {
-        if (!is_digit_at(filename, i)) {
-            return false;
-        }
-    }
-    for (size_t i = timestampOffset + 9; i < timestampOffset + 15; ++i) {
-        if (!is_digit_at(filename, i)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-void delete_log_file(const std::filesystem::path& path) {
-    std::error_code ec;
-    std::filesystem::remove(path, ec);
-    if (ec) {
-        warn_log_cleanup_failure("remove old log file", path, ec);
-    }
-}
-
-void prune_old_log_files(const std::filesystem::path& logsDir) {
-    std::error_code ec;
-    std::filesystem::directory_iterator entries{logsDir, ec};
-    if (ec) {
-        warn_log_cleanup_failure("inspect log directory", logsDir, ec);
-        return;
-    }
-
-    std::vector<LogFileCandidate> candidates;
-    for (const auto& entry : entries) {
-        const std::filesystem::path path = entry.path();
-        if (!is_generated_log_file_name(path)) {
-            continue;
-        }
-
-        ec.clear();
-        const auto status = entry.symlink_status(ec);
-        if (ec) {
-            warn_log_cleanup_failure("inspect log file", path, ec);
-            continue;
-        }
-        if (!std::filesystem::is_regular_file(status)) {
-            continue;
-        }
-
-        ec.clear();
-        const uintmax_t size = entry.file_size(ec);
-        if (ec) {
-            warn_log_cleanup_failure("inspect size of log file", path, ec);
-            continue;
-        }
-
-        candidates.push_back({path, path.filename().string(), size});
-    }
-
-    std::sort(candidates.begin(), candidates.end(),
-        [](const LogFileCandidate& a, const LogFileCandidate& b) {
-            return a.filename > b.filename;
-        });
-
-    const size_t retainedCount = std::min(candidates.size(), MaxRetainedOldLogCount);
-    uintmax_t retainedBytes = 0;
-    for (size_t i = 0; i < retainedCount; ++i) {
-        retainedBytes += candidates[i].size;
-    }
-
-    size_t retainedAfterSizeLimit = retainedCount;
-    while (retainedAfterSizeLimit > 0 && retainedBytes > MaxRetainedOldLogBytes) {
-        --retainedAfterSizeLimit;
-        retainedBytes -= candidates[retainedAfterSizeLimit].size;
-    }
-
-    for (size_t i = retainedAfterSizeLimit; i < candidates.size(); ++i) {
-        delete_log_file(candidates[i].path);
-    }
-}
-
-std::string MakeTimestampedLogName() {
-    const auto now = std::chrono::system_clock::now();
-    const std::time_t nowTime = std::chrono::system_clock::to_time_t(now);
-
-    std::tm localTime{};
-#if _WIN32
-    localtime_s(&localTime, &nowTime);
-#else
-    localtime_r(&nowTime, &localTime);
-#endif
-
-    std::array<char, 32> buffer{};
-    std::strftime(buffer.data(), buffer.size(), "dusklight-%Y%m%d-%H%M%S.log", &localTime);
-    return buffer.data();
-}
-
-void WriteLogLine(FILE* out, const char* levelStr, const char* module, const char* message, unsigned int len) {
-    if (out == nullptr) {
-        return;
-    }
-
-    std::fprintf(out, "[%s | %s] ", levelStr, module);
-    std::fwrite(message, 1, len, out);
-    std::fputc('\n', out);
-    std::fflush(out);
-}
-
-void WriteLogLineToFile(
-    const char* levelStr, const char* module, const char* message, unsigned int len) {
-    if (g_logStateAlive.load(std::memory_order_acquire)) {
-        std::lock_guard lock(g_logState.mutex);
-        if (g_logState.file != nullptr) {
-            WriteLogLine(g_logState.file, levelStr, module, message, len);
-        }
-    }
-}
-}  // namespace
-
-static bool IsForStubLog(const char* message) {
-    std::string_view msg_view(message);
-
-    for (auto& fragment : StubFragments) {
-        if (msg_view.find(fragment) != ""sv.npos) {
+bool is_for_stub_log(const std::string_view message) {
+    for (const auto& fragment : kStubFragments) {
+        if (message.find(fragment) != std::string_view::npos) {
             return true;
         }
     }
-
     return false;
 }
 
-#if TARGET_ANDROID
-void aurora_log_callback(AuroraLogLevel level, const char* module, const char* message,
-                         unsigned int len) {
+bool divert_stub_messages(const borealis::log::Message& message) {
     ZoneScoped;
-    if (StubLogEnabled && level != LOG_FATAL && IsForStubLog(message)) {
-        dusk::SendToStubLog(level, module, message);
-        return;
-    }
-
-    if (module == nullptr) {
-        module = "";
-    }
-
-    const char* levelStr = LogLevelString(level);
-    int android_log_level = 0;
-    switch (level) {
-    case LOG_DEBUG:
-        android_log_level = ANDROID_LOG_DEBUG;
-        break;
-    case LOG_INFO:
-        android_log_level = ANDROID_LOG_INFO;
-        break;
-    case LOG_WARNING:
-        android_log_level = ANDROID_LOG_WARN;
-        break;
-    case LOG_ERROR:
-        android_log_level = ANDROID_LOG_ERROR;
-        break;
-    case LOG_FATAL:
-        android_log_level = ANDROID_LOG_FATAL;
-        break;
-    }
-
-    std::stringstream msgStream(std::string(message, len));
-    std::string segment;
-    while(std::getline(msgStream, segment)) {
-        __android_log_print(android_log_level, module, "%s\n", segment.c_str());
-    }
-
-    WriteLogLineToFile(levelStr, module, message, len);
-
-    if (level == LOG_FATAL) {
-        abort();
+    if (!StubLogEnabled || !is_for_stub_log(message.text)) {
+        return false;
     }
+    dusk::SendToStubLog(message.level, message.module, message.text);
+    return true;
 }
-#else
-void aurora_log_callback(AuroraLogLevel level, const char* module, const char* message,
-                         unsigned int len) {
-    ZoneScoped;
-    if (StubLogEnabled && level != LOG_FATAL && IsForStubLog(message)) {
-        dusk::SendToStubLog(level, module, message);
-        return;
-    }
+}  // namespace
 
-    if (module == nullptr) {
-        module = "";
-    }
-
-    const char* levelStr = LogLevelString(level);
-    FILE* out = LogStreamForLevel(level);
-    WriteLogLine(out, levelStr, module, message, len);
-    WriteLogLineToFile(levelStr, module, message, len);
-
-    if (level == LOG_FATAL) {
-        abort();
-    }
-}
-#endif
-
-
-aurora::Module DuskLog("dusk");
-
-void dusk::InitializeFileLogging(const std::filesystem::path& configDir, AuroraLogLevel logLevel) {
-    if (!g_logStateAlive.load(std::memory_order_acquire)) {
-        return;
-    }
-    std::lock_guard lock(g_logState.mutex);
-    if (g_logState.file != nullptr || configDir.empty()) {
-        return;
-    }
-
-    std::error_code ec;
-    const std::filesystem::path logsDir = configDir / "logs";
-    std::filesystem::create_directories(logsDir, ec);
-    if (ec) {
-        std::fprintf(stderr, "[WARNING | dusk] Failed to create log directory '%s': %s\n",
-            io::fs_path_to_string(logsDir).c_str(), ec.message().c_str());
-        return;
-    }
-    prune_old_log_files(logsDir);
-
-    const std::filesystem::path logPath = logsDir / MakeTimestampedLogName();
-    g_logState.file = io::FileStream::Create(logPath).ToInner();
-    if (g_logState.file == nullptr) {
-        std::fprintf(stderr, "[WARNING | dusk] Failed to open log file '%s'\n",
-            io::fs_path_to_string(logPath).c_str());
-        return;
-    }
-
-    g_logState.filePath = logPath.u8string();
-    g_logFd.store(DUSK_FILENO(g_logState.file), std::memory_order_release);
-    aurora::g_config.logCallback = &aurora_log_callback;
-    aurora::g_config.logLevel = logLevel;
-    WriteLogLine(g_logState.file, "INFO", "dusk", "File logging initialized", 24);
-}
-
-void dusk::ShutdownFileLogging() {
-    if (!g_logStateAlive.load(std::memory_order_acquire)) {
-        return;
-    }
-    g_logState.CloseFile();
-}
-
-const char* dusk::GetLogFilePath() {
-    if (!g_logStateAlive.load(std::memory_order_acquire)) {
-        return nullptr;
-    }
-    std::lock_guard lock(g_logState.mutex);
-    return reinterpret_cast<const char*>(
-        g_logState.filePath.empty() ? nullptr : g_logState.filePath.c_str());
-}
-
-int dusk::GetLogFileDescriptor() {
-    return g_logFd.load(std::memory_order_acquire);
+void dusk::InitializeLogging(
+    const std::filesystem::path& cacheDir, const borealis::cli::StandardOptions& standard) {
+    borealis::log::Options options{};
+    options.level = borealis::LogLevel::Debug;
+    options.fileDirectory = cacheDir.empty() ? std::filesystem::path{} : cacheDir / "logs";
+    options.filePrefix = "dusklight";
+    options.legacyFilePrefixes = {"dusk"};
+    options.divert = &divert_stub_messages;
+    standard.apply_to(options);
+    borealis::log::init(options);
 }
diff --git a/src/dusk/logging.h b/src/dusk/logging.h
new file mode 100644
index 0000000000..0f94274376
--- /dev/null
+++ b/src/dusk/logging.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <borealis/cli.hpp>
+#include <borealis/log.hpp>
+
+#include <filesystem>
+#include <string_view>
+
+namespace dusk {
+void InitializeLogging(
+    const std::filesystem::path& cacheDir, const borealis::cli::StandardOptions& standard);
+void SendToStubLog(borealis::LogLevel level, std::string_view module, std::string_view message);
+}  // namespace dusk
+
+extern bool StubLogEnabled;
+
+inline constexpr borealis::Log DuskLog{"dusk"};
+
+#ifndef NDEBUG
+#define STUB_LOG() DuskLog.debug("{} is a stub", __FUNCTION__)
+#else
+#define STUB_LOG()
+#endif
+
+#if TARGET_PC
+#define STUB_RET(...)                                                                              \
+    STUB_LOG();                                                                                    \
+    return __VA_ARGS__;
+
+#else
+#define STUB_RET() (void)0
+#endif
diff --git a/src/dusk/main.cpp b/src/dusk/main.cpp
index a35f695b50..ab3184b9bb 100644
--- a/src/dusk/main.cpp
+++ b/src/dusk/main.cpp
@@ -5,8 +5,10 @@
 #endif
 
 #include <aurora/main.h>
+#include "d/actor/d_a_movie_player.h"
 #include "dusk/main.h"
 #include "dusk/io.hpp"
+#include <borealis/io.hpp>
 
 #include <algorithm>
 #include <array>
@@ -92,7 +94,7 @@ bool RestartProcess(int argc, char* argv[]) {
 
     std::vector<std::string> args;
     args.reserve(static_cast<size_t>(std::max(argc, 1)));
-    args.push_back(dusk::io::fs_path_to_string(executablePath));
+    args.push_back(borealis::io::fs_path_to_string(executablePath));
     for (int i = 1; i < argc; ++i) {
         args.emplace_back(argv[i] != nullptr ? argv[i] : "");
     }
diff --git a/include/dusk/main.h b/src/dusk/main.h
similarity index 75%
rename from include/dusk/main.h
rename to src/dusk/main.h
index 0a2be8734d..e3db4420d1 100644
--- a/include/dusk/main.h
+++ b/src/dusk/main.h
@@ -1,8 +1,6 @@
-#ifndef DUSK_MAIN_H
-#define DUSK_MAIN_H
+#pragma once
 
 #include <filesystem>
-
 namespace dusk {
 
 extern bool IsRunning;
@@ -12,6 +10,16 @@ extern bool RestartRequested;
 extern std::filesystem::path ConfigPath;
 extern std::filesystem::path CachePath;
 
+extern uint8_t SaveRequested;
+struct StageRequest {
+    std::string stage;
+    bool set;
+    s8 room;
+    s16 point;
+    s8 layer;
+};
+extern StageRequest StageRequested;
+
 #if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) ||                           \
     (defined(TARGET_OS_TV) && TARGET_OS_TV)
 inline constexpr bool SupportsProcessRestart = false;
@@ -22,5 +30,3 @@ inline constexpr bool SupportsProcessRestart = true;
 void RequestRestart() noexcept;
 
 }  // namespace dusk
-
-#endif  // DUSK_MAIN_H
diff --git a/include/dusk/map_loader_definitions.h b/src/dusk/map_loader_definitions.h
similarity index 100%
rename from include/dusk/map_loader_definitions.h
rename to src/dusk/map_loader_definitions.h
diff --git a/include/dusk/memory.h b/src/dusk/memory.h
similarity index 68%
rename from include/dusk/memory.h
rename to src/dusk/memory.h
index dd55181170..2d24e5b957 100644
--- a/include/dusk/memory.h
+++ b/src/dusk/memory.h
@@ -1,10 +1,7 @@
-#ifndef DUSK_MEMORY_H
-#define DUSK_MEMORY_H
+#pragma once
 
 #if TARGET_PC
 #define HEAP_SIZE(original, dusk) (dusk)
 #else
 #define HEAP_SIZE(original, dusk) (original)
 #endif
-
-#endif
diff --git a/include/dusk/menu_pointer.h b/src/dusk/menu_pointer.h
similarity index 100%
rename from include/dusk/menu_pointer.h
rename to src/dusk/menu_pointer.h
diff --git a/include/dusk/mod_loader.hpp b/src/dusk/mod_loader.hpp
similarity index 54%
rename from include/dusk/mod_loader.hpp
rename to src/dusk/mod_loader.hpp
index 9d77f6984a..fc419e7367 100644
--- a/include/dusk/mod_loader.hpp
+++ b/src/dusk/mod_loader.hpp
@@ -1,15 +1,18 @@
 #pragma once
 
-#include <filesystem>
-#include <memory>
-#include <ranges>
-#include <string>
-#include <string_view>
-#include <vector>
-
 #include "dusk/config.hpp"
 #include "dusk/config_var.hpp"
 #include "mods/api.h"
+#include "mods/runtime.h"
+
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
 
 namespace dusk::mods {
 struct LoadedMod;
@@ -35,6 +38,7 @@ struct ModManifestInfo {
     struct Import {
         std::string id;
         uint16_t major = 0;
+        uint16_t minMinor = 0;
         bool required = false;
         bool operator==(const Import&) const = default;
     };
@@ -48,6 +52,19 @@ struct ModManifestInfo {
     bool operator==(const ModManifestInfo&) const = default;
 };
 
+struct DelegatedModRuntime {
+    std::string id;
+    uint16_t major = 0;
+    uint16_t minMinor = 0;
+
+    const ModRuntimeService* service = nullptr;
+    ModContext* providerContext = nullptr;
+
+    bool operator==(const DelegatedModRuntime& other) const {
+        return id == other.id && major == other.major && minMinor == other.minMinor;
+    }
+};
+
 struct ModMetadata {
     std::string id;
     std::string name;
@@ -67,9 +84,55 @@ struct ModSearchDir {
     std::filesystem::path nativeLibDir;
 };
 
+struct ModOperation {
+    enum class State : u8 {
+        Pending,
+        Succeeded,
+        Failed,
+    };
+
+    State state = State::Pending;
+    std::string message;
+};
+
+using ModOperationHandle = std::shared_ptr<const ModOperation>;
+
+struct ModMetaParsed {
+    uint32_t abiVersion = 0;
+    std::vector<ModMetaImport*> imports;
+    std::vector<ModMetaExport*> exports;
+    std::vector<ModMetaHookFn*> hookFns;
+    std::vector<ModMetaHookMem*> hookMems;
+    std::vector<ModMetaHookMemExt*> hookMemExts;
+    std::vector<ModMetaHookName*> hookNames;
+};
+
+inline const char* hook_mem_vtable_symbol(const ModMetaHookMem& rec) {
+    return reinterpret_cast<const char*>(&rec) + sizeof(ModMetaHookMem);
+}
+
+inline const char* hook_mem_display_name(const ModMetaHookMem& rec) {
+    const char* vtable = hook_mem_vtable_symbol(rec);
+    return vtable + std::char_traits<char>::length(vtable) + 1;
+}
+
+inline const char* hook_mem_vtable_symbol(const ModMetaHookMemExt& rec) {
+    return reinterpret_cast<const char*>(&rec) + sizeof(ModMetaHookMemExt);
+}
+
+inline const char* hook_mem_display_name(const ModMetaHookMemExt& rec) {
+    const char* vtable = hook_mem_vtable_symbol(rec);
+    return vtable + std::char_traits<char>::length(vtable) + 1;
+}
+
+inline const char* hook_name_symbol(const ModMetaHookName& rec) {
+    return reinterpret_cast<const char*>(&rec) + sizeof(ModMetaHookName);
+}
+
 struct NativeMod {
     std::unique_ptr<loader::NativeModule> handle;
-    const ModManifest* manifest = nullptr;
+    const ModMeta* meta = nullptr;
+    ModMetaParsed parsed;
     ModContext** contextSymbol = nullptr;
 
     ModInitializeFn fn_initialize = nullptr;
@@ -111,6 +174,16 @@ enum class NativeModStatus : u8 {
      */
     MissingExport,
 
+    /**
+     * Mod's metadata record section is malformed.
+     */
+    InvalidMetadata,
+
+    /**
+     * Mod bundle contains files in an invalid location.
+     */
+    InvalidBundle,
+
     /**
      * Unknown error loading the native mod.
      */
@@ -118,22 +191,38 @@ enum class NativeModStatus : u8 {
 };
 
 struct LoadedMod {
+    struct FileIdentity {
+        std::uintmax_t size = 0;
+        std::filesystem::file_time_type modified{};
+        bool valid = false;
+
+        bool operator==(const FileIdentity&) const = default;
+    };
+
     ModMetadata metadata;
-    std::string modPath;
-    std::string dir;
+    std::filesystem::path modPath;
+    std::filesystem::path dir;
+    // Stable UTF-8 storage for HostService::mod_dir.
+    std::string dirUtf8;
+    // Stable UTF-8 storage for HostService::data_dir.
+    std::string dataDirUtf8;
 
     uint32_t searchDirIndex = 0;
-    // Native lib is dlopen'd in place and stays resident for the session. Reload is unsupported.
-    bool inPlace = false;
+    bool fromDirectory = false;
+    // Native lib is dlopen'd in place.
+    bool nativeInPlace = false;
+    bool hasUserPackage = false;
+    bool hasBundledCopy = false;
+    FileIdentity fileIdentity;
 
-    std::unique_ptr<ConfigVar<bool> > cvarIsEnabled;
+    std::unique_ptr<ConfigVar<bool>> cvarIsEnabled;
     config::Subscription enabledSubscription = 0;
 
     bool active = false;
     bool loadFailed = false;
     std::string failureReason;
 
-    // mod_initialize succeeded; a mod_shutdown is owed on deactivation.
+    // Initialization succeeded; shutdown is owed on deactivation.
     bool initialized = false;
     // Static service exports are currently present in the registry.
     bool servicesRegistered = false;
@@ -147,10 +236,15 @@ struct LoadedMod {
     // asset-only reloads, so it doubles as a generation for anything caching per-mod content.
     uint32_t cacheGeneration = 0;
     // Currently extracted native library, empty if none.
-    std::string nativePath;
+    std::filesystem::path nativePath;
+    // Read-only directory containing the current platform's main module and runtime libraries.
+    std::filesystem::path nativeDir;
+    // Stable UTF-8 storage for HostService::native_dir.
+    std::string nativeDirUtf8;
 
     NativeModStatus nativeStatus = NativeModStatus::None;
     std::unique_ptr<NativeMod> native;
+    std::optional<DelegatedModRuntime> runtime;
     std::unique_ptr<ModContext> context;
 
     // Shared with overlay file registrations so in-flight DVD reads survive disable/reload.
@@ -161,8 +255,15 @@ struct LoadedMod {
     // Mods this mod imports services from, and mods importing services from this mod.
     std::vector<ModDependencyEdge> dependencies;
     std::vector<ModDependencyEdge> dependents;
+
+    [[nodiscard]] bool is_enabled() const {
+        return cvarIsEnabled != nullptr && cvarIsEnabled->getValue();
+    }
+    [[nodiscard]] bool activation_failed() const { return loadFailed || (is_enabled() && !active); }
 };
 
+struct PackageCandidate;
+
 class ModLoader {
 public:
     static ModLoader& instance();
@@ -175,9 +276,19 @@ public:
 
     void request_enable(std::string_view id);
     void request_disable(std::string_view id);
-    void request_reload(std::string_view id);
+    ModOperationHandle request_reload(std::string_view id);
+    ModOperationHandle request_install(std::filesystem::path path);
+    ModOperationHandle request_uninstall(std::string_view id);
+    ModOperationHandle request_reactivate(std::string_view id);
     void notify_mod_failure(LoadedMod& mod, bool firstFailure);
 
+    [[nodiscard]] std::filesystem::path user_mods_dir() const;
+    [[nodiscard]] bool can_uninstall(const LoadedMod& mod) const;
+    [[nodiscard]] bool can_update(const LoadedMod& mod) const;
+    [[nodiscard]] LoadedMod* find_mod(std::string_view id);
+    [[nodiscard]] const LoadedMod* find_mod(std::string_view id) const;
+    [[nodiscard]] uint64_t generation() const noexcept { return m_generation; }
+
     [[nodiscard]] auto mods() const {
         return m_mods | std::views::transform([](const auto& m) -> LoadedMod& { return *m; });
     }
@@ -187,30 +298,54 @@ public:
     }
 
 private:
-    enum class RequestKind : u8 { Enable, Disable, Reload };
-    struct Request {
+    enum class LifecycleAction : u8 { Enable, Disable, Reactivate };
+    struct LifecycleRequest {
         std::string modId;
-        RequestKind kind;
+        LifecycleAction action;
+        std::shared_ptr<ModOperation> operation;
+    };
+    struct InstallRequest {
+        std::filesystem::path stagedPath;
+        std::shared_ptr<ModOperation> operation;
+    };
+    struct ReloadRequest {
+        std::string modId;
+        std::shared_ptr<ModOperation> operation;
+    };
+    struct UninstallRequest {
+        std::string modId;
+        std::shared_ptr<ModOperation> operation;
+    };
+    using Request = std::variant<LifecycleRequest, InstallRequest, ReloadRequest, UninstallRequest>;
+
+    struct OperationResult {
+        bool success = true;
+        std::string message;
+        LoadedMod* mod = nullptr;
     };
     // ModLoader::tick runs inside fapGm_Execute, so code from an unloading mod can still be
     // live on the stack (its frame unwinds after the tick). dlclose is therefore deferred to
     // the next tick, by which point every per-frame entry into the mod should have returned.
     struct RetiredNative {
         std::unique_ptr<NativeMod> native;
-        std::string path;
+        std::filesystem::path directory;
     };
 
-    std::vector<std::unique_ptr<LoadedMod> > m_mods;
+    std::vector<std::unique_ptr<LoadedMod>> m_mods;
     std::vector<ModSearchDir> m_searchDirs;
     std::filesystem::path m_cacheDir;
     std::vector<Request> m_pendingRequests;
     std::vector<std::string> m_pendingFailures;
     std::vector<RetiredNative> m_retiredNatives;
+    uint64_t m_generation = 0;
     bool m_initialized = false;
     bool m_startupComplete = false;
 
-    void try_load_mod(const std::filesystem::path& modPath, bool fromDir, uint32_t searchDirIndex);
-    void load_native(LoadedMod& mod, const std::string& dllEntry);
+    LoadedMod* try_load_mod(const std::filesystem::path& modPath, bool fromDir,
+        uint32_t searchDirIndex, std::unique_ptr<ModBundle> bundle = {});
+    void load_native(LoadedMod& mod, const std::string& dllEntry,
+        const std::vector<std::string>& runtimeEntries);
+    bool load_native_if_present(LoadedMod& mod);
     // Resolved <nativeLibDir>/<mod id><ext> if it exists on disk, empty otherwise.
     [[nodiscard]] std::filesystem::path external_native_lib_path(const LoadedMod& mod) const;
     void unload_native(LoadedMod& mod);
@@ -226,20 +361,31 @@ private:
     [[nodiscard]] std::string describe_missing_import(
         const char* serviceId, uint16_t majorVersion, uint16_t minMinorVersion) const;
 
-    LoadedMod* find_mod(std::string_view id) const;
     void drain_retired_natives();
     void apply_pending_requests();
+    [[nodiscard]] OperationResult install_staged(const std::filesystem::path& path);
+    [[nodiscard]] OperationResult load_runtime_mod(const std::filesystem::path& path);
+    [[nodiscard]] OperationResult reload_runtime_mod(
+        LoadedMod& mod, const PackageCandidate* replacement = nullptr);
+    [[nodiscard]] OperationResult uninstall_runtime_mod(LoadedMod& mod);
+    [[nodiscard]] OperationResult runtime_result(LoadedMod& mod);
+    void forget_mod(LoadedMod& mod);
     void flush_toasts();
     void on_enabled_changed(LoadedMod& mod);
     // Deactivates `target` (if needed) and its transitive dependents, optionally re-reads the
     // bundle from disk, then reactivates whatever the current cvar/provider state allows.
-    void apply_lifecycle_change(LoadedMod& target, bool reload);
+    void apply_lifecycle_change(
+        LoadedMod& target, bool reload, const PackageCandidate* replacement = nullptr);
     // `target` plus transitive active/suspended dependents, in m_mods (init) order.
-    std::vector<LoadedMod*> collect_lifecycle_set(LoadedMod& target);
+    std::vector<LoadedMod*> collect_lifecycle_set(LoadedMod& target) const;
+    void resume_lifecycle_set(const std::vector<LoadedMod*>& mods);
     bool reload_bundle(LoadedMod& mod);
     bool ensure_native_loaded(LoadedMod& mod);
 };
 
+bool inspect_mod_bundle(const std::filesystem::path& path, ModMetadata& metadata,
+    std::string& error, bool* hasNative = nullptr) noexcept;
+
 using ModIndex = std::ranges::range_difference_t<decltype(std::declval<ModLoader>().mods())>;
 
 }  // namespace dusk::mods
diff --git a/src/dusk/mods/catalog.cpp b/src/dusk/mods/catalog.cpp
new file mode 100644
index 0000000000..4ba118cd5b
--- /dev/null
+++ b/src/dusk/mods/catalog.cpp
@@ -0,0 +1,458 @@
+#include "catalog.hpp"
+
+#include "dusk/app_info.hpp"
+#include "fmt/format.h"
+#include "nlohmann/json.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <iterator>
+#include <limits>
+#include <stdexcept>
+#include <string_view>
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+namespace dusk::mods::catalog {
+namespace {
+
+using json = nlohmann::json;
+using namespace std::chrono_literals;
+
+constexpr std::string_view catalogUrl =
+    "https://staging.twilitrealm.workers.dev/api/v1/games/dusklight/mods";
+
+std::string_view sort_value(Sort sort) noexcept {
+    switch (sort) {
+    case Sort::Endorsements:
+        return "endorsements";
+    case Sort::Updated:
+        return "updated";
+    case Sort::Newest:
+        return "newest";
+    case Sort::Name:
+        return "name";
+    case Sort::Downloads:
+    default:
+        return "downloads";
+    }
+}
+
+std::string_view catalog_platform() noexcept {
+#if defined(_WIN32) && defined(_M_ARM64)
+    return "windows-arm64";
+#elif defined(_WIN32) && defined(_M_X64)
+    return "windows-amd64";
+#elif defined(__ANDROID__) && defined(__aarch64__)
+    return "android-aarch64";
+#elif defined(__APPLE__) && TARGET_OS_IOS
+    return "ios-arm64";
+#elif defined(__APPLE__) && !TARGET_OS_TV && defined(__aarch64__)
+    return "macos-arm64";
+#elif defined(__APPLE__) && !TARGET_OS_TV && defined(__x86_64__)
+    return "macos-x86_64";
+#elif defined(__linux__) && defined(__aarch64__)
+    return "linux-aarch64";
+#elif defined(__linux__) && defined(__x86_64__)
+    return "linux-x86_64";
+#else
+    // The catalog rejects platforms outside its published package matrix.
+    return {};
+#endif
+}
+
+std::string url_encode(std::string_view value) {
+    constexpr char hex[] = "0123456789ABCDEF";
+    std::string encoded;
+    encoded.reserve(value.size());
+    for (const unsigned char c : value) {
+        const bool unreserved = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
+                                (c >= '0' && c <= '9') || c == '-' || c == '.' || c == '_' ||
+                                c == '~';
+        if (unreserved) {
+            encoded.push_back(static_cast<char>(c));
+        } else {
+            encoded.push_back('%');
+            encoded.push_back(hex[c >> 4]);
+            encoded.push_back(hex[c & 0x0f]);
+        }
+    }
+    return encoded;
+}
+
+void append_query(std::string& url, std::string_view name, std::string_view value) {
+    fmt::format_to(std::back_inserter(url), "{}{}={}",
+        url.find('?') == std::string::npos ? '?' : '&', name, url_encode(value));
+}
+
+std::string make_url(const Query& query) {
+    std::string url{catalogUrl};
+    if (!query.search.empty()) {
+        append_query(url, "q", query.search);
+    }
+    if (!query.category.empty()) {
+        append_query(url, "category", query.category);
+    }
+    append_query(url, "sort", sort_value(query.sort));
+    append_query(url, "page", fmt::format("{}", std::max(query.page, 1)));
+    if (query.thisDevice) {
+        const auto platform = catalog_platform();
+        if (!platform.empty()) {
+            append_query(url, "platform", platform);
+        }
+    }
+    return url;
+}
+
+std::string make_detail_url(std::string_view id) {
+    return fmt::format("{}/{}", catalogUrl, url_encode(id));
+}
+
+const json& required_field(const json& object, const char* name) {
+    if (!object.is_object()) {
+        throw std::runtime_error{"expected an object"};
+    }
+    const auto iter = object.find(name);
+    if (iter == object.end()) {
+        throw std::runtime_error{fmt::format("missing field '{}'", name)};
+    }
+    return *iter;
+}
+
+std::string required_string(const json& object, const char* name) {
+    const auto& value = required_field(object, name);
+    if (!value.is_string()) {
+        throw std::runtime_error{fmt::format("field '{}' is not a string", name)};
+    }
+    return value.get<std::string>();
+}
+
+bool required_bool(const json& object, const char* name) {
+    const auto& value = required_field(object, name);
+    if (!value.is_boolean()) {
+        throw std::runtime_error{fmt::format("field '{}' is not a boolean", name)};
+    }
+    return value.get<bool>();
+}
+
+uint64_t required_count(const json& object, const char* name) {
+    const auto& value = required_field(object, name);
+    if (value.is_number_unsigned()) {
+        return value.get<uint64_t>();
+    }
+    if (value.is_number_integer()) {
+        const auto count = value.get<int64_t>();
+        if (count >= 0) {
+            return static_cast<uint64_t>(count);
+        }
+    }
+    throw std::runtime_error{fmt::format("field '{}' is not a non-negative integer", name)};
+}
+
+int required_int(const json& object, const char* name) {
+    const uint64_t value = required_count(object, name);
+    if (value > static_cast<uint64_t>(std::numeric_limits<int>::max())) {
+        throw std::runtime_error{fmt::format("field '{}' is too large", name)};
+    }
+    return static_cast<int>(value);
+}
+
+std::optional<std::string> optional_string(const json& object, const char* name) {
+    const auto& value = required_field(object, name);
+    if (value.is_null()) {
+        return std::nullopt;
+    }
+    if (!value.is_string()) {
+        throw std::runtime_error{fmt::format("field '{}' is not a string or null", name)};
+    }
+    return value.get<std::string>();
+}
+
+uint16_t required_u16(const json& object, const char* name) {
+    const auto value = required_count(object, name);
+    if (value > std::numeric_limits<uint16_t>::max()) {
+        throw std::runtime_error{fmt::format("field '{}' is too large", name)};
+    }
+    return static_cast<uint16_t>(value);
+}
+
+Image parse_image(const json& value) {
+    const auto width = required_count(value, "width");
+    const auto height = required_count(value, "height");
+    if (width > std::numeric_limits<uint32_t>::max() ||
+        height > std::numeric_limits<uint32_t>::max())
+    {
+        throw std::runtime_error{"image dimensions are too large"};
+    }
+    Image image{
+        .width = static_cast<uint32_t>(width),
+        .height = static_cast<uint32_t>(height),
+    };
+    const auto& sources = required_field(value, "sources");
+    if (!sources.is_array()) {
+        throw std::runtime_error{"field 'sources' is not an array"};
+    }
+    image.sources.reserve(sources.size());
+    for (const auto& source : sources) {
+        const auto sourceWidth = required_count(source, "width");
+        if (sourceWidth > std::numeric_limits<uint32_t>::max()) {
+            throw std::runtime_error{"image source width is too large"};
+        }
+        image.sources.push_back({
+            .width = static_cast<uint32_t>(sourceWidth),
+            .pngUrl = required_string(source, "png_url"),
+        });
+    }
+    if (image.sources.empty()) {
+        throw std::runtime_error{"image has no sources"};
+    }
+    return image;
+}
+
+Category parse_category(const json& value) {
+    return {
+        .slug = required_string(value, "slug"),
+        .name = required_string(value, "name"),
+        .modCount = required_count(value, "mod_count"),
+    };
+}
+
+Category parse_mod_category(const json& value) {
+    return {
+        .slug = required_string(value, "slug"),
+        .name = required_string(value, "name"),
+    };
+}
+
+Tag parse_tag(const json& value) {
+    return {
+        .slug = required_string(value, "slug"),
+        .name = required_string(value, "name"),
+    };
+}
+
+Author parse_author(const json& value) {
+    return {
+        .name = required_string(value, "name"),
+        .handle = required_string(value, "handle"),
+        .official = required_bool(value, "official"),
+    };
+}
+
+Mod parse_mod(const json& value) {
+    Mod mod{
+        .id = required_string(value, "id"),
+        .name = required_string(value, "name"),
+        .version = required_string(value, "version"),
+        .author = parse_author(required_field(value, "author")),
+        .summary = required_string(value, "summary"),
+        .downloads = required_count(value, "downloads"),
+        .endorsements = required_count(value, "endorsements"),
+        .publishedAt = required_string(value, "published_at"),
+        .updatedAt = required_string(value, "updated_at"),
+        .packageSize = required_count(value, "package_size"),
+        .containsNativeCode = required_bool(value, "contains_native_code"),
+    };
+
+    const auto& category = required_field(value, "category");
+    if (!category.is_null()) {
+        mod.category = parse_mod_category(category);
+    }
+
+    const auto& tags = required_field(value, "tags");
+    if (!tags.is_array()) {
+        throw std::runtime_error{"field 'tags' is not an array"};
+    }
+    mod.tags.reserve(tags.size());
+    for (const auto& tag : tags) {
+        mod.tags.push_back(parse_tag(tag));
+    }
+
+    const auto& platforms = required_field(value, "supported_platforms");
+    if (!platforms.is_array()) {
+        throw std::runtime_error{"field 'supported_platforms' is not an array"};
+    }
+    mod.supportedPlatforms.reserve(platforms.size());
+    for (const auto& platform : platforms) {
+        if (!platform.is_string()) {
+            throw std::runtime_error{"supported platform is not a string"};
+        }
+        mod.supportedPlatforms.push_back(platform.get<std::string>());
+    }
+
+    const auto& icon = required_field(value, "icon");
+    if (!icon.is_null()) {
+        mod.icon = parse_image(icon);
+    }
+    const auto& banner = required_field(value, "banner");
+    if (!banner.is_null()) {
+        mod.banner = parse_image(banner);
+    }
+    return mod;
+}
+
+Detail parse_detail(std::string_view body) {
+    const json root = json::parse(body);
+    Detail detail{
+        .mod = parse_mod(root),
+        .siteUrl = required_string(root, "site_url"),
+        .sourceUrl = optional_string(root, "source_url"),
+        .license = optional_string(root, "license"),
+        .descriptionHtml = required_string(root, "description_html"),
+        .changelogHtml = required_string(root, "changelog_html"),
+    };
+
+    const auto& download = required_field(root, "download");
+    if (!download.is_object()) {
+        throw std::runtime_error{"field 'download' is not an object"};
+    }
+    detail.download = {
+        .url = required_string(download, "url"),
+        .sha256 = required_string(download, "sha256"),
+        .size = required_count(download, "size"),
+    };
+
+    const auto& modAbi = required_field(root, "mod_abi");
+    if (!modAbi.is_null()) {
+        const auto value = required_count(root, "mod_abi");
+        if (value > std::numeric_limits<uint32_t>::max()) {
+            throw std::runtime_error{"field 'mod_abi' is too large"};
+        }
+        detail.modAbi = static_cast<uint32_t>(value);
+    }
+
+    const auto& screenshots = required_field(root, "screenshots");
+    if (!screenshots.is_array()) {
+        throw std::runtime_error{"field 'screenshots' is not an array"};
+    }
+    detail.screenshots.reserve(screenshots.size());
+    for (const auto& screenshot : screenshots) {
+        detail.screenshots.push_back({
+            .altText = required_string(screenshot, "alt_text"),
+            .image = parse_image(required_field(screenshot, "image")),
+        });
+    }
+
+    const auto& imports = required_field(root, "service_imports");
+    if (!imports.is_array()) {
+        throw std::runtime_error{"field 'service_imports' is not an array"};
+    }
+    detail.serviceImports.reserve(imports.size());
+    for (const auto& import : imports) {
+        detail.serviceImports.push_back({
+            .id = required_string(import, "id"),
+            .major = required_u16(import, "major"),
+            .minMinor = required_u16(import, "min_minor"),
+            .optional = required_bool(import, "optional"),
+        });
+    }
+    return detail;
+}
+
+Page parse_page(std::string_view body) {
+    const json root = json::parse(body);
+    const auto& game = required_field(root, "game");
+    if (required_string(game, "id") != "dusklight") {
+        throw std::runtime_error{"catalog response is for a different game"};
+    }
+
+    Page page;
+    const auto& categories = required_field(root, "categories");
+    if (!categories.is_array()) {
+        throw std::runtime_error{"field 'categories' is not an array"};
+    }
+    page.categories.reserve(categories.size());
+    for (const auto& category : categories) {
+        page.categories.push_back(parse_category(category));
+    }
+
+    const auto& mods = required_field(root, "mods");
+    if (!mods.is_array()) {
+        throw std::runtime_error{"field 'mods' is not an array"};
+    }
+    page.mods.reserve(mods.size());
+    for (const auto& mod : mods) {
+        page.mods.push_back(parse_mod(mod));
+    }
+
+    const auto& pagination = required_field(root, "pagination");
+    page.pagination = {
+        .page = required_int(pagination, "page"),
+        .pageSize = required_int(pagination, "page_size"),
+        .pageCount = required_int(pagination, "page_count"),
+        .total = required_count(pagination, "total"),
+    };
+    return page;
+}
+
+std::string api_error(const borealis::http::Response& response) {
+    try {
+        const auto body = json::parse(response.body);
+        const auto& error = required_field(body, "error");
+        return required_string(error, "message");
+    } catch (...) {
+        return fmt::format("The catalog returned HTTP {}.", response.statusCode);
+    }
+}
+
+FetchResult finish_request(borealis::http::Result result) {
+    if (result.error != borealis::http::Error::None) {
+        return {.error = result.message.empty() ? "The catalog request failed." :
+                                                  std::move(result.message)};
+    }
+    if (result.response.statusCode != 200) {
+        return {.error = api_error(result.response)};
+    }
+    try {
+        return {.page = parse_page(result.response.body)};
+    } catch (const std::exception& exception) {
+        return {.error = fmt::format("The catalog response was invalid: {}", exception.what())};
+    } catch (...) {
+        return {.error = "The catalog response was invalid."};
+    }
+}
+
+DetailFetchResult finish_detail_request(borealis::http::Result result) {
+    if (result.error != borealis::http::Error::None) {
+        return {.error =
+                    result.message.empty() ? "The mod request failed." : std::move(result.message)};
+    }
+    if (result.response.statusCode != 200) {
+        return {.error = api_error(result.response)};
+    }
+    try {
+        return {.detail = parse_detail(result.response.body)};
+    } catch (const std::exception& exception) {
+        return {.error = fmt::format("The mod response was invalid: {}", exception.what())};
+    } catch (...) {
+        return {.error = "The mod response was invalid."};
+    }
+}
+
+borealis::http::Request make_request(std::string url) {
+    return {
+        .url = std::move(url),
+        .headers =
+            {
+                {.name = "User-Agent", .value = borealis::user_agent(dusk::AppInfo)},
+                {.name = "Accept", .value = "application/json"},
+            },
+        .connectTimeout = 10s,
+        .idleTimeout = 10s,
+        .totalTimeout = 20s,
+    };
+}
+
+}  // namespace
+
+borealis::Task<FetchResult> fetch_page(Query query) {
+    return borealis::http::start(make_request(make_url(query))).map(finish_request);
+}
+
+borealis::Task<DetailFetchResult> fetch_detail(std::string id) {
+    return borealis::http::start(make_request(make_detail_url(id))).map(finish_detail_request);
+}
+
+}  // namespace dusk::mods::catalog
diff --git a/src/dusk/mods/catalog.hpp b/src/dusk/mods/catalog.hpp
new file mode 100644
index 0000000000..5605cb6e9a
--- /dev/null
+++ b/src/dusk/mods/catalog.hpp
@@ -0,0 +1,135 @@
+#pragma once
+
+#include <borealis/http.hpp>
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace dusk::mods::catalog {
+
+enum class Sort {
+    Downloads,
+    Endorsements,
+    Updated,
+    Newest,
+    Name,
+};
+
+struct Query {
+    std::string search;
+    std::string category;
+    Sort sort = Sort::Downloads;
+    int page = 1;
+    bool thisDevice = true;
+};
+
+struct Category {
+    std::string slug;
+    std::string name;
+    uint64_t modCount = 0;
+};
+
+struct Tag {
+    std::string slug;
+    std::string name;
+};
+
+struct Author {
+    std::string name;
+    std::string handle;
+    bool official = false;
+};
+
+struct ImageSource {
+    uint32_t width = 0;
+    std::string pngUrl;
+};
+
+struct Image {
+    uint32_t width = 0;
+    uint32_t height = 0;
+    std::vector<ImageSource> sources;
+};
+
+struct Mod {
+    std::string id;
+    std::string name;
+    std::string version;
+    Author author;
+    std::string summary;
+    std::optional<Category> category;
+    std::vector<Tag> tags;
+    uint64_t downloads = 0;
+    uint64_t endorsements = 0;
+    std::string publishedAt;
+    std::string updatedAt;
+    uint64_t packageSize = 0;
+    bool containsNativeCode = false;
+    std::vector<std::string> supportedPlatforms;
+    std::optional<Image> icon;
+    std::optional<Image> banner;
+};
+
+struct Screenshot {
+    std::string altText;
+    Image image;
+};
+
+struct ServiceImport {
+    std::string id;
+    uint16_t major = 0;
+    uint16_t minMinor = 0;
+    bool optional = false;
+};
+
+struct Download {
+    std::string url;
+    std::string sha256;
+    uint64_t size = 0;
+};
+
+struct Detail {
+    Mod mod;
+    std::string siteUrl;
+    std::optional<std::string> sourceUrl;
+    std::optional<std::string> license;
+    std::string descriptionHtml;
+    std::string changelogHtml;
+    Download download;
+    std::optional<uint32_t> modAbi;
+    std::vector<Screenshot> screenshots;
+    std::vector<ServiceImport> serviceImports;
+};
+
+struct Pagination {
+    int page = 1;
+    int pageSize = 0;
+    int pageCount = 0;
+    uint64_t total = 0;
+};
+
+struct Page {
+    std::vector<Category> categories;
+    std::vector<Mod> mods;
+    Pagination pagination;
+};
+
+struct FetchResult {
+    std::optional<Page> page;
+    std::string error;
+};
+
+struct DetailFetchResult {
+    std::optional<Detail> detail;
+    std::string error;
+};
+
+/** Fetches one filtered page from the Dusklight catalog. */
+borealis::Task<FetchResult> fetch_page(Query query);
+
+/** Fetches the full catalog record for one mod. */
+borealis::Task<DetailFetchResult> fetch_detail(std::string id);
+
+}  // namespace dusk::mods::catalog
diff --git a/src/dusk/mods/item.hpp b/src/dusk/mods/item.hpp
new file mode 100644
index 0000000000..1b8897ae00
--- /dev/null
+++ b/src/dusk/mods/item.hpp
@@ -0,0 +1,117 @@
+#pragma once
+
+#include "mods/svc/item.h"
+
+#include <cstdint>
+#include <unordered_map>
+#include <utility>
+
+class fopAc_ac_c;
+
+namespace dusk::mods {
+
+enum class ItemGiveMode : uint8_t {
+    Demo,
+    Silent,
+    ForcedDemo,
+};
+
+struct ItemCheckResult {
+    uint32_t tag = 0;
+    uint8_t itemNo = 0;
+    uint8_t displayItemNo = 0;
+    bool was_resolved = false;
+};
+
+ItemCheckResolution item_check_resolve(const char* name, uint8_t itemNo, fopAc_ac_c* giver);
+ItemCheckResolution item_check_resolve(uint32_t giveTag, uint8_t itemNo, fopAc_ac_c* giver);
+uint8_t item_check(const char* name, uint8_t itemNo, fopAc_ac_c* giver);
+ItemCheckResult item_check_commit(const char* name, uint8_t itemNo, fopAc_ac_c* giver);
+ItemCheckResult item_check_commit(uint32_t giveTag, uint8_t itemNo, fopAc_ac_c* giver);
+
+uint8_t item_check_chest(uint8_t boxNo, uint8_t itemNo, fopAc_ac_c* chest);
+uint8_t item_check_boss(uint8_t itemNo, fopAc_ac_c* boss);
+uint8_t item_check_freestanding(uint8_t bitNo, uint8_t itemNo, fopAc_ac_c* item);
+uint8_t item_check_golden_wolf(uint16_t eventFlag, uint8_t itemNo, fopAc_ac_c* item);
+uint8_t item_check_shop(uint8_t itemNo, fopAc_ac_c* giver);
+
+uint32_t item_give_tag(const char* name);
+uint32_t item_give_tag_chest(uint8_t boxNo);
+uint32_t item_give_tag_boss();
+uint32_t item_give_tag_freestanding(uint8_t bitNo);
+uint32_t item_give_tag_golden_wolf(uint16_t eventFlag);
+uint32_t item_give_tag_poe(uint8_t bitNo);
+uint32_t item_give_tag_shop(uint8_t itemNo);
+uint32_t item_give_tag_bug(uint8_t insectId);
+uint32_t item_give_tag_sky_character();
+
+void item_check_enqueue_deferred(const char* name, uint8_t itemNo);
+bool item_check_enqueue(ItemCheckResult check, ItemGiveMode mode);
+
+void item_check_complete(ItemCheckResult check, fopAc_ac_c* giver);
+void item_check_cancel(uint32_t giveTag);
+void item_check_clear_committed();
+void item_granted(uint8_t itemNo, uint32_t giveTag, fopAc_ac_c* giver);
+
+uint32_t item_check_message(uint16_t group, uint32_t messageId);
+
+bool item_give_queue_dispatching();
+uint32_t item_give_queue_take_tag();
+
+struct BossItemActorSpeeds {
+    f32 f;
+    f32 y;
+};
+void set_boss_item_actor_speeds(f32 f, f32 y);
+BossItemActorSpeeds get_boss_item_actor_speeds();
+
+namespace detail {
+struct CommittedCheck {
+    uint8_t vanillaItem = 0;
+    ItemCheckResolution resolution{};
+    bool queued = false;
+};
+
+class ItemCommitStore {
+public:
+    CommittedCheck* find(uint32_t giveTag) {
+        const auto it = mChecks.find(giveTag);
+        return it != mChecks.end() ? &it->second : nullptr;
+    }
+
+    const CommittedCheck* find(uint32_t giveTag) const {
+        const auto it = mChecks.find(giveTag);
+        return it != mChecks.end() ? &it->second : nullptr;
+    }
+
+    template <typename ResolveFn>
+    CommittedCheck& commit(uint32_t giveTag, uint8_t vanillaItem, ResolveFn&& resolve) {
+        const auto existing = mChecks.find(giveTag);
+        if (existing != mChecks.end()) {
+            return existing->second;
+        }
+
+        const ItemCheckResolution resolution = std::forward<ResolveFn>(resolve)();
+        return mChecks
+            .emplace(giveTag,
+                CommittedCheck{
+                    .vanillaItem = vanillaItem,
+                    .resolution = resolution,
+                })
+            .first->second;
+    }
+
+    bool contains(uint32_t giveTag) const { return mChecks.contains(giveTag); }
+
+    void erase(uint32_t giveTag) { mChecks.erase(giveTag); }
+
+    void clear() { mChecks.clear(); }
+
+    bool empty() const { return mChecks.empty(); }
+
+private:
+    std::unordered_map<uint32_t, CommittedCheck> mChecks;
+};
+}  // namespace detail
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/item_actor.cpp b/src/dusk/mods/item_actor.cpp
new file mode 100644
index 0000000000..dc0feab472
--- /dev/null
+++ b/src/dusk/mods/item_actor.cpp
@@ -0,0 +1,15 @@
+#include "item.hpp"
+
+namespace dusk::mods {
+
+static BossItemActorSpeeds bossItemActorSpeeds{};
+void set_boss_item_actor_speeds(f32 f, f32 y) {
+    bossItemActorSpeeds.f = f;
+    bossItemActorSpeeds.y = y;
+}
+
+BossItemActorSpeeds get_boss_item_actor_speeds() {
+    return bossItemActorSpeeds;
+}
+
+}
diff --git a/src/dusk/mods/item_checks.cpp b/src/dusk/mods/item_checks.cpp
new file mode 100644
index 0000000000..221654ea07
--- /dev/null
+++ b/src/dusk/mods/item_checks.cpp
@@ -0,0 +1,450 @@
+#include "item.hpp"
+
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/loader/loader.hpp"
+#include "dusk/mods/svc/item.hpp"
+#include "mods/items.h"
+
+#include "d/d_com_inf_game.h"
+#include "d/d_item_data.h"
+
+#include <aurora/lib/logging.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <array>
+#include <exception>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace dusk::mods {
+namespace {
+
+aurora::Module Log{"dusk::mods::item_checks"};
+
+struct CheckOverride {
+    std::string name;
+    uint8_t itemNo = 0;
+};
+
+struct CheckResolver {
+    ItemCheckHandle handle = 0;
+    std::string name;
+    ItemCheckResolveFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+struct ModItemChecks {
+    std::vector<CheckOverride> overrides;
+    std::vector<CheckResolver> resolvers;
+};
+
+struct PendingResolve {
+    LoadedMod* mod = nullptr;
+    bool fixedValue = false;
+    uint8_t itemNo = 0;
+    ItemCheckResolveFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+struct MessageCheck {
+    uint16_t group = 0;
+    uint16_t messageId = 0;
+    const char* name = nullptr;
+    uint8_t vanillaItem = 0;
+    bool enqueueAtDisplay = true;
+};
+
+constexpr std::array kMessageChecks{
+    MessageCheck{
+        .group = 0,
+        .messageId = 1822,
+        .name = ITEM_CHECK_FISHING_BOTTLE,
+        .vanillaItem = dItemNo_EMPTY_BOTTLE_e,
+    },
+    MessageCheck{
+        .group = 7,
+        .messageId = 7564,
+        .name = ITEM_CHECK_FISHING_HEART_PIECE,
+        .vanillaItem = dItemNo_KAKERA_HEART_e,
+    },
+    MessageCheck{
+        .group = 7,
+        .messageId = 7578,
+        .name = ITEM_CHECK_FISHING_HEART_PIECE,
+        .vanillaItem = dItemNo_KAKERA_HEART_e,
+    },
+    MessageCheck{
+        .group = 5,
+        .messageId = 5001,
+        .name = ITEM_CHECK_DUNGEON_REWARD_FOREST,
+        .vanillaItem = dItemNo_NONE_e,
+    },
+    MessageCheck{
+        .group = 5,
+        .messageId = 6011,
+        .name = ITEM_CHECK_DUNGEON_REWARD_GORON,
+        .vanillaItem = dItemNo_NONE_e,
+    },
+    MessageCheck{
+        .group = 5,
+        .messageId = 7001,
+        .name = ITEM_CHECK_DUNGEON_REWARD_LAKEBED,
+        .vanillaItem = dItemNo_NONE_e,
+    },
+    MessageCheck{
+        .group = 5,
+        .messageId = 9301,
+        .name = ITEM_CHECK_DUNGEON_REWARD_SNOWPEAK,
+        .vanillaItem = dItemNo_NONE_e,
+    },
+    MessageCheck{
+        .group = 5,
+        .messageId = 9401,
+        .name = ITEM_CHECK_DUNGEON_REWARD_TIME,
+        .vanillaItem = dItemNo_NONE_e,
+    },
+    MessageCheck{
+        .group = 5,
+        .messageId = 11001,
+        .name = ITEM_CHECK_DUNGEON_REWARD_CITY,
+        .vanillaItem = dItemNo_NONE_e,
+    },
+    MessageCheck{
+        .group = 0,
+        .messageId = 233,
+        .name = ITEM_CHECK_ILIA_MEMORY,
+        .vanillaItem = dItemNo_HORSE_FLUTE_e,
+        .enqueueAtDisplay = false,
+    },
+    MessageCheck{
+        .group = 2,
+        .messageId = 6531,
+        .name = ITEM_CHECK_SHAD_DOMINION_ROD,
+        .vanillaItem = dItemNo_COPY_ROD_2_e,
+    }
+};
+
+std::unordered_map<LoadedMod*, ModItemChecks> s_modChecks;
+std::unordered_set<std::string> s_warnedCollisions;
+ItemCheckHandle s_nextCheckHandle = 1;
+
+const char* current_stage_name() {
+    const char* stageName = dComIfGp_getStartStageName();
+    return stageName != nullptr ? stageName : "";
+}
+
+std::string chest_check_name(uint8_t boxNo) {
+    return fmt::format("chest:{}:{}", current_stage_name(), boxNo);
+}
+
+std::string boss_check_name() {
+    return fmt::format("boss:{}", current_stage_name());
+}
+
+std::string freestanding_check_name(uint8_t bitNo) {
+    return fmt::format("freestanding:{}:{}", current_stage_name(), bitNo);
+}
+
+std::string golden_wolf_check_name(uint16_t eventFlag) {
+    return fmt::format("golden_wolf:{}", eventFlag);
+}
+
+std::string poe_check_name(uint8_t bitNo) {
+    return fmt::format("poe:{}:{}", current_stage_name(), bitNo);
+}
+
+std::string shop_check_name(uint8_t itemNo) {
+    return fmt::format("shop:{}:{}:{}", current_stage_name(), dStage_roomControl_c::getStayNo(), itemNo);
+}
+
+std::string bug_check_name(uint8_t insectId) {
+    return fmt::format("bug:{}", insectId);
+}
+
+std::string sky_character_check_name() {
+    return fmt::format("sky:{}:{}", current_stage_name(), dStage_roomControl_c::getStayNo());
+}
+
+bool ilia_memory_context() {
+    return std::strcmp(current_stage_name(), "R_SP109") == 0 &&
+           dComIfGp_roomControl_getStayNo() == 0 && dComIfG_play_c::getLayerNo(0) == 9;
+}
+
+uint16_t item_get_message(uint8_t itemNo) {
+    if (itemNo == dItemNo_KAKERA_HEART_e) {
+        constexpr std::array<uint16_t, 5> heartPieceMessages{0x86, 0x9C, 0x9D, 0x9E, 0x9F};
+        return heartPieceMessages[dComIfGs_getMaxLife() % heartPieceMessages.size()];
+    }
+    return static_cast<uint16_t>(itemNo + 0x65);
+}
+
+void invalidate_committed_check(const std::string& name) {
+    if (name.empty()) {
+        item_check_clear_committed();
+    } else {
+        item_check_cancel(item_give_tag(name.c_str()));
+    }
+}
+
+}  // namespace
+
+ItemCheckResolution item_check_resolve(const char* name, uint8_t itemNo, fopAc_ac_c* giver) {
+    if (name == nullptr || *name == '\0' || s_modChecks.empty()) {
+        return {.item = itemNo, .display_item = itemNo};
+    }
+
+    // Callbacks may change registrations, so copy the applicable chain before invoking one.
+    std::vector<PendingResolve> resolves;
+    LoadedMod* previousOverrideOwner = nullptr;
+    for (auto& mod : ModLoader::instance().mods()) {
+        if (!mod.active) {
+            continue;
+        }
+
+        const auto modIt = s_modChecks.find(&mod);
+        if (modIt == s_modChecks.end()) {
+            continue;
+        }
+
+        for (const auto& checkOverride : modIt->second.overrides) {
+            if (checkOverride.name != name) {
+                continue;
+            }
+            if (previousOverrideOwner != nullptr && s_warnedCollisions.emplace(name).second) {
+                Log.warn("check '{}' is overridden by [{}] and [{}]; [{}] wins by load order", name,
+                    previousOverrideOwner->metadata.id, mod.metadata.id, mod.metadata.id);
+            }
+            previousOverrideOwner = &mod;
+            resolves.push_back({.mod = &mod, .fixedValue = true, .itemNo = checkOverride.itemNo});
+        }
+
+        for (const auto& resolver : modIt->second.resolvers) {
+            if (resolver.name.empty() || resolver.name == name) {
+                resolves.push_back({.mod = &mod, .fn = resolver.fn, .userData = resolver.userData});
+            }
+        }
+    }
+
+    ItemCheckInfo info{
+        .name = name,
+        .giver_actor = giver,
+        .vanilla_item = itemNo,
+        .current_item = itemNo,
+        .current_display_item = itemNo,
+        .was_resolved = false,
+    };
+    for (const auto& resolve : resolves) {
+        if (!resolve.mod->active) {
+            continue;
+        }
+        if (resolve.fixedValue) {
+            info.current_item = resolve.itemNo;
+            info.current_display_item = resolve.itemNo;
+            info.was_resolved = true;
+            continue;
+        }
+
+        ItemCheckResolution resolution{
+            .item = info.current_item,
+            .display_item = dItemNo_NONE_e,
+        };
+        try {
+            if (resolve.fn(resolve.mod->context.get(), &info, &resolution, resolve.userData)) {
+                if (resolution.display_item == UINT8_MAX) {
+                    resolution.display_item = resolution.item;
+                }
+                info.current_item = resolution.item;
+                info.current_display_item = resolution.display_item;
+                info.was_resolved = true;
+            }
+        } catch (const std::exception& e) {
+            fail_mod(*resolve.mod, MOD_ERROR,
+                fmt::format("Exception in item check resolver for '{}': {}", name, e.what()));
+        } catch (...) {
+            fail_mod(*resolve.mod, MOD_ERROR,
+                fmt::format("Unknown exception in item check resolver for '{}'", name));
+        }
+    }
+    return {
+        .item = info.current_item,
+        .display_item = info.current_display_item,
+        .was_resolved = info.was_resolved,
+    };
+}
+
+uint8_t item_check(const char* name, uint8_t itemNo, fopAc_ac_c* giver) {
+    return item_check_resolve(name, itemNo, giver).item;
+}
+
+uint8_t item_check_chest(uint8_t boxNo, uint8_t itemNo, fopAc_ac_c* chest) {
+    if (s_modChecks.empty()) {
+        return itemNo;
+    }
+    const auto name = chest_check_name(boxNo);
+    return item_check(name.c_str(), itemNo, chest);
+}
+
+uint8_t item_check_boss(uint8_t itemNo, fopAc_ac_c* boss) {
+    if (s_modChecks.empty()) {
+        return itemNo;
+    }
+    const auto name = boss_check_name();
+    return item_check(name.c_str(), itemNo, boss);
+}
+
+uint8_t item_check_freestanding(uint8_t bitNo, uint8_t itemNo, fopAc_ac_c* item) {
+    if (s_modChecks.empty()) {
+        return itemNo;
+    }
+    const auto name = freestanding_check_name(bitNo);
+    return item_check(name.c_str(), itemNo, item);
+}
+
+uint8_t item_check_golden_wolf(uint16_t eventFlag, uint8_t itemNo, fopAc_ac_c* item) {
+    if (s_modChecks.empty()) {
+        return itemNo;
+    }
+    const auto name = golden_wolf_check_name(eventFlag);
+    return item_check(name.c_str(), itemNo, item);
+}
+
+uint8_t item_check_shop(uint8_t itemNo, fopAc_ac_c* giver) {
+    if (s_modChecks.empty()) {
+        return itemNo;
+    }
+    const auto name = shop_check_name(itemNo);
+    return item_check(name.c_str(), itemNo, giver);
+}
+
+uint32_t item_check_message(uint16_t group, uint32_t messageId) {
+    for (const auto& check : kMessageChecks) {
+        if (check.group != group || check.messageId != messageId ||
+            (check.group == 0 && check.messageId == 233 && !ilia_memory_context()))
+        {
+            continue;
+        }
+
+        const ItemCheckResult result = item_check_commit(check.name, check.vanillaItem, nullptr);
+        if (result.itemNo == check.vanillaItem || result.itemNo == dItemNo_NONE_e) {
+            return messageId;
+        }
+        if (check.enqueueAtDisplay) {
+            item_check_enqueue(result, ItemGiveMode::Silent);
+        }
+        return item_get_message(result.itemNo);
+    }
+    return messageId;
+}
+
+uint32_t item_give_tag_chest(uint8_t boxNo) {
+    return item_give_tag(chest_check_name(boxNo).c_str());
+}
+
+uint32_t item_give_tag_boss() {
+    return item_give_tag(boss_check_name().c_str());
+}
+
+uint32_t item_give_tag_freestanding(uint8_t bitNo) {
+    return item_give_tag(freestanding_check_name(bitNo).c_str());
+}
+
+uint32_t item_give_tag_golden_wolf(uint16_t eventFlag) {
+    return item_give_tag(golden_wolf_check_name(eventFlag).c_str());
+}
+
+uint32_t item_give_tag_poe(uint8_t bitNo) {
+    return item_give_tag(poe_check_name(bitNo).c_str());
+}
+
+uint32_t item_give_tag_shop(uint8_t itemNo) {
+    return item_give_tag(shop_check_name(itemNo).c_str());
+}
+
+uint32_t item_give_tag_bug(uint8_t insectId) {
+    return item_give_tag(bug_check_name(insectId).c_str());
+}
+
+uint32_t item_give_tag_sky_character() {
+    return item_give_tag(sky_character_check_name().c_str());
+}
+
+namespace svc {
+
+ModResult item_check_set_override(LoadedMod& mod, const char* name, uint8_t itemNo) {
+    auto& checks = s_modChecks[&mod];
+    for (auto& checkOverride : checks.overrides) {
+        if (checkOverride.name == name) {
+            checkOverride.itemNo = itemNo;
+            invalidate_committed_check(checkOverride.name);
+            return MOD_OK;
+        }
+    }
+    checks.overrides.push_back({.name = name, .itemNo = itemNo});
+    invalidate_committed_check(checks.overrides.back().name);
+    return MOD_OK;
+}
+
+ModResult item_check_clear_override(LoadedMod& mod, const char* name) {
+    const auto modIt = s_modChecks.find(&mod);
+    if (modIt == s_modChecks.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const auto removed = std::erase_if(modIt->second.overrides,
+        [&](const auto& checkOverride) { return checkOverride.name == name; });
+    if (removed != 0) {
+        invalidate_committed_check(name);
+    }
+    return removed != 0 ? MOD_OK : MOD_INVALID_ARGUMENT;
+}
+
+ModResult item_check_add_resolver(LoadedMod& mod, const char* name, ItemCheckResolveFn fn,
+    void* userData, ItemCheckHandle& outHandle) {
+    auto& resolver = s_modChecks[&mod].resolvers.emplace_back();
+    resolver.handle = s_nextCheckHandle++;
+    resolver.name = name != nullptr ? name : "";
+    resolver.fn = fn;
+    resolver.userData = userData;
+    outHandle = resolver.handle;
+    invalidate_committed_check(resolver.name);
+    return MOD_OK;
+}
+
+ModResult item_check_remove_resolver(LoadedMod& mod, ItemCheckHandle handle) {
+    const auto modIt = s_modChecks.find(&mod);
+    if (modIt == s_modChecks.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const auto resolverIt =
+        std::find_if(modIt->second.resolvers.begin(), modIt->second.resolvers.end(),
+            [&](const auto& resolver) { return resolver.handle == handle; });
+    if (resolverIt == modIt->second.resolvers.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const std::string name = resolverIt->name;
+    modIt->second.resolvers.erase(resolverIt);
+    invalidate_committed_check(name);
+    return MOD_OK;
+}
+
+void item_checks_remove_mod(LoadedMod& mod) {
+    if (const auto modIt = s_modChecks.find(&mod); modIt != s_modChecks.end()) {
+        for (const auto& resolver : modIt->second.resolvers) {
+            if (resolver.name.empty()) {
+                item_check_clear_committed();
+                break;
+            }
+            invalidate_committed_check(resolver.name);
+        }
+        for (const auto& checkOverride : modIt->second.overrides) {
+            invalidate_committed_check(checkOverride.name);
+        }
+    }
+    s_modChecks.erase(&mod);
+    s_warnedCollisions.clear();
+}
+
+}  // namespace svc
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/item_gives.cpp b/src/dusk/mods/item_gives.cpp
new file mode 100644
index 0000000000..7a0ed3f6b1
--- /dev/null
+++ b/src/dusk/mods/item_gives.cpp
@@ -0,0 +1,455 @@
+#include "item.hpp"
+
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/loader/loader.hpp"
+#include "dusk/mods/svc/item.hpp"
+
+#include "d/actor/d_a_alink.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_item.h"
+#include "d/d_item_data.h"
+#include "f_op/f_op_actor_mng.h"
+
+#include <aurora/lib/logging.hpp>
+#include <fmt/format.h>
+
+#include <deque>
+#include <exception>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace dusk::mods {
+namespace {
+
+aurora::Module Log{"dusk::mods::item_gives"};
+
+// deque keeps previously returned c_str pointers valid if a callback interns another name.
+std::deque<std::string> s_giveNames;
+std::unordered_map<std::string, uint32_t> s_giveNameIds;
+
+detail::ItemCommitStore s_committedChecks;
+
+const char* item_give_name(uint32_t tag) {
+    if (tag == 0 || tag > s_giveNames.size()) {
+        return nullptr;
+    }
+    return s_giveNames[tag - 1].c_str();
+}
+
+struct GiveObserver {
+    ItemGiveHandle handle = 0;
+    ItemGiveObserveFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+struct PendingObserver {
+    LoadedMod* mod = nullptr;
+    ItemGiveObserveFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+std::unordered_map<LoadedMod*, std::vector<GiveObserver>> s_modObservers;
+ItemGiveHandle s_nextGiveHandle = 1;
+size_t s_observerCount = 0;
+
+void notify_gives(const char* checkName, uint8_t itemNo, fopAc_ac_c* giver, ItemGiveOrigin origin) {
+    if (s_observerCount == 0) {
+        return;
+    }
+
+    // Callbacks may change registrations, so copy them before invoking one.
+    std::vector<PendingObserver> observers;
+    for (auto& mod : ModLoader::instance().mods()) {
+        if (!mod.active) {
+            continue;
+        }
+        const auto modIt = s_modObservers.find(&mod);
+        if (modIt == s_modObservers.end()) {
+            continue;
+        }
+        for (const auto& observer : modIt->second) {
+            observers.push_back({.mod = &mod, .fn = observer.fn, .userData = observer.userData});
+        }
+    }
+
+    const ItemGiveInfo info{
+        .check_name = checkName,
+        .giver_actor = giver,
+        .item = itemNo,
+        .origin = static_cast<uint8_t>(origin),
+    };
+    for (const auto& observer : observers) {
+        if (!observer.mod->active) {
+            continue;
+        }
+        try {
+            observer.fn(observer.mod->context.get(), &info, observer.userData);
+        } catch (const std::exception& e) {
+            fail_mod(*observer.mod, MOD_ERROR,
+                fmt::format("Exception in item give observer: {}", e.what()));
+        } catch (...) {
+            fail_mod(*observer.mod, MOD_ERROR, "Unknown exception in item give observer");
+        }
+    }
+}
+
+void complete_check(uint8_t itemNo, uint32_t giveTag, fopAc_ac_c* giver, ItemGiveOrigin origin) {
+    if (const auto* committed = s_committedChecks.find(giveTag);
+        committed != nullptr && committed->resolution.item != itemNo)
+    {
+        Log.error("committed check '{}' completed with item {:#x} instead of {:#x}",
+            item_give_name(giveTag) != nullptr ? item_give_name(giveTag) : "", itemNo,
+            committed->resolution.item);
+    }
+    s_committedChecks.erase(giveTag);
+    notify_gives(item_give_name(giveTag), itemNo, giver, origin);
+}
+
+constexpr int kGiveMaxRetries = 5;
+
+struct QueuedGive {
+    LoadedMod* owner = nullptr;
+    uint32_t tag = 0;
+    uint8_t itemNo = 0;
+    bool silent = false;
+    bool resolveAtDispatch = false;
+    bool forced = false;
+};
+
+std::deque<QueuedGive> s_giveQueue;
+QueuedGive s_inFlightGive{};
+uint8_t s_inFlightItem = 0;
+int s_inFlightRetries = 0;
+bool s_inFlight = false;
+bool s_inFlightSpawned = false;
+bool s_dispatchingSilent = false;
+
+bool has_forced_give() {
+    return std::any_of(
+        s_giveQueue.begin(), s_giveQueue.end(), [](const QueuedGive& give) { return give.forced; });
+}
+
+bool safe_to_dispatch() {
+    daAlink_c* link = daAlink_getAlinkActorClass();
+    if (link == nullptr) {
+        return false;
+    }
+
+    // make sure player is in a safe action and not already in an event before dispatching
+    switch (link->mProcID) {
+    case daAlink_c::PROC_WAIT:
+    case daAlink_c::PROC_TIRED_WAIT:
+    case daAlink_c::PROC_MOVE:
+    case daAlink_c::PROC_WOLF_WAIT:
+    case daAlink_c::PROC_WOLF_TIRED_WAIT:
+    case daAlink_c::PROC_WOLF_MOVE:
+    case daAlink_c::PROC_ATN_MOVE:
+    case daAlink_c::PROC_WOLF_ATN_AC_MOVE:
+        break;
+    default:
+        return false;
+    }
+    if (link->checkEventRun()) {
+        return false;
+    }
+
+    int itemId = 0;
+    return link->mMsgFlow.getEventId(&itemId) == 0;
+}
+
+bool resolve_queued_give(const QueuedGive& give, ItemGiveOrigin origin, uint8_t& outItem) {
+    outItem = give.itemNo;
+    if (give.resolveAtDispatch) {
+        outItem = item_check_commit(give.tag, give.itemNo, nullptr).itemNo;
+    }
+    if (outItem != dItemNo_NONE_e) {
+        return true;
+    }
+
+    complete_check(dItemNo_NONE_e, give.tag, nullptr, origin);
+    return false;
+}
+
+void dispatch_silent_give(const QueuedGive& give) {
+    uint8_t itemNo = 0;
+    if (!resolve_queued_give(give, ITEM_GIVE_ORIGIN_QUEUE_SILENT, itemNo)) {
+        return;
+    }
+
+    Log.debug("dispatching silent item {:#x} for '{}'", itemNo,
+        item_give_name(give.tag) != nullptr ? item_give_name(give.tag) : "");
+    s_dispatchingSilent = true;
+    execItemGet(itemNo, give.tag, nullptr);
+    s_dispatchingSilent = false;
+}
+
+void dispatch_demo_give() {
+    Log.debug("dispatching item {:#x} for '{}'", s_inFlightItem,
+        item_give_name(s_inFlightGive.tag) != nullptr ? item_give_name(s_inFlightGive.tag) : "");
+
+    daAlink_c* link = daAlink_getAlinkActorClass();
+    dComIfGp_getEvent()->setGtItm(s_inFlightItem);
+    link->mProcID = daAlink_c::PROC_GET_ITEM;
+    const s16 eventIndex = dComIfGp_getEventManager().getEventIdx(link, "DEFAULT_GETITEM", 0xFF);
+    fopAcM_orderChangeEventId(link, eventIndex, 1, 0xFFFF);
+}
+
+void dispatch_next_give() {
+    while (!s_giveQueue.empty()) {
+        while (!s_giveQueue.empty() && s_giveQueue.front().silent) {
+            const QueuedGive give = s_giveQueue.front();
+            s_giveQueue.pop_front();
+            dispatch_silent_give(give);
+        }
+        if (s_giveQueue.empty()) {
+            return;
+        }
+
+        const QueuedGive give = s_giveQueue.front();
+        s_giveQueue.pop_front();
+
+        uint8_t itemNo = 0;
+        if (!resolve_queued_give(give, ITEM_GIVE_ORIGIN_QUEUE, itemNo)) {
+            continue;
+        }
+
+        s_inFlightGive = give;
+        s_inFlightItem = itemNo;
+        s_inFlightRetries = 0;
+        s_inFlight = true;
+        s_inFlightSpawned = false;
+        dispatch_demo_give();
+        return;
+    }
+}
+
+}  // namespace
+
+uint32_t item_give_tag(const char* name) {
+    if (name == nullptr || *name == '\0') {
+        return 0;
+    }
+    if (const auto it = s_giveNameIds.find(name); it != s_giveNameIds.end()) {
+        return it->second;
+    }
+
+    s_giveNames.emplace_back(name);
+    const auto tag = static_cast<uint32_t>(s_giveNames.size());
+    s_giveNameIds.emplace(s_giveNames.back(), tag);
+    return tag;
+}
+
+ItemCheckResolution item_check_resolve(uint32_t giveTag, uint8_t itemNo, fopAc_ac_c* giver) {
+    if (const auto* committed = s_committedChecks.find(giveTag); committed != nullptr) {
+        return committed->resolution;
+    }
+    const char* name = item_give_name(giveTag);
+    return name != nullptr ? item_check_resolve(name, itemNo, giver) :
+                             ItemCheckResolution{.item = itemNo, .display_item = itemNo};
+}
+
+ItemCheckResult item_check_commit(uint32_t giveTag, uint8_t itemNo, fopAc_ac_c* giver) {
+    const char* name = item_give_name(giveTag);
+    if (name == nullptr) {
+        return {.tag = giveTag, .itemNo = itemNo, .displayItemNo = itemNo};
+    }
+
+    if (const auto* committed = s_committedChecks.find(giveTag); committed != nullptr) {
+        if (committed->vanillaItem != itemNo) {
+            Log.error("committed check '{}' changed vanilla item from {:#x} to {:#x}", name,
+                committed->vanillaItem, itemNo);
+        }
+        return {
+            .tag = giveTag,
+            .itemNo = committed->resolution.item,
+            .displayItemNo = committed->resolution.display_item,
+            .was_resolved = committed->resolution.was_resolved,
+        };
+    }
+
+    const auto& committed = s_committedChecks.commit(
+        giveTag, itemNo, [&] { return item_check_resolve(name, itemNo, giver); });
+    return {
+        .tag = giveTag,
+        .itemNo = committed.resolution.item,
+        .displayItemNo = committed.resolution.display_item,
+        .was_resolved = committed.resolution.was_resolved,
+    };
+}
+
+ItemCheckResult item_check_commit(const char* name, uint8_t itemNo, fopAc_ac_c* giver) {
+    return item_check_commit(item_give_tag(name), itemNo, giver);
+}
+
+void item_check_enqueue_deferred(const char* name, uint8_t itemNo) {
+    s_giveQueue.push_back({
+        .tag = item_give_tag(name),
+        .itemNo = itemNo,
+        .resolveAtDispatch = true,
+    });
+}
+
+bool item_check_enqueue(ItemCheckResult check, ItemGiveMode mode) {
+    auto* committed = s_committedChecks.find(check.tag);
+    if (committed == nullptr) {
+        Log.error("cannot enqueue uncommitted check '{}'",
+            item_give_name(check.tag) != nullptr ? item_give_name(check.tag) : "");
+        return false;
+    }
+    if (committed->resolution.item != check.itemNo) {
+        Log.error("committed check '{}' changed item from {:#x} to {:#x}",
+            item_give_name(check.tag) != nullptr ? item_give_name(check.tag) : "", check.itemNo,
+            committed->resolution.item);
+        return false;
+    }
+    if (committed->queued) {
+        return false;
+    }
+
+    committed->queued = true;
+    s_giveQueue.push_back({
+        .tag = check.tag,
+        .itemNo = committed->resolution.item,
+        .silent = mode == ItemGiveMode::Silent,
+        .forced = mode == ItemGiveMode::ForcedDemo,
+    });
+    if (mode == ItemGiveMode::ForcedDemo && !s_inFlight) {
+        dispatch_next_give();
+    }
+    return true;
+}
+
+void item_check_complete(ItemCheckResult check, fopAc_ac_c* giver) {
+    complete_check(check.itemNo, check.tag, giver, ITEM_GIVE_ORIGIN_GAME);
+}
+
+void item_check_cancel(uint32_t giveTag) {
+    s_committedChecks.erase(giveTag);
+    std::erase_if(s_giveQueue,
+        [&](const QueuedGive& give) { return give.owner == nullptr && give.tag == giveTag; });
+}
+
+void item_check_clear_committed() {
+    std::erase_if(s_giveQueue, [&](const QueuedGive& give) {
+        return give.owner == nullptr && s_committedChecks.contains(give.tag);
+    });
+    s_committedChecks.clear();
+}
+
+void item_granted(uint8_t itemNo, uint32_t giveTag, fopAc_ac_c* giver) {
+    ItemGiveOrigin origin = ITEM_GIVE_ORIGIN_GAME;
+    if (s_dispatchingSilent) {
+        origin = ITEM_GIVE_ORIGIN_QUEUE_SILENT;
+    } else if (s_inFlight && itemNo == s_inFlightItem && giveTag == s_inFlightGive.tag) {
+        origin = ITEM_GIVE_ORIGIN_QUEUE;
+        s_inFlight = false;
+        s_inFlightSpawned = false;
+    }
+    complete_check(itemNo, giveTag, giver, origin);
+}
+
+bool item_give_queue_dispatching() {
+    return s_inFlight && !s_inFlightSpawned;
+}
+
+uint32_t item_give_queue_take_tag() {
+    if (!item_give_queue_dispatching()) {
+        return 0;
+    }
+    s_inFlightSpawned = true;
+    return s_inFlightGive.tag;
+}
+
+namespace svc {
+
+void item_gives_tick() {
+    if (!s_inFlight && s_giveQueue.empty()) {
+        return;
+    }
+
+    if (s_inFlight) {
+        if (!safe_to_dispatch()) {
+            return;
+        }
+        if (++s_inFlightRetries > kGiveMaxRetries) {
+            Log.error("item {:#x} for '{}' did not complete after {} attempts; dropping it",
+                s_inFlightItem,
+                item_give_name(s_inFlightGive.tag) != nullptr ? item_give_name(s_inFlightGive.tag) :
+                                                                "",
+                kGiveMaxRetries);
+            item_check_cancel(s_inFlightGive.tag);
+            s_inFlight = false;
+            s_inFlightSpawned = false;
+            return;
+        }
+        s_inFlightSpawned = false;
+        dispatch_demo_give();
+        return;
+    }
+
+    if (!has_forced_give() && !safe_to_dispatch()) {
+        return;
+    }
+    dispatch_next_give();
+}
+
+void item_gives_clear() {
+    if (!s_giveQueue.empty() || s_inFlight) {
+        Log.info("dropping {} pending item give(s)",
+            s_giveQueue.size() + static_cast<size_t>(s_inFlight));
+    }
+    s_giveQueue.clear();
+    s_inFlight = false;
+    s_inFlightSpawned = false;
+    s_committedChecks.clear();
+}
+
+ModResult item_give_enqueue(LoadedMod& mod, const char* checkName, uint8_t itemNo, uint32_t flags) {
+    s_giveQueue.push_back({
+        .owner = &mod,
+        .tag = item_give_tag(checkName),
+        .itemNo = itemNo,
+        .silent = (flags & ITEM_GIVE_SILENT) != 0,
+        .resolveAtDispatch = (flags & ITEM_GIVE_RESOLVE) != 0,
+    });
+    return MOD_OK;
+}
+
+ModResult item_give_add_observer(
+    LoadedMod& mod, ItemGiveObserveFn fn, void* userData, ItemGiveHandle& outHandle) {
+    auto& observer = s_modObservers[&mod].emplace_back();
+    observer.handle = s_nextGiveHandle++;
+    observer.fn = fn;
+    observer.userData = userData;
+    outHandle = observer.handle;
+    ++s_observerCount;
+    return MOD_OK;
+}
+
+ModResult item_give_remove_observer(LoadedMod& mod, ItemGiveHandle handle) {
+    const auto modIt = s_modObservers.find(&mod);
+    if (modIt == s_modObservers.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const auto removed = std::erase_if(
+        modIt->second, [&](const auto& observer) { return observer.handle == handle; });
+    s_observerCount -= removed;
+    return removed != 0 ? MOD_OK : MOD_INVALID_ARGUMENT;
+}
+
+void item_gives_remove_mod(LoadedMod& mod) {
+    if (const auto modIt = s_modObservers.find(&mod); modIt != s_modObservers.end()) {
+        s_observerCount -= modIt->second.size();
+        s_modObservers.erase(modIt);
+    }
+    std::erase_if(s_giveQueue, [&](const QueuedGive& give) { return give.owner == &mod; });
+    if (s_inFlight && s_inFlightGive.owner == &mod) {
+        // The event system already owns this grant, so it can no longer be canceled safely.
+        s_inFlightGive.owner = nullptr;
+    }
+}
+
+}  // namespace svc
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/bundle_disk.cpp b/src/dusk/mods/loader/bundle_disk.cpp
index 26e1bbd722..c9903b9b38 100644
--- a/src/dusk/mods/loader/bundle_disk.cpp
+++ b/src/dusk/mods/loader/bundle_disk.cpp
@@ -1,6 +1,7 @@
 #include <utility>
 
 #include "dusk/io.hpp"
+#include <borealis/io.hpp>
 #include "loader.hpp"
 
 namespace fs = std::filesystem;
@@ -32,7 +33,7 @@ std::vector<std::string> ModBundleDisk::getFileNames() {
 
         const auto& path = it->path();
         const auto relPath = fs::relative(path, root_path);
-        auto string = io::fs_path_to_string(relPath);
+        auto string = borealis::io::fs_path_to_string(relPath);
         if constexpr (fs::path::preferred_separator != '/') {
             // Convert \ to / on Windows
             for (auto& chr : string) {
diff --git a/src/dusk/mods/loader/bundle_zip.cpp b/src/dusk/mods/loader/bundle_zip.cpp
index 517c5943c2..630fa3ae97 100644
--- a/src/dusk/mods/loader/bundle_zip.cpp
+++ b/src/dusk/mods/loader/bundle_zip.cpp
@@ -1,68 +1,25 @@
-#include "fmt/format.h"
 #include "loader.hpp"
 
-#include <span>
+#include <stdexcept>
 
 namespace dusk::mods {
 
-ModBundleZip::ModBundleZip(std::vector<u8>&& data) : zip_data(std::move(data)) {
-    if (!mz_zip_reader_init_mem(&res_zip, zip_data.data(), zip_data.size(), 0)) {
-        const auto error = mz_zip_get_last_error(&res_zip);
-        throw std::runtime_error(
-            fmt::format("Opening zip failed: {}", mz_zip_get_error_string(error)));
+ModBundleZip::ModBundleZip(const std::filesystem::path& path) : m_archive{path} {
+    if (m_archive.package_format() != archive::PackageFormat::Mod) {
+        throw std::runtime_error("Archive is not a valid mod package");
     }
 }
 
-ModBundleZip::~ModBundleZip() {
-    mz_zip_reader_end(&res_zip);
-}
-
 std::vector<u8> ModBundleZip::readFile(const std::string& fileName) {
-    std::lock_guard lock{m_mutex};
-    size_t size;
-    const auto ptr = mz_zip_reader_extract_file_to_heap(&res_zip, fileName.c_str(), &size, 0);
-
-    if (!ptr) {
-        throw std::runtime_error(fmt::format("File does not exist: {}", fileName));
-    }
-
-    std::span data(static_cast<u8*>(ptr), size);
-    std::vector vec(data.begin(), data.end());
-
-    mz_free(ptr);
-
-    return vec;
+    return m_archive.read_file(fileName);
 }
 
 std::vector<std::string> ModBundleZip::getFileNames() {
-    std::lock_guard lock{m_mutex};
-    std::vector<std::string> results;
-
-    for (mz_uint i = 0, n = mz_zip_reader_get_num_files(&res_zip); i < n; ++i) {
-        mz_zip_archive_file_stat stat{};
-        if (!mz_zip_reader_file_stat(&res_zip, i, &stat)) {
-            continue;
-        }
-        if (mz_zip_reader_is_file_a_directory(&res_zip, i)) {
-            continue;
-        }
-
-        results.emplace_back(stat.m_filename);
-    }
-
-    return results;
+    return m_archive.file_names();
 }
 
 size_t ModBundleZip::getFileSize(const std::string& fileName) {
-    std::lock_guard lock{m_mutex};
-    const auto idx = mz_zip_reader_locate_file(&res_zip, fileName.c_str(), nullptr, 0);
-    if (idx < 0) {
-        throw std::runtime_error(fmt::format("Unable to locate file in zip: {}", fileName));
-    }
-
-    mz_zip_archive_file_stat stat{};
-    mz_zip_reader_file_stat(&res_zip, idx, &stat);
-    return stat.m_uncomp_size;
+    return m_archive.file_size(fileName);
 }
 
 }  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/code_patch_macos.cpp b/src/dusk/mods/loader/code_patch_macos.cpp
new file mode 100644
index 0000000000..64a7b4a606
--- /dev/null
+++ b/src/dusk/mods/loader/code_patch_macos.cpp
@@ -0,0 +1,223 @@
+#include "code_patch_macos.hpp"
+
+#include <libkern/OSCacheControl.h>
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#define PATCH_CODE                                                                                 \
+    __attribute__((section("__TEXT,__code_patch,regular,pure_instructions"), noinline))
+
+extern const char kPatchBegin[] asm("section$start$__TEXT$__code_patch");
+extern const char kPatchEnd[] asm("section$end$__TEXT$__code_patch");
+
+namespace {
+
+constexpr unsigned kMaxThreads = 1024;
+constexpr unsigned kMaxAttempts = 16;
+constexpr size_t kMaxPatchSize = 16;
+pthread_mutex_t sPatchMutex = PTHREAD_MUTEX_INITIALIZER;
+
+struct ThreadList {
+    thread_act_array_t threads = nullptr;
+    mach_msg_type_number_t count = 0;
+};
+
+PATCH_CODE void release_threads(ThreadList& list) {
+    for (unsigned i = 0; i < list.count; ++i) {
+        mach_port_deallocate(mach_task_self(), list.threads[i]);
+    }
+    if (list.threads != nullptr) {
+        vm_deallocate(mach_task_self(), reinterpret_cast<vm_address_t>(list.threads),
+            list.count * sizeof(thread_t));
+    }
+}
+
+PATCH_CODE kern_return_t read_pc(thread_t thread, uintptr_t& pc) {
+#if defined(__aarch64__)
+    arm_thread_state64_t state{};
+    mach_msg_type_number_t count = ARM_THREAD_STATE64_COUNT;
+    const auto result = thread_get_state(
+        thread, ARM_THREAD_STATE64, reinterpret_cast<thread_state_t>(&state), &count);
+    pc = arm_thread_state64_get_pc(state);
+#elif defined(__x86_64__)
+    x86_thread_state64_t state{};
+    mach_msg_type_number_t count = x86_THREAD_STATE64_COUNT;
+    const auto result = thread_get_state(
+        thread, x86_THREAD_STATE64, reinterpret_cast<thread_state_t>(&state), &count);
+    pc = state.__rip;
+#else
+#error Unsupported macOS architecture
+#endif
+    return result;
+}
+
+PATCH_CODE __attribute__((aligned(16384))) kern_return_t commit_patch(uintptr_t target,
+    const unsigned char* expected, const unsigned char* replacement, size_t size, uintptr_t page,
+    size_t pageSize, thread_t currentThread) {
+    ThreadList initial;
+    auto result = task_threads(mach_task_self(), &initial.threads, &initial.count);
+    if (result != KERN_SUCCESS) {
+        return result;
+    }
+    thread_t suspended[kMaxThreads];
+    unsigned suspendedCount = 0;
+    if (initial.count > kMaxThreads) {
+        release_threads(initial);
+        return KERN_RESOURCE_SHORTAGE;
+    }
+
+    for (unsigned i = 0; i < initial.count; ++i) {
+        const auto thread = initial.threads[i];
+        if (thread == currentThread) {
+            continue;
+        }
+        result = thread_suspend(thread);
+        if (result != KERN_SUCCESS) {
+            break;
+        }
+        suspended[suspendedCount++] = thread;
+        uintptr_t pc = 0;
+        result = read_pc(thread, pc);
+        if (result != KERN_SUCCESS) {
+            break;
+        }
+        if (pc >= target && pc < target + size) {
+            result = KERN_ABORTED;
+            break;
+        }
+    }
+
+    if (result == KERN_SUCCESS) {
+        ThreadList current;
+        result = task_threads(mach_task_self(), &current.threads, &current.count);
+        if (result == KERN_SUCCESS) {
+            for (unsigned i = 0; i < current.count; ++i) {
+                bool known = false;
+                for (unsigned j = 0; j < initial.count; ++j) {
+                    known |= current.threads[i] == initial.threads[j];
+                }
+                if (!known) {
+                    result = KERN_ABORTED;
+                    break;
+                }
+            }
+        }
+        release_threads(current);
+    }
+
+    if (result == KERN_SUCCESS) {
+        const auto* bytes = reinterpret_cast<const volatile unsigned char*>(target);
+        for (size_t i = 0; i < size; ++i) {
+            if (bytes[i] != expected[i]) {
+                result = KERN_INVALID_VALUE;
+                break;
+            }
+        }
+    }
+
+    if (result == KERN_SUCCESS) {
+        result = mach_vm_protect(
+            mach_task_self(), page, pageSize, false, VM_PROT_READ | VM_PROT_WRITE | VM_PROT_COPY);
+        if (result == KERN_SUCCESS) {
+            auto* bytes = reinterpret_cast<volatile unsigned char*>(target);
+            for (size_t i = 0; i < size; ++i) {
+                bytes[i] = replacement[i];
+            }
+            sys_icache_invalidate(reinterpret_cast<void*>(target), size);
+            result = mach_vm_protect(
+                mach_task_self(), page, pageSize, false, VM_PROT_READ | VM_PROT_EXECUTE);
+            if (result != KERN_SUCCESS) {
+                for (size_t i = 0; i < size; ++i) {
+                    bytes[i] = expected[i];
+                }
+                sys_icache_invalidate(reinterpret_cast<void*>(target), size);
+                if (mach_vm_protect(mach_task_self(), page, pageSize, false,
+                        VM_PROT_READ | VM_PROT_EXECUTE) != KERN_SUCCESS)
+                {
+                    __builtin_trap();  // Can't resume into non-executable code
+                }
+            }
+        }
+    }
+
+    for (unsigned i = 0; i < suspendedCount; ++i) {
+        if (thread_resume(suspended[i]) != KERN_SUCCESS) {
+            __builtin_trap();
+        }
+    }
+    release_threads(initial);
+    return result;
+}
+
+}  // namespace
+
+extern "C" int commit_code_patch(
+    void* targetPointer, const void* expected, const void* replacement, size_t size) {
+    if (targetPointer == nullptr || expected == nullptr || replacement == nullptr || size == 0 ||
+        size > kMaxPatchSize)
+    {
+        return KERN_INVALID_ARGUMENT;
+    }
+    const auto target = reinterpret_cast<uintptr_t>(targetPointer);
+    const size_t pageSize = vm_page_size;
+    if (target > UINTPTR_MAX - size - pageSize) {
+        return KERN_INVALID_ADDRESS;
+    }
+    const auto page = target & ~(pageSize - 1);
+    const size_t length = ((target + size + pageSize - 1) & ~(pageSize - 1)) - page;
+    if (page < reinterpret_cast<uintptr_t>(kPatchEnd) &&
+        page + length > reinterpret_cast<uintptr_t>(kPatchBegin))
+    {
+        return KERN_PROTECTION_FAILURE;
+    }
+
+    unsigned char oldCode[kMaxPatchSize];
+    unsigned char newCode[kMaxPatchSize];
+    for (size_t i = 0; i < size; ++i) {
+        oldCode[i] = static_cast<const unsigned char*>(expected)[i];
+        newCode[i] = static_cast<const unsigned char*>(replacement)[i];
+    }
+
+    pthread_mutex_lock(&sPatchMutex);
+    mach_vm_address_t region = page;
+    mach_vm_size_t regionSize = 0;
+    vm_region_basic_info_data_64_t info{};
+    mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
+    mach_port_t object = MACH_PORT_NULL;
+    auto result = mach_vm_region(mach_task_self(), &region, &regionSize, VM_REGION_BASIC_INFO_64,
+        reinterpret_cast<vm_region_info_t>(&info), &count, &object);
+    if (object != MACH_PORT_NULL) {
+        mach_port_deallocate(mach_task_self(), object);
+    }
+    if (result == KERN_SUCCESS && (region > page || regionSize < page + length - region ||
+                                      info.protection != (VM_PROT_READ | VM_PROT_EXECUTE)))
+    {
+        result = KERN_PROTECTION_FAILURE;
+    }
+    if (result == KERN_SUCCESS) {
+        const auto currentThread = mach_thread_self();
+        uintptr_t pc = 0;
+        read_pc(currentThread, pc);
+        thread_suspend(MACH_PORT_NULL);
+        thread_resume(MACH_PORT_NULL);
+        vm_deallocate(mach_task_self(), 0, 0);
+        mach_port_deallocate(mach_task_self(), MACH_PORT_NULL);
+        sys_icache_invalidate(targetPointer, size);
+        result = mach_vm_protect(mach_task_self(), page, length, false, info.protection);
+        if (result == KERN_SUCCESS) {
+            for (unsigned attempt = 0; attempt < kMaxAttempts; ++attempt) {
+                result = commit_patch(target, oldCode, newCode, size, page, length, currentThread);
+                if (result != KERN_ABORTED || attempt + 1 == kMaxAttempts) {
+                    break;
+                }
+                usleep(1000);
+            }
+        }
+        mach_port_deallocate(mach_task_self(), currentThread);
+    }
+    pthread_mutex_unlock(&sPatchMutex);
+    return result;
+}
diff --git a/src/dusk/mods/loader/code_patch_macos.hpp b/src/dusk/mods/loader/code_patch_macos.hpp
new file mode 100644
index 0000000000..540e806404
--- /dev/null
+++ b/src/dusk/mods/loader/code_patch_macos.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int commit_code_patch(void* target, const void* expected, const void* replacement, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/dusk/mods/loader/depgraph.cpp b/src/dusk/mods/loader/depgraph.cpp
index d1748b56c4..d814d64f2a 100644
--- a/src/dusk/mods/loader/depgraph.cpp
+++ b/src/dusk/mods/loader/depgraph.cpp
@@ -9,7 +9,7 @@
 
 namespace dusk::mods::loader {
 namespace {
-aurora::Module Log{"dusk::mods::loader"};
+constexpr borealis::Log Log{"dusk::mods::loader"};
 
 struct Edge {
     size_t provider;
diff --git a/src/dusk/mods/loader/loader.cpp b/src/dusk/mods/loader/loader.cpp
index e1bb2797c8..16c49f8c45 100644
--- a/src/dusk/mods/loader/loader.cpp
+++ b/src/dusk/mods/loader/loader.cpp
@@ -1,262 +1,80 @@
 #include "loader.hpp"
+
+#include "depgraph.hpp"
+#include "manifest.hpp"
+#include "native_module.hpp"
+#include "natives.hpp"
+#include "packages.hpp"
+#if DUSK_HAS_PREPATCH
+#include "prepatch.hpp"
+#endif
+
+#include "dusk/config.hpp"
+#include "dusk/data.hpp"
 #include "dusk/logging.h"
 #include "dusk/mod_loader.hpp"
+#include "dusk/mods/log_buffer.hpp"
+#include "dusk/mods/manifest.hpp"
+#include "dusk/mods/path.hpp"
+#include "dusk/mods/queue.hpp"
+#include "dusk/mods/svc/config.hpp"
+#include "dusk/mods/svc/hook.hpp"
+#include "dusk/mods/svc/registry.hpp"
+#include "dusk/ui/mod_texture_provider.hpp"
+#include "dusk/ui/mods_window.hpp"
+#include "dusk/ui/ui.hpp"
+
+#include <borealis/io.hpp>
+#include <borealis/update.hpp>
+#include <fmt/format.h>
 
 #include <algorithm>
 #include <chrono>
 #include <filesystem>
-#include <fstream>
 #include <string>
 #include <string_view>
 #include <utility>
+#include <variant>
 
-#include "../manifest.hpp"
-#include "depgraph.hpp"
-#include "dusk/config.hpp"
-#include "dusk/io.hpp"
-#include "dusk/mods/log_buffer.hpp"
-#include "dusk/mods/svc/config.hpp"
-#include "dusk/mods/svc/registry.hpp"
-#include "dusk/ui/mods_window.hpp"
-#include "dusk/ui/ui.hpp"
-#include "miniz.h"
-#include "native_module.hpp"
-#include "nlohmann/json.hpp"
-
-using namespace std::string_literals;
-using namespace std::string_view_literals;
-
-#if defined(_WIN32)
-#if defined(_M_ARM64)
-static constexpr std::string_view k_nativeLibName = "windows-arm64.dll"sv;
-#elif defined(_M_X64)
-static constexpr std::string_view k_nativeLibName = "windows-amd64.dll"sv;
-#elif defined(_M_IX86)
-static constexpr std::string_view k_nativeLibName = "windows-x86.dll"sv;
-#else
-static constexpr std::string_view k_nativeLibName = ""sv;
-#endif
-#elif defined(__ANDROID__)
-#if defined(__aarch64__)
-static constexpr std::string_view k_nativeLibName = "android-aarch64.so"sv;
-#elif defined(__x86_64__)
-static constexpr std::string_view k_nativeLibName = "android-x86_64.so"sv;
-#else
-static constexpr std::string_view k_nativeLibName = ""sv;
-#endif
-#elif defined(__APPLE__)
-#include <TargetConditionals.h>
-#if TARGET_OS_IOS
-static constexpr std::string_view k_nativeLibName = "ios-arm64.dylib"sv;
-#elif TARGET_OS_TV
-static constexpr std::string_view k_nativeLibName = "tvos-arm64.dylib"sv;
-#elif defined(__aarch64__)
-static constexpr std::string_view k_nativeLibName = "darwin-arm64.dylib"sv;
-#elif defined(__x86_64__)
-static constexpr std::string_view k_nativeLibName = "darwin-x86_64.dylib"sv;
-#else
-static constexpr std::string_view k_nativeLibName = ""sv;
-#endif
-#elif defined(__linux__)
-#if defined(__aarch64__)
-static constexpr std::string_view k_nativeLibName = "linux-aarch64.so"sv;
-#elif defined(__x86_64__)
-static constexpr std::string_view k_nativeLibName = "linux-x86_64.so"sv;
-#elif defined(__i386__)
-static constexpr std::string_view k_nativeLibName = "linux-x86.so"sv;
-#else
-static constexpr std::string_view k_nativeLibName = ""sv;
-#endif
-#else
-static constexpr std::string_view k_nativeLibName = ""sv;
-#endif
+namespace fs = std::filesystem;
 
 namespace dusk::mods {
 namespace {
-aurora::Module Log{"dusk::mods::loader"};
+constexpr borealis::Log Log{"dusk::mods::loader"};
 ModLoader g_modLoader;
 
-std::unique_ptr<ModBundle> load_bundle(const std::filesystem::path& modPath, bool fromDir) {
-    if (fromDir) {
-        return std::make_unique<ModBundleDisk>(modPath);
-    } else {
-        std::vector<u8> data = io::FileStream::ReadAllBytes(modPath);
-        return std::make_unique<ModBundleZip>(std::move(data));
+void complete_operation(const std::shared_ptr<ModOperation>& operation, const bool success = true,
+    std::string message = {}) {
+    if (operation == nullptr) {
+        return;
     }
+    operation->state = success ? ModOperation::State::Succeeded : ModOperation::State::Failed;
+    operation->message = std::move(message);
 }
 
-struct DllLocateResult {
-    std::string entry;
-    bool anyLibs = false;
-};
-
-DllLocateResult locate_dll_in_bundle(ModBundle& bundle) {
-    DllLocateResult result;
-    for (const auto& name : bundle.getFileNames()) {
-        if (name.find('/') != std::string::npos ||
-            (!name.ends_with(".dll"sv) && !name.ends_with(".dylib"sv) && !name.ends_with(".so"sv)))
-        {
-            continue;
-        }
-        result.anyLibs = true;
-        if (name == k_nativeLibName) {
-            result.entry = name;
-        }
+LoadedMod::FileIdentity file_identity(const fs::path& path) {
+    std::error_code error;
+    const bool isDirectory = fs::is_directory(path, error);
+    if (error) {
+        return {};
     }
-    return result;
+    const auto size = isDirectory ? 0 : fs::file_size(path, error);
+    if (error) {
+        return {};
+    }
+    const auto modified = fs::last_write_time(path, error);
+    if (error) {
+        return {};
+    }
+    return {.size = size, .modified = modified, .valid = true};
 }
+
 }  // namespace
 
 ModLoader& ModLoader::instance() {
     return g_modLoader;
 }
 
-class InvalidModDataException : public std::runtime_error {
-public:
-    explicit InvalidModDataException(const std::string& msg) : runtime_error(msg) {}
-    explicit InvalidModDataException(const char* msg) : runtime_error(msg) {}
-};
-
-static void validate_mod_id(std::string_view const str) {
-    if (str.empty()) {
-        throw InvalidModDataException("Missing ID value in mod metadata!");
-    }
-
-    bool lastWasPeriod = false;
-    for (auto const chr : str) {
-        if (chr == '.') {
-            if (lastWasPeriod) {
-                throw InvalidModDataException("Cannot have two consecutive periods in mod ID!");
-            }
-            lastWasPeriod = true;
-            continue;
-        }
-
-        lastWasPeriod = false;
-
-        if (chr == '_')
-            continue;
-
-        if (chr >= '0' && chr <= '9')
-            continue;
-
-        if (chr >= 'a' && chr <= 'z')
-            continue;
-
-        if (chr >= 'A' && chr <= 'Z')
-            continue;
-
-        throw InvalidModDataException(
-            fmt::format("Invalid character '{}' in mod ID. Valid characters are period, "
-                        "underscore, and alphanumerics.",
-                chr));
-    }
-}
-
-static bool bundle_has_file(ModBundle& bundle, const std::string& path) {
-    try {
-        bundle.getFileSize(path);
-        return true;
-    } catch (const std::runtime_error&) {
-        return false;
-    }
-}
-
-static std::string resolve_image_path(ModBundle& bundle, const std::string& modId,
-    std::string_view key, const std::string& manifestPath, const std::string& defaultPath) {
-    if (!manifestPath.empty()) {
-        if (!is_safe_resource_path(manifestPath)) {
-            log::write(
-                modId, LOG_LEVEL_WARN, "invalid {} path '{}' in mod.json", key, manifestPath);
-        } else if (!bundle_has_file(bundle, manifestPath)) {
-            log::write(
-                modId, LOG_LEVEL_WARN, "{} path '{}' not found in bundle", key, manifestPath);
-        } else {
-            return manifestPath;
-        }
-    }
-    if (bundle_has_file(bundle, defaultPath)) {
-        return defaultPath;
-    }
-    return {};
-}
-
-static ModMetadata load_metadata(const std::filesystem::path& modPath, ModBundle& bundle) {
-    const auto metaJson = bundle.readFile("mod.json");
-    auto j = nlohmann::json::parse(metaJson);
-
-    std::string metaId = j.value("id", "");
-    std::string metaName = j.value("name", "");
-    std::string metaVersion = j.value("version", "");
-    std::string metaAuthor = j.value("author", "");
-    std::string metaDescription = j.value("description", "");
-    std::string metaIcon = j.value("icon", "");
-    std::string metaBanner = j.value("banner", "");
-
-    validate_mod_id(metaId);
-
-    if (metaName.empty()) {
-        metaName = io::fs_path_to_string(modPath.stem());
-    }
-    if (metaVersion.empty()) {
-        metaVersion = "?"s;
-    }
-    if (metaAuthor.empty()) {
-        metaAuthor = "unknown"s;
-    }
-
-    std::string iconPath = resolve_image_path(bundle, metaId, "icon", metaIcon, "res/icon.png"s);
-    std::string bannerPath =
-        resolve_image_path(bundle, metaId, "banner", metaBanner, "res/banner.png"s);
-
-    return ModMetadata{
-        std::move(metaId),
-        std::move(metaName),
-        std::move(metaVersion),
-        std::move(metaAuthor),
-        std::move(metaDescription),
-        std::move(iconPath),
-        std::move(bannerPath),
-    };
-}
-
-static bool validate_manifest(const ModManifest* manifest, LoadedMod& mod) {
-    if (manifest == nullptr) {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "returned a null mod manifest");
-        mod.nativeStatus = NativeModStatus::MissingExport;
-        return false;
-    }
-    if (manifest->struct_size != sizeof(ModManifest)) {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "manifest has invalid size {} (expected {})",
-            manifest->struct_size, sizeof(ModManifest));
-        mod.nativeStatus = NativeModStatus::ApiVersionMismatch;
-        return false;
-    }
-    if (manifest->abi_version != MOD_ABI_VERSION) {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "expects ABI v{} but engine is v{}, skipping",
-            manifest->abi_version, MOD_ABI_VERSION);
-        mod.nativeStatus = NativeModStatus::ApiVersionMismatch;
-        return false;
-    }
-    if ((manifest->import_count > 0 && manifest->imports == nullptr) ||
-        (manifest->export_count > 0 && manifest->exports == nullptr))
-    {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "manifest has invalid import/export arrays");
-        mod.nativeStatus = NativeModStatus::MissingExport;
-        return false;
-    }
-    return true;
-}
-
-static bool validate_context_symbol(ModContext** contextSymbol, LoadedMod& mod) {
-    if (contextSymbol == nullptr) {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "missing required mod_ctx export");
-        mod.nativeStatus = NativeModStatus::MissingExport;
-        return false;
-    }
-    return true;
-}
-
 static std::string lifecycle_error_message(
     const char* fnName, const ModResult result, const ModError& error) {
     if (error.message[0] != '\0') {
@@ -265,194 +83,6 @@ static std::string lifecycle_error_message(
     return fmt::format("{} failed with result {}", fnName, static_cast<int>(result));
 }
 
-static std::string native_status_message(const NativeModStatus status) {
-    switch (status) {
-    case NativeModStatus::BuildDisabled:
-        return "Code mods are disabled on this Dusklight build";
-    case NativeModStatus::ModMissingPlatform:
-        return fmt::format("Mod not supported on this platform ({})", k_nativeLibName);
-    case NativeModStatus::ApiVersionMismatch:
-        // TODO: differentiate whether mod or Dusklight is out of date
-        return "Mod ABI version mismatch";
-    case NativeModStatus::MissingExport:
-        return "Missing required mod API exports";
-    case NativeModStatus::Unknown:
-        return "Unknown mod load failure";
-    case NativeModStatus::None:
-    case NativeModStatus::Loaded:
-        break;
-    }
-    return "native mod failed to load";
-}
-
-std::filesystem::path ModLoader::external_native_lib_path(const LoadedMod& mod) const {
-    namespace fs = std::filesystem;
-    if (k_nativeLibName.empty()) {
-        return {};
-    }
-    const auto& libDir = m_searchDirs[mod.searchDirIndex].nativeLibDir;
-    if (libDir.empty()) {
-        return {};
-    }
-    fs::path path = libDir / fs::path(mod.metadata.id +
-                                      io::fs_path_to_string(fs::path(k_nativeLibName).extension()));
-    std::error_code ec;
-    if (!fs::is_regular_file(path, ec)) {
-        return {};
-    }
-    return path;
-}
-
-void ModLoader::load_native(LoadedMod& mod, const std::string& dllEntry) {
-    if (!EnableCodeMods) {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "Code mods are not available in this build");
-        mod.nativeStatus = NativeModStatus::BuildDisabled;
-        return;
-    }
-
-    namespace fs = std::filesystem;
-
-    const fs::path cacheDir = m_cacheDir / mod.metadata.id;
-    std::error_code ec;
-    fs::create_directories(cacheDir, ec);
-
-    fs::path libPath;
-    if (mod.inPlace) {
-        if (!dllEntry.empty()) {
-            libPath = fs::path(mod.modPath) / dllEntry;
-        } else if (auto external = external_native_lib_path(mod); !external.empty()) {
-            libPath = std::move(external);
-        } else {
-            log::write(mod.metadata.id, LOG_LEVEL_ERROR,
-                "no native library named {} found; skipping", k_nativeLibName);
-            mod.nativeStatus = NativeModStatus::ModMissingPlatform;
-            return;
-        }
-    } else {
-        if (dllEntry.empty()) {
-            log::write(mod.metadata.id, LOG_LEVEL_ERROR,
-                "no native library named {} found; skipping", k_nativeLibName);
-            mod.nativeStatus = NativeModStatus::ModMissingPlatform;
-            return;
-        }
-
-        // Generation-versioned filename: every dlopen gets a path it has never seen, so a reload
-        // always yields a fresh image with fresh statics even if the previous dlclose did not
-        // fully unmap the old one (TLS/ObjC pinning). The .cache dir is wiped on startup.
-        const fs::path dllCachePath =
-            cacheDir / fmt::format("{}.g{}{}", mod.metadata.id, ++mod.cacheGeneration,
-                           io::fs_path_to_string(fs::path(dllEntry).extension()));
-
-        std::vector<u8> dllData;
-        try {
-            dllData = mod.bundle->readFile(dllEntry);
-        } catch (const std::exception& e) {
-            log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to extract {}", dllEntry);
-            return;
-        }
-
-        {
-            std::ofstream out(dllCachePath, std::ios::binary | std::ios::out);
-            if (!out) {
-                log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to write {}",
-                    io::fs_path_to_string(dllCachePath));
-                return;
-            }
-
-            out.write(reinterpret_cast<const char*>(dllData.data()),
-                static_cast<std::streamsize>(dllData.size()));
-        }
-
-        libPath = dllCachePath;
-    }
-
-    auto nativeMod = std::make_unique<NativeMod>();
-    try {
-        nativeMod->handle = std::make_unique<loader::NativeModule>(libPath);
-    } catch (const std::runtime_error& e) {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to open {}: {}",
-            io::fs_path_to_string(libPath), e.what());
-        return;
-    }
-
-    const auto getManifest = nativeMod->handle->LookupSymbol<ModGetManifestFn>("mod_get_manifest");
-    nativeMod->contextSymbol = nativeMod->handle->LookupSymbol<ModContext**>("mod_ctx");
-    nativeMod->fn_initialize = nativeMod->handle->LookupSymbol<ModInitializeFn>("mod_initialize");
-    nativeMod->fn_update = nativeMod->handle->LookupSymbol<ModUpdateFn>("mod_update");
-    nativeMod->fn_shutdown = nativeMod->handle->LookupSymbol<ModShutdownFn>("mod_shutdown");
-
-    if (!getManifest || !nativeMod->contextSymbol || !nativeMod->fn_initialize ||
-        !nativeMod->fn_update || !nativeMod->fn_shutdown)
-    {
-        log::write(mod.metadata.id, LOG_LEVEL_ERROR,
-            "{} missing required mod API exports; skipping",
-            io::fs_path_to_string(libPath.filename()));
-        mod.nativeStatus = NativeModStatus::MissingExport;
-        return;
-    }
-
-    nativeMod->manifest = getManifest();
-    if (!validate_manifest(nativeMod->manifest, mod)) {
-        return;
-    }
-
-    if (!validate_context_symbol(nativeMod->contextSymbol, mod)) {
-        return;
-    }
-    *nativeMod->contextSymbol = mod.context.get();
-
-    mod.dir = io::fs_path_to_string(fs::absolute(cacheDir));
-    mod.nativePath = io::fs_path_to_string(fs::absolute(libPath));
-    mod.native = std::move(nativeMod);
-    mod.nativeStatus = NativeModStatus::Loaded;
-}
-
-void ModLoader::unload_native(LoadedMod& mod) {
-    if (!mod.native || mod.inPlace) {
-        return;
-    }
-    // Deferred dlclose: this mod's code may still be on the stack below the current tick
-    m_retiredNatives.push_back({std::move(mod.native), std::move(mod.nativePath)});
-    mod.nativePath.clear();
-}
-
-void ModLoader::drain_retired_natives() {
-    for (auto& retired : m_retiredNatives) {
-        retired.native.reset();
-        if (!retired.path.empty()) {
-            std::error_code ec;
-            std::filesystem::remove(retired.path, ec);
-        }
-    }
-    m_retiredNatives.clear();
-}
-
-static ModManifestInfo build_manifest_info(const ModManifest& manifest) {
-    ModManifestInfo info;
-    info.imports.reserve(manifest.import_count);
-    for (size_t i = 0; i < manifest.import_count; ++i) {
-        const auto& serviceImport = manifest.imports[i];
-        if (serviceImport.struct_size != sizeof(ServiceImport) ||
-            !svc::valid_service_id(serviceImport.service_id))
-        {
-            continue;
-        }
-        info.imports.push_back({serviceImport.service_id, serviceImport.major_version,
-            (serviceImport.flags & SERVICE_IMPORT_OPTIONAL) == 0});
-    }
-    info.exports.reserve(manifest.export_count);
-    for (size_t i = 0; i < manifest.export_count; ++i) {
-        const auto& serviceExport = manifest.exports[i];
-        if (serviceExport.struct_size != sizeof(ServiceExport) ||
-            !svc::valid_service_id(serviceExport.service_id))
-        {
-            continue;
-        }
-        info.exports.push_back({serviceExport.service_id, serviceExport.major_version});
-    }
-    return info;
-}
-
 std::string escape_mod_id_for_config(std::string_view const id) {
     std::string buf;
 
@@ -484,88 +114,95 @@ static bool required_deps_active(const LoadedMod& mod) {
 // A deferred export that was not published by the end of the provider's initialization can
 // never resolve, which is almost certainly a bug in the provider.
 static void warn_unpublished_deferred_exports(const LoadedMod& mod) {
-    if (!mod.active || !mod.native || mod.native->manifest == nullptr) {
+    if (!mod.active || !mod.native) {
         return;
     }
 
-    const auto& manifest = *mod.native->manifest;
-    for (size_t i = 0; i < manifest.export_count; ++i) {
-        const auto& serviceExport = manifest.exports[i];
-        if (serviceExport.struct_size != sizeof(ServiceExport) ||
-            (serviceExport.flags & SERVICE_EXPORT_DEFERRED) == 0)
-        {
+    for (const auto* serviceExport : mod.native->parsed.exports) {
+        if ((serviceExport->rec.flags & SERVICE_EXPORT_DEFERRED) == 0) {
             continue;
         }
         const auto* record =
-            svc::find_service_record(serviceExport.service_id, serviceExport.major_version);
+            svc::find_service_record(serviceExport->service_id.chars, serviceExport->major_version);
         if (record != nullptr && record->service == nullptr) {
             log::write(mod.metadata.id, LOG_LEVEL_WARN,
                 "declared deferred service '{}@{}' but never published it during initialization",
-                serviceExport.service_id, serviceExport.major_version);
+                serviceExport->service_id.chars, serviceExport->major_version);
         }
     }
 }
 
-void ModLoader::try_load_mod(
-    const std::filesystem::path& modPath, bool fromDir, uint32_t searchDirIndex) {
-    namespace fs = std::filesystem;
-
-    std::unique_ptr<ModBundle> bundle;
-    try {
-        bundle = load_bundle(modPath, fromDir);
-    } catch (const std::exception& e) {
-        Log.error(
-            "Failed to open {} bundle: {}", io::fs_path_to_string(modPath.filename()), e.what());
-        return;
-    }
-
-    ModMetadata metadata;
-    try {
-        metadata = load_metadata(modPath, *bundle);
-    } catch (const std::exception& e) {
-        Log.error("bad mod.json in {}: {}", io::fs_path_to_string(modPath.filename()), e.what());
-        return;
-    }
-
-    if (const auto* existing = find_mod(metadata.id)) {
-        if (existing->searchDirIndex < searchDirIndex) {
-            log::write(metadata.id, LOG_LEVEL_INFO, "{} shadowed by higher-priority copy {}",
-                io::fs_path_to_string(modPath.filename()), existing->modPath);
-        } else {
-            log::write(metadata.id, LOG_LEVEL_ERROR, "duplicate mod id, not loading {}",
-                io::fs_path_to_string(modPath.filename()));
+LoadedMod* ModLoader::try_load_mod(const fs::path& modPath, bool fromDir, uint32_t searchDirIndex,
+    std::unique_ptr<ModBundle> bundle) {
+    if (bundle == nullptr) {
+        try {
+            bundle = load_bundle(modPath, fromDir);
+        } catch (const std::exception& e) {
+            Log.error(
+                "Failed to open {} bundle: {}", data::abbreviated_path_string(modPath), e.what());
+            return nullptr;
         }
-        return;
+    }
+
+    LoadedManifest manifest;
+    try {
+        manifest = load_manifest(modPath, *bundle);
+    } catch (const std::exception& e) {
+        Log.error("bad mod.json in {}: {}", data::abbreviated_path_string(modPath), e.what());
+        return nullptr;
+    }
+
+    if (const auto* existing = find_mod(manifest.metadata.id)) {
+        if (existing->searchDirIndex < searchDirIndex) {
+            log::write(manifest.metadata.id, LOG_LEVEL_INFO,
+                "{} shadowed by higher-priority duplicate {}",
+                data::abbreviated_path_string(modPath),
+                data::abbreviated_path_string(existing->modPath));
+        } else {
+            log::write(manifest.metadata.id, LOG_LEVEL_ERROR, "duplicate mod id, not loading {}",
+                data::abbreviated_path_string(modPath));
+        }
+        return nullptr;
     }
 
     const auto& inserted = m_mods.emplace_back(std::make_unique<LoadedMod>());
-
     auto& mod = *inserted;
     mod.active = true;
-    mod.modPath = io::fs_path_to_string(fs::absolute(modPath));
+    mod.modPath = fs::absolute(modPath);
     mod.searchDirIndex = searchDirIndex;
-    mod.inPlace = m_searchDirs[searchDirIndex].inPlaceNative && fromDir;
-    mod.metadata = std::move(metadata);
+    mod.fromDirectory = fromDir;
+    mod.nativeInPlace = m_searchDirs[searchDirIndex].inPlaceNative && fromDir;
+    mod.fileIdentity = file_identity(modPath);
+    mod.metadata = std::move(manifest.metadata);
+    mod.runtime = std::move(manifest.runtime);
     mod.bundle = std::move(bundle);
     mod.context = std::make_unique<ModContext>();
     mod.context->mod = &mod;
     mod.cvarIsEnabled =
         std::make_unique<ConfigVar<bool>>(mod_enabled_cvar_name(mod.metadata.id), true);
+    if (mod.runtime.has_value()) {
+        const auto& runtime = *mod.runtime;
+        mod.manifestInfo.imports.push_back({runtime.id, runtime.major, runtime.minMinor, true});
 
-    const auto [dllEntry, anyLibs] = locate_dll_in_bundle(*mod.bundle);
-    if (anyLibs || (mod.inPlace && !external_native_lib_path(mod).empty())) {
-        mod.nativeStatus = NativeModStatus::Unknown;
-        load_native(mod, dllEntry);
-        if (mod.nativeStatus != NativeModStatus::Loaded) {
-            Log.error("Native mod '{}' failed to load, disabling", mod.metadata.id);
-            fail_mod(mod, MOD_ERROR, native_status_message(mod.nativeStatus));
-        } else {
-            mod.manifestInfo = build_manifest_info(*mod.native->manifest);
+        std::error_code ec;
+        mod.dir = fs::absolute(m_cacheDir / mod.metadata.id / "data", ec);
+        if (!ec) {
+            fs::create_directories(mod.dir, ec);
         }
+        if (ec) {
+            fail_mod(mod, MOD_ERROR,
+                fmt::format("Failed to create script scratch directory: {}", ec.message()));
+        } else {
+            mod.dirUtf8 = borealis::io::fs_path_to_string(mod.dir);
+        }
+    }
+    if (load_native_if_present(mod) && mod.native) {
+        mod.manifestInfo = build_manifest_info(mod.native->parsed);
     }
 
     log::write(mod.metadata.id, LOG_LEVEL_INFO, "found '{}' v{} by {} ({})", mod.metadata.name,
-        mod.metadata.version, mod.metadata.author, io::fs_path_to_string(modPath.filename()));
+        mod.metadata.version, mod.metadata.author, data::abbreviated_path_string(modPath));
+    return &mod;
 }
 
 bool ModLoader::activate_mod(LoadedMod& mod) {
@@ -573,12 +210,12 @@ bool ModLoader::activate_mod(LoadedMod& mod) {
     mod.active = true;
 
     // Asset-only mods have no lifecycle beyond their overlay files.
-    if (!mod.native) {
+    if (!mod.native && !mod.runtime.has_value()) {
         mod.enabledApplied = true;
         return true;
     }
 
-    if (!mod.servicesRegistered) {
+    if (mod.native && !mod.servicesRegistered) {
         if (!register_static_service_exports(mod)) {
             log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to register service exports");
             deactivate_mod(mod);
@@ -587,28 +224,60 @@ bool ModLoader::activate_mod(LoadedMod& mod) {
         mod.servicesRegistered = true;
     }
 
-    if (!resolve_service_imports(mod)) {
+    if (mod.native && !resolve_service_imports(mod)) {
         log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to resolve service imports");
         deactivate_mod(mod);
         return false;
     }
 
-    *mod.native->contextSymbol = mod.context.get();
+    if (mod.native) {
+        svc::hook_resolve_mod_records(mod);
+        *mod.native->contextSymbol = mod.context.get();
+    } else {
+        auto& runtime = *mod.runtime;
+        const auto* record = svc::find_service(runtime.id.c_str(), runtime.major, runtime.minMinor);
+        if (record == nullptr) {
+            fail_mod(mod, MOD_UNAVAILABLE,
+                describe_missing_import(runtime.id.c_str(), runtime.major, runtime.minMinor));
+            deactivate_mod(mod);
+            return false;
+        }
 
-    log::write(mod.metadata.id, LOG_LEVEL_TRACE, "calling mod_initialize");
+        const auto* service = static_cast<const ModRuntimeService*>(record->service);
+        constexpr size_t kRequiredSize = offsetof(ModRuntimeService, deactivate) +
+                                         sizeof(((ModRuntimeService*)nullptr)->deactivate);
+        if (record->provider == nullptr || service == nullptr ||
+            service->header.struct_size < kRequiredSize || service->activate == nullptr ||
+            service->update == nullptr || service->deactivate == nullptr)
+        {
+            fail_mod(mod, MOD_UNAVAILABLE,
+                fmt::format("Runtime service {}@{} has an invalid lifecycle contract", runtime.id,
+                    runtime.major));
+            deactivate_mod(mod);
+            return false;
+        }
+        runtime.service = service;
+        runtime.providerContext = record->provider->context.get();
+    }
+
+    const char* initializeName = mod.native ? "mod_initialize" : "runtime activate";
+    log::write(mod.metadata.id, LOG_LEVEL_TRACE, "calling {}", initializeName);
     try {
         ModError error = MOD_ERROR_INIT;
-        const auto result = mod.native->fn_initialize(&error);
+        const auto result = mod.native ?
+                                mod.native->fn_initialize(&error) :
+                                mod.runtime->service->activate(
+                                    mod.runtime->providerContext, mod.context.get(), &error);
         if (result == MOD_OK && !mod.loadFailed) {
             mod.initialized = true;
-            log::write(mod.metadata.id, LOG_LEVEL_TRACE, "mod_initialize succeeded");
+            log::write(mod.metadata.id, LOG_LEVEL_TRACE, "{} succeeded", initializeName);
         } else if (result != MOD_OK && !mod.loadFailed) {
-            fail_mod(mod, result, lifecycle_error_message("mod_initialize", result, error));
+            fail_mod(mod, result, lifecycle_error_message(initializeName, result, error));
         }
     } catch (const std::exception& e) {
-        fail_mod(mod, MOD_ERROR, fmt::format("Exception in mod_initialize: {}", e.what()));
+        fail_mod(mod, MOD_ERROR, fmt::format("Exception in {}: {}", initializeName, e.what()));
     } catch (...) {
-        fail_mod(mod, MOD_ERROR, "Unknown exception in mod_initialize");
+        fail_mod(mod, MOD_ERROR, fmt::format("Unknown exception in {}", initializeName));
     }
 
     warn_unpublished_deferred_exports(mod);
@@ -624,21 +293,37 @@ bool ModLoader::activate_mod(LoadedMod& mod) {
 }
 
 void ModLoader::deactivate_mod(LoadedMod& mod) {
-    if (mod.initialized && mod.native && mod.native->fn_shutdown) {
-        log::write(mod.metadata.id, LOG_LEVEL_TRACE, "calling mod_shutdown");
+    svc::modules_mod_deactivating(mod);
+    if (mod.initialized && ((mod.native && mod.native->fn_shutdown) ||
+                               (mod.runtime.has_value() && mod.runtime->service != nullptr)))
+    {
+        const char* shutdownName = mod.native ? "mod_shutdown" : "runtime deactivate";
+        log::write(mod.metadata.id, LOG_LEVEL_TRACE, "calling {}", shutdownName);
         try {
             ModError error = MOD_ERROR_INIT;
-            const auto result = mod.native->fn_shutdown(&error);
+            const auto result = mod.native ?
+                                    mod.native->fn_shutdown(&error) :
+                                    mod.runtime->service->deactivate(
+                                        mod.runtime->providerContext, mod.context.get(), &error);
             if (result == MOD_OK) {
-                log::write(mod.metadata.id, LOG_LEVEL_TRACE, "mod_shutdown succeeded");
+                log::write(mod.metadata.id, LOG_LEVEL_TRACE, "{} succeeded", shutdownName);
             } else {
-                log::write(mod.metadata.id, LOG_LEVEL_ERROR, "mod_shutdown failed: {}",
-                    lifecycle_error_message("mod_shutdown", result, error));
+                log::write(mod.metadata.id, LOG_LEVEL_ERROR, "{} failed: {}", shutdownName,
+                    lifecycle_error_message(shutdownName, result, error));
             }
+        } catch (const std::exception& exception) {
+            log::write(
+                mod.metadata.id, LOG_LEVEL_ERROR, "{} threw: {}", shutdownName, exception.what());
         } catch (...) {
+            log::write(
+                mod.metadata.id, LOG_LEVEL_ERROR, "{} threw an unknown exception", shutdownName);
         }
     }
     mod.initialized = false;
+    if (mod.runtime.has_value()) {
+        mod.runtime->service = nullptr;
+        mod.runtime->providerContext = nullptr;
+    }
 
     if (mod.servicesRegistered) {
         svc::remove_services_for_provider(mod);
@@ -658,6 +343,9 @@ void ModLoader::init() {
     m_initialized = true;
 
     manifest::initialize();
+#if DUSK_HAS_PREPATCH
+    prepatch::initialize();
+#endif
 
     if (m_searchDirs.empty()) {
         Log.warn("no mod search directories configured; mod loading skipped");
@@ -668,53 +356,30 @@ void ModLoader::init() {
         m_cacheDir = m_searchDirs.front().path / ".cache";
     }
 
-    namespace fs = std::filesystem;
     std::error_code ec;
 
     // Stale libs from previous sessions (see load_native).
     fs::remove_all(m_cacheDir, ec);
 
-    for (size_t dirIndex = 0; dirIndex < m_searchDirs.size(); ++dirIndex) {
-        const auto& searchDir = m_searchDirs[dirIndex];
-
-        // --mods can point the user dir at the bundled dir; don't scan the same dir twice.
-        bool alreadyScanned = false;
-        for (size_t earlier = 0; earlier < dirIndex && !alreadyScanned; ++earlier) {
-            alreadyScanned = fs::equivalent(m_searchDirs[earlier].path, searchDir.path, ec);
-        }
-        if (alreadyScanned) {
+    const auto packages = scan_packages(m_searchDirs);
+    for (const auto& package : packages) {
+        const auto* selected = select_package(packages, package.metadata.id);
+        if (selected != &package) {
+            log::write(package.metadata.id, LOG_LEVEL_INFO, "{} v{} shadowed by {} v{}",
+                data::abbreviated_path_string(package.path), package.metadata.version,
+                data::abbreviated_path_string(selected->path), selected->metadata.version);
             continue;
         }
-
-        if (!fs::is_directory(searchDir.path)) {
-            if (dirIndex == 0) {
-                Log.info("mods directory '{}' not found", io::fs_path_to_string(searchDir.path));
-            } else {
-                Log.debug("mods directory '{}' not found", io::fs_path_to_string(searchDir.path));
-            }
-            continue;
-        }
-
-        std::vector<fs::directory_entry> entries;
-        for (auto& e : fs::directory_iterator(searchDir.path, ec)) {
-            if (e.is_directory() && std::filesystem::exists(e.path() / "mod.json")) {
-                entries.push_back(e);
-            } else if (e.is_regular_file() && e.path().extension() == ".dusk") {
-                entries.push_back(e);
-            }
-        }
-        std::sort(entries.begin(), entries.end(),
-            [](const fs::directory_entry& a, const fs::directory_entry& b) {
-                return a.path().filename() < b.path().filename();
-            });
-
-        for (auto& entry : entries) {
-            try_load_mod(entry.path(), entry.is_directory(), static_cast<uint32_t>(dirIndex));
+        if (auto* mod = try_load_mod(package.path, package.fromDirectory, package.searchDirIndex)) {
+            record_package_sources(*mod, packages);
         }
     }
 
     if (m_mods.empty()) {
+        init_services();
         Log.info("no mods found");
+        svc::modules_lifecycle_applied();
+        m_startupComplete = true;
         return;
     }
 
@@ -779,10 +444,19 @@ void ModLoader::init() {
     m_startupComplete = true;
 }
 
-LoadedMod* ModLoader::find_mod(std::string_view id) const {
-    for (auto& mod : mods()) {
-        if (mod.metadata.id == id) {
-            return &mod;
+LoadedMod* ModLoader::find_mod(std::string_view id) {
+    for (auto& mod : m_mods) {
+        if (mod->metadata.id == id) {
+            return mod.get();
+        }
+    }
+    return nullptr;
+}
+
+const LoadedMod* ModLoader::find_mod(std::string_view id) const {
+    for (const auto& mod : m_mods) {
+        if (mod->metadata.id == id) {
+            return mod.get();
         }
     }
     return nullptr;
@@ -800,8 +474,61 @@ void ModLoader::request_disable(std::string_view id) {
     }
 }
 
-void ModLoader::request_reload(std::string_view id) {
-    m_pendingRequests.push_back({std::string{id}, RequestKind::Reload});
+ModOperationHandle ModLoader::request_reload(std::string_view id) {
+    auto operation = std::make_shared<ModOperation>();
+    if (find_mod(id) != nullptr) {
+        m_pendingRequests.push_back(ReloadRequest{
+            .modId = std::string{id},
+            .operation = operation,
+        });
+    } else {
+        complete_operation(operation, false, "The mod is no longer installed");
+    }
+    return operation;
+}
+
+ModOperationHandle ModLoader::request_install(fs::path path) {
+    auto operation = std::make_shared<ModOperation>();
+    m_pendingRequests.push_back(InstallRequest{
+        .stagedPath = std::move(path),
+        .operation = operation,
+    });
+    return operation;
+}
+
+ModOperationHandle ModLoader::request_uninstall(std::string_view id) {
+    auto operation = std::make_shared<ModOperation>();
+    if (find_mod(id) != nullptr) {
+        m_pendingRequests.push_back(UninstallRequest{
+            .modId = std::string{id},
+            .operation = operation,
+        });
+    } else {
+        complete_operation(operation);
+    }
+    return operation;
+}
+
+ModOperationHandle ModLoader::request_reactivate(std::string_view id) {
+    auto operation = std::make_shared<ModOperation>();
+    m_pendingRequests.push_back(LifecycleRequest{
+        .modId = std::string{id},
+        .action = LifecycleAction::Reactivate,
+        .operation = operation,
+    });
+    return operation;
+}
+
+fs::path ModLoader::user_mods_dir() const {
+    return m_searchDirs.empty() ? fs::path{} : m_searchDirs.front().path;
+}
+
+bool ModLoader::can_uninstall(const LoadedMod& mod) const {
+    return mod.hasUserPackage;
+}
+
+bool ModLoader::can_update(const LoadedMod& mod) const {
+    return mod.searchDirIndex != 0 || (!mod.fromDirectory && can_uninstall(mod));
 }
 
 void ModLoader::notify_mod_failure(LoadedMod& mod, bool firstFailure) {
@@ -812,7 +539,10 @@ void ModLoader::notify_mod_failure(LoadedMod& mod, bool firstFailure) {
     if (!m_startupComplete) {
         return;
     }
-    m_pendingRequests.push_back({mod.metadata.id, RequestKind::Disable});
+    m_pendingRequests.emplace_back(LifecycleRequest{
+        .modId = mod.metadata.id,
+        .action = LifecycleAction::Disable,
+    });
 }
 
 void ModLoader::flush_toasts() {
@@ -845,7 +575,7 @@ void ModLoader::flush_toasts() {
     ui::push_toast(std::move(toast));
 }
 
-std::vector<LoadedMod*> ModLoader::collect_lifecycle_set(LoadedMod& target) {
+std::vector<LoadedMod*> ModLoader::collect_lifecycle_set(LoadedMod& target) const {
     std::vector included{&target};
     std::vector pending{&target};
     while (!pending.empty()) {
@@ -874,64 +604,47 @@ std::vector<LoadedMod*> ModLoader::collect_lifecycle_set(LoadedMod& target) {
     return ordered;
 }
 
-bool ModLoader::ensure_native_loaded(LoadedMod& mod) {
-    if (mod.native || mod.nativeStatus == NativeModStatus::None) {
-        return true;
-    }
-
-    const auto [dllEntry, anyLibs] = locate_dll_in_bundle(*mod.bundle);
-    if (!anyLibs && !(mod.inPlace && !external_native_lib_path(mod).empty())) {
-        mod.nativeStatus = NativeModStatus::None;
-        return true;
-    }
-
-    mod.nativeStatus = NativeModStatus::Unknown;
-    load_native(mod, dllEntry);
-    if (mod.nativeStatus != NativeModStatus::Loaded) {
-        fail_mod(mod, MOD_ERROR, native_status_message(mod.nativeStatus));
-        return false;
-    }
-    return true;
-}
-
 bool ModLoader::reload_bundle(LoadedMod& mod) {
-    namespace fs = std::filesystem;
-    log::write(mod.metadata.id, LOG_LEVEL_INFO, "reloading from {}", mod.modPath);
+    log::write(mod.metadata.id, LOG_LEVEL_INFO, "reloading from {}",
+        data::abbreviated_path_string(mod.modPath));
 
     std::shared_ptr<ModBundle> newBundle;
-    ModMetadata newMetadata;
+    LoadedManifest newManifest;
     try {
         std::error_code ec;
         newBundle = load_bundle(mod.modPath, fs::is_directory(mod.modPath, ec));
-        newMetadata = load_metadata(mod.modPath, *newBundle);
+        newManifest = load_manifest(mod.modPath, *newBundle);
     } catch (const std::exception& e) {
         fail_mod(mod, MOD_ERROR, fmt::format("Reload failed: {}", e.what()));
         return false;
     }
 
-    if (newMetadata.id != mod.metadata.id) {
+    if (newManifest.metadata.id != mod.metadata.id) {
         fail_mod(mod, MOD_CONFLICT,
-            fmt::format("Mod ID changed on reload ('{}'); restart required", newMetadata.id));
+            fmt::format(
+                "Mod ID changed on reload ('{}'); restart required", newManifest.metadata.id));
         return false;
     }
 
-    mod.metadata = std::move(newMetadata);
+    mod.metadata = std::move(newManifest.metadata);
+    mod.runtime = std::move(newManifest.runtime);
     // In-flight readers of the old bundle keep it alive through their shared_ptr.
     mod.bundle = std::move(newBundle);
+    mod.fileIdentity = file_identity(mod.modPath);
     mod.loadFailed = false;
     mod.failureReason.clear();
 
     ModManifestInfo newInfo;
-    if (const auto [dllEntry, anyLibs] = locate_dll_in_bundle(*mod.bundle); anyLibs) {
-        mod.nativeStatus = NativeModStatus::Unknown;
-        load_native(mod, dllEntry);
-        if (mod.nativeStatus != NativeModStatus::Loaded) {
-            fail_mod(mod, MOD_ERROR, native_status_message(mod.nativeStatus));
-            return false;
-        }
-        newInfo = build_manifest_info(*mod.native->manifest);
+    if (mod.runtime.has_value()) {
+        const auto& runtime = *mod.runtime;
+        newInfo.imports.push_back({runtime.id, runtime.major, runtime.minMinor, true});
+    }
+    if (!load_native_if_present(mod)) {
+        return false;
+    }
+    if (mod.native) {
+        newInfo = build_manifest_info(mod.native->parsed);
     } else {
-        mod.nativeStatus = NativeModStatus::None;
         ++mod.cacheGeneration;
     }
 
@@ -947,7 +660,48 @@ bool ModLoader::reload_bundle(LoadedMod& mod) {
     return true;
 }
 
-void ModLoader::apply_lifecycle_change(LoadedMod& target, const bool reload) {
+void ModLoader::resume_lifecycle_set(const std::vector<LoadedMod*>& affected) {
+    for (auto* mod : affected) {
+        if (mod->active || mod->loadFailed || !mod->cvarIsEnabled->getValue()) {
+            continue;
+        }
+        if (!ensure_native_loaded(*mod)) {
+            continue;
+        }
+        if (mod->native && !mod->servicesRegistered) {
+            if (register_static_service_exports(*mod)) {
+                mod->servicesRegistered = true;
+            } else {
+                log::write(mod->metadata.id, LOG_LEVEL_ERROR, "failed to register service exports");
+                deactivate_mod(*mod);
+            }
+        }
+    }
+
+    for (auto* mod : affected) {
+        if (mod->active || mod->loadFailed || !mod->cvarIsEnabled->getValue()) {
+            continue;
+        }
+        if (!required_deps_active(*mod)) {
+            mod->suspendedByProvider = true;
+            log::write(
+                mod->metadata.id, LOG_LEVEL_INFO, "suspended: a required provider is disabled");
+            continue;
+        }
+        mod->suspendedByProvider = false;
+        activate_mod(*mod);
+    }
+
+    for (auto* mod : affected) {
+        if (!mod->active && mod->servicesRegistered) {
+            svc::remove_services_for_provider(*mod);
+            mod->servicesRegistered = false;
+        }
+    }
+}
+
+void ModLoader::apply_lifecycle_change(
+    LoadedMod& target, const bool reload, const PackageCandidate* replacement) {
     auto affected = collect_lifecycle_set(target);
 
     // Dependents first (reverse init order), like shutdown.
@@ -967,6 +721,17 @@ void ModLoader::apply_lifecycle_change(LoadedMod& target, const bool reload) {
         }
     }
 
+    if (replacement != nullptr) {
+        target.modPath = replacement->path;
+        target.searchDirIndex = replacement->searchDirIndex;
+        target.fromDirectory = replacement->fromDirectory;
+        target.nativeInPlace =
+            replacement->fromDirectory && m_searchDirs[replacement->searchDirIndex].inPlaceNative;
+        std::stable_sort(m_mods.begin(), m_mods.end(),
+            [](const auto& a, const auto& b) { return a->searchDirIndex > b->searchDirIndex; });
+        loader::sort_mods(m_mods);
+    }
+
     if (reload) {
         // On failure the target is failed and stays down; dependents get resume attempts below
         // and suspend against the failed provider where required.
@@ -984,49 +749,7 @@ void ModLoader::apply_lifecycle_change(LoadedMod& target, const bool reload) {
         affected = std::move(reordered);
     }
 
-    // Mirror startup: publish every candidate's static exports before any of them initialize,
-    // so importers within the set resolve providers regardless of initialization order
-    // (optional cycles rely on this).
-    for (auto* mod : affected) {
-        if (mod->active || mod->loadFailed || !mod->cvarIsEnabled->getValue()) {
-            continue;
-        }
-        if (!ensure_native_loaded(*mod)) {
-            continue;
-        }
-        if (mod->native && !mod->servicesRegistered) {
-            if (register_static_service_exports(*mod)) {
-                mod->servicesRegistered = true;
-            } else {
-                log::write(
-                    mod->metadata.id, LOG_LEVEL_ERROR, "failed to register service exports");
-                deactivate_mod(*mod);
-            }
-        }
-    }
-
-    // Providers first (init order). The target is naturally first among the affected mods.
-    for (auto* mod : affected) {
-        if (mod->active || mod->loadFailed || !mod->cvarIsEnabled->getValue()) {
-            continue;
-        }
-        if (!required_deps_active(*mod)) {
-            mod->suspendedByProvider = true;
-            log::write(
-                mod->metadata.id, LOG_LEVEL_INFO, "suspended: a required provider is disabled");
-            continue;
-        }
-        mod->suspendedByProvider = false;
-        activate_mod(*mod);
-    }
-
-    // Mods that stayed down must not leave their exports resolvable.
-    for (auto* mod : affected) {
-        if (!mod->active && mod->servicesRegistered) {
-            svc::remove_services_for_provider(*mod);
-            mod->servicesRegistered = false;
-        }
-    }
+    resume_lifecycle_set(affected);
 }
 
 void ModLoader::on_enabled_changed(LoadedMod& mod) {
@@ -1040,13 +763,325 @@ void ModLoader::on_enabled_changed(LoadedMod& mod) {
     }
     if (mod.suspendedByProvider) {
         if (!mod.cvarIsEnabled->getValue()) {
-            // The user disabled a suspended mod; stop waiting for its providers.
             mod.suspendedByProvider = false;
         }
         return;
     }
-    m_pendingRequests.push_back({mod.metadata.id,
-        mod.cvarIsEnabled->getValue() ? RequestKind::Enable : RequestKind::Disable});
+    m_pendingRequests.push_back(LifecycleRequest{
+        .modId = mod.metadata.id,
+        .action =
+            mod.cvarIsEnabled->getValue() ? LifecycleAction::Enable : LifecycleAction::Disable,
+    });
+}
+
+void ModLoader::forget_mod(LoadedMod& mod) {
+    auto affected = collect_lifecycle_set(mod);
+    std::vector<LoadedMod*> blocked;
+    std::vector<LoadedMod*> pending{&mod};
+    while (!pending.empty()) {
+        auto* provider = pending.back();
+        pending.pop_back();
+        for (const auto& edge : provider->dependents) {
+            if (!edge.required || edge.mod == nullptr ||
+                std::ranges::find(blocked, edge.mod) != blocked.end())
+            {
+                continue;
+            }
+            blocked.push_back(edge.mod);
+            pending.push_back(edge.mod);
+        }
+    }
+
+    for (auto* affectedMod : affected | std::views::reverse) {
+        const bool wasActive = affectedMod->active;
+        if (affectedMod->active || affectedMod->initialized || affectedMod->native != nullptr) {
+            log::write(affectedMod->metadata.id, LOG_LEVEL_INFO, "deactivating mod");
+            deactivate_mod(*affectedMod);
+        }
+        if (affectedMod != &mod && wasActive) {
+            affectedMod->suspendedByProvider = true;
+        }
+    }
+
+    const std::string modId = mod.metadata.id;
+    auto* removedMod = &mod;
+    if (mod.enabledSubscription != 0) {
+        config::unsubscribe(mod.enabledSubscription);
+        mod.enabledSubscription = 0;
+    }
+    unregister(*mod.cvarIsEnabled);
+
+    std::vector<LoadedMod*> remaining;
+    remaining.reserve(affected.size());
+    for (auto* affectedMod : affected) {
+        if (affectedMod != &mod) {
+            remaining.push_back(affectedMod);
+        }
+    }
+    std::erase_if(
+        m_mods, [removedMod](const auto& candidate) { return candidate.get() == removedMod; });
+    loader::sort_mods(m_mods);
+
+    std::vector<LoadedMod*> resumable;
+    for (auto* affectedMod : remaining) {
+        const bool needsRemovedProvider = std::ranges::find(blocked, affectedMod) != blocked.end();
+        affectedMod->suspendedByProvider = needsRemovedProvider;
+        if (needsRemovedProvider) {
+            log::write(affectedMod->metadata.id, LOG_LEVEL_INFO,
+                "suspended: required provider '{}' was removed", modId);
+        } else {
+            resumable.push_back(affectedMod);
+        }
+    }
+    resume_lifecycle_set(resumable);
+
+    ++m_generation;
+    log::write(modId, LOG_LEVEL_INFO, "forgot removed package");
+}
+
+ModLoader::OperationResult ModLoader::load_runtime_mod(const fs::path& requestedPath) {
+    const auto path = fs::absolute(requestedPath).lexically_normal();
+    std::error_code error;
+    const auto status = fs::status(path, error);
+    if (error || !fs::exists(status)) {
+        return {
+            .success = false,
+            .message = error ? fmt::format("Could not inspect the package: {}", error.message()) :
+                               "The package was not found",
+        };
+    }
+
+    const bool fromDir = fs::is_directory(status);
+    std::unique_ptr<ModBundle> bundle;
+    std::optional<ModMetadata> metadata;
+    try {
+        bundle = load_bundle(path, fromDir);
+        metadata = load_manifest(path, *bundle).metadata;
+    } catch (const std::exception& exception) {
+        return {
+            .success = false,
+            .message = fmt::format("Invalid mod package: {}", exception.what()),
+        };
+    }
+    if (const auto* duplicate = find_mod(metadata->id)) {
+        return {
+            .success = false,
+            .message = fmt::format("A mod with this ID is already loaded from {}",
+                data::abbreviated_path_string(duplicate->modPath)),
+        };
+    }
+    auto* mod = try_load_mod(path, fromDir, 0, std::move(bundle));
+    if (mod == nullptr) {
+        return {
+            .success = false,
+            .message = "The mod could not be loaded",
+        };
+    }
+
+    mod->enabledSubscription = Register(
+        *mod->cvarIsEnabled, [this, mod](const bool&, const bool&) { on_enabled_changed(*mod); });
+    loader::sort_mods(m_mods);
+    if (!mod->cvarIsEnabled->getValue()) {
+        mod->active = false;
+        mod->suspendedByProvider = false;
+        log::write(mod->metadata.id, LOG_LEVEL_INFO, "installed disabled by config");
+    } else if (!mod->loadFailed) {
+        mod->active = false;
+        apply_lifecycle_change(*mod, false);
+    }
+    ++m_generation;
+    log::write(mod->metadata.id, LOG_LEVEL_INFO, "installed at runtime");
+    return runtime_result(*mod);
+}
+
+ModLoader::OperationResult ModLoader::reload_runtime_mod(
+    LoadedMod& mod, const PackageCandidate* replacement) {
+    if (mod.nativeInPlace && replacement == nullptr) {
+        return {
+            .success = false,
+            .message = "An in-place native library cannot be reloaded",
+            .mod = &mod,
+        };
+    }
+    apply_lifecycle_change(mod, true, replacement);
+    ++m_generation;
+    return runtime_result(mod);
+}
+
+ModLoader::OperationResult ModLoader::uninstall_runtime_mod(LoadedMod& mod) {
+    std::vector<PackageCandidate> packages;
+    try {
+        packages = scan_packages(m_searchDirs);
+    } catch (const std::exception& exception) {
+        return {.success = false, .message = exception.what()};
+    }
+    record_package_sources(mod, packages);
+    if (!can_uninstall(mod)) {
+        return {.success = false, .message = "No installed package to remove"};
+    }
+
+    std::string removalError;
+    std::erase_if(packages, [&](const auto& package) {
+        if (package.metadata.id != mod.metadata.id || package.searchDirIndex != 0 ||
+            package.fromDirectory || package.symlink)
+        {
+            return false;
+        }
+        std::error_code error;
+        fs::remove(package.path, error);
+        if (error) {
+            removalError = fmt::format("Could not remove {}: {}",
+                data::abbreviated_path_string(package.path), error.message());
+        }
+        return !error;
+    });
+
+    OperationResult result;
+    if (const auto* selected = select_package(packages, mod.metadata.id)) {
+        if (selected->path != mod.modPath) {
+            result = reload_runtime_mod(mod, selected);
+        } else {
+            result.mod = &mod;
+            ++m_generation;
+        }
+        record_package_sources(mod, packages);
+    } else {
+        forget_mod(mod);
+    }
+    if (!removalError.empty()) {
+        result.success = false;
+        result.message = std::move(removalError);
+    }
+    return result;
+}
+
+ModLoader::OperationResult ModLoader::runtime_result(LoadedMod& mod) {
+    if (mod.loadFailed) {
+        return {
+            .success = false,
+            .message = mod.failureReason.empty() ? "Mod failed to activate" : mod.failureReason,
+            .mod = &mod,
+        };
+    }
+    if (mod.cvarIsEnabled->getValue() && !mod.active) {
+        return {
+            .success = false,
+            .message = "A required provider is unavailable",
+            .mod = &mod,
+        };
+    }
+    if (!mod.cvarIsEnabled->getValue()) {
+        return {
+            .message = "Installed, disabled by config",
+            .mod = &mod,
+        };
+    }
+    return {.mod = &mod};
+}
+
+ModLoader::OperationResult ModLoader::install_staged(const fs::path& requestedPath) {
+    if (m_searchDirs.empty()) {
+        return {
+            .success = false,
+            .message = "No writable mods directory is configured",
+        };
+    }
+    std::error_code error;
+    const auto userDir = fs::weakly_canonical(m_searchDirs.front().path, error);
+    if (error) {
+        return {
+            .success = false,
+            .message =
+                fmt::format("Could not resolve the user mods directory: {}", error.message()),
+        };
+    }
+    const auto stagingDir = userDir / ".staging";
+    const auto path = fs::weakly_canonical(requestedPath, error);
+    const bool stagedName = path.extension() == ".part" && path.stem().extension() == ".dusk";
+    if (error || path.parent_path() != stagingDir || !stagedName ||
+        !fs::is_regular_file(path, error))
+    {
+        Log.error("refusing staged install from {}", data::abbreviated_path_string(requestedPath));
+        return {
+            .success = false,
+            .message = "The package is not in the mod staging directory",
+        };
+    }
+
+    ModMetadata metadata;
+    std::string validationError;
+    if (!inspect_mod_bundle(path, metadata, validationError)) {
+        return {
+            .success = false,
+            .message = fmt::format("Invalid mod package: {}", validationError),
+        };
+    }
+
+    const auto destination = userDir / fmt::format("{}.dusk", safe_filename(metadata.id));
+    auto* installed = find_mod(metadata.id);
+    if (installed != nullptr && !can_update(*installed)) {
+        return {
+            .success = false,
+            .message = "Cannot install mod over a development directory",
+        };
+    }
+
+    for (const auto& mod : mods()) {
+        if (mod.metadata.id != metadata.id && fs::equivalent(mod.modPath, destination, error)) {
+            return {
+                .success = false,
+                .message = "The destination filename belongs to a different mod",
+            };
+        }
+    }
+    error.clear();
+
+    if (!borealis::update::parse_version(metadata.version)) {
+        return {.success = false, .message = "The package version is invalid"};
+    }
+    std::vector<PackageCandidate> packages;
+    try {
+        packages = scan_packages(m_searchDirs);
+    } catch (const std::exception& exception) {
+        return {.success = false, .message = exception.what()};
+    }
+    if (const auto* selected = select_package(packages, metadata.id);
+        selected && compare_package_versions(metadata.version, selected->metadata.version) < 0)
+    {
+        return {
+            .success = false,
+            .message = fmt::format(
+                "A newer version ({}) is already installed", selected->metadata.version),
+        };
+    }
+
+    const auto packageResult = install_package(path, destination, metadata.id);
+    if (!packageResult.replaced) {
+        return {.success = false, .message = packageResult.error};
+    }
+    std::erase_if(packages, [&](const auto& package) {
+        if (package.metadata.id != metadata.id || package.searchDirIndex != 0 ||
+            package.fromDirectory)
+        {
+            return false;
+        }
+        std::error_code statusError;
+        return fs::equivalent(package.path, destination, statusError) ||
+               !fs::exists(package.path, statusError);
+    });
+    packages.push_back({.path = destination, .metadata = metadata});
+    const auto* selected = select_package(packages, metadata.id);
+    auto result = installed != nullptr ? reload_runtime_mod(*installed, selected) :
+                                         load_runtime_mod(selected->path);
+    if (result.mod != nullptr) {
+        record_package_sources(*result.mod, packages);
+    }
+
+    if (result.success && !packageResult.error.empty()) {
+        result.success = false;
+        result.message = packageResult.error;
+    }
+    return result;
 }
 
 void ModLoader::apply_pending_requests() {
@@ -1057,16 +1092,90 @@ void ModLoader::apply_pending_requests() {
         return;
     }
 
-    // Coalesce per mod, last request wins. Failures during apply re-enqueue for next tick.
     const auto requests = std::exchange(m_pendingRequests, {});
-    std::vector<Request> coalesced;
+    std::vector<LifecycleRequest> coalesced;
     for (const auto& request : requests) {
-        const auto existing = std::ranges::find_if(
-            coalesced, [&](const Request& r) { return r.modId == request.modId; });
+        if (const auto* install = std::get_if<InstallRequest>(&request)) {
+            auto result = install_staged(install->stagedPath);
+            if (result.success && result.mod != nullptr) {
+                const auto& metadata = result.mod->metadata;
+                const std::string iconRml =
+                    metadata.iconPath.empty() ?
+                        std::string{} :
+                        fmt::format(R"(<img src="{}" />)",
+                            ui::escape(ui::mod_image_source(*result.mod, metadata.iconPath)));
+                ui::push_toast({
+                    .type = "mod-installed",
+                    .title = "Mod installed",
+                    .content = fmt::format(
+                        R"(<row><mod-icon>{}</mod-icon><mod-info><mod-name><b>{}</b><small class="version">v{}</small></mod-name><small>{}</small></mod-info></row>)",
+                        iconRml, ui::escape(metadata.name), ui::escape(metadata.version),
+                        ui::escape(metadata.author)),
+                    .duration = std::chrono::seconds{4},
+                });
+            } else if (!result.success && result.mod == nullptr) {
+                ui::push_toast({
+                    .type = "warning",
+                    .title = "Mod install failed",
+                    .content =
+                        result.message.empty() ? "The loader rejected the package" : result.message,
+                    .duration = std::chrono::seconds{6},
+                });
+            }
+            if (!result.success && !m_searchDirs.empty()) {
+                // request_install owns only files under the configured staging directory.
+                std::error_code error;
+                const auto userDir = fs::weakly_canonical(m_searchDirs.front().path, error);
+                if (!error) {
+                    const auto stagedPath = fs::weakly_canonical(install->stagedPath, error);
+                    if (!error && stagedPath.parent_path() == userDir / ".staging") {
+                        fs::remove(stagedPath, error);
+                    }
+                }
+            }
+            complete_operation(install->operation, result.success, std::move(result.message));
+            continue;
+        }
+        if (const auto* reload = std::get_if<ReloadRequest>(&request)) {
+            auto* mod = find_mod(reload->modId);
+            if (mod == nullptr) {
+                complete_operation(reload->operation, false, "The mod is no longer installed");
+                continue;
+            }
+            auto result = reload_runtime_mod(*mod);
+            complete_operation(reload->operation, result.success, std::move(result.message));
+            continue;
+        }
+        if (const auto* uninstall = std::get_if<UninstallRequest>(&request)) {
+            auto* mod = find_mod(uninstall->modId);
+            if (mod == nullptr) {
+                complete_operation(uninstall->operation);
+                continue;
+            }
+            const auto removedName = mod->metadata.name;
+            const auto removedId = mod->metadata.id;
+            auto result = uninstall_runtime_mod(*mod);
+            if (result.success) {
+                queue::remove_by_mod_id(removedId);
+                ui::push_toast({
+                    .title = result.mod != nullptr ? "User update removed" : "Mod uninstalled",
+                    .content = removedName,
+                    .duration = std::chrono::seconds{2},
+                });
+            }
+            complete_operation(uninstall->operation, result.success, std::move(result.message));
+            continue;
+        }
+
+        const auto& lifecycle = std::get<LifecycleRequest>(request);
+        const auto existing =
+            std::ranges::find(coalesced, lifecycle.modId, &LifecycleRequest::modId);
         if (existing != coalesced.end()) {
-            existing->kind = request.kind;
+            complete_operation(
+                existing->operation, false, "Superseded by a newer lifecycle request");
+            *existing = lifecycle;
         } else {
-            coalesced.push_back(request);
+            coalesced.push_back(lifecycle);
         }
     }
 
@@ -1074,19 +1183,36 @@ void ModLoader::apply_pending_requests() {
         auto* mod = find_mod(request.modId);
         if (mod == nullptr) {
             Log.warn("lifecycle request for unknown mod '{}'", request.modId);
+            complete_operation(request.operation, false, "The mod is no longer installed");
             continue;
         }
-        if (request.kind == RequestKind::Reload && mod->inPlace) {
-            log::write(mod->metadata.id, LOG_LEVEL_WARN, "is a built-in mod and can't be reloaded");
+        if (request.action == LifecycleAction::Enable && mod->enabledApplied) {
             continue;
         }
-        if (request.kind == RequestKind::Enable && mod->enabledApplied) {
+        if (request.action == LifecycleAction::Disable && !mod->enabledApplied && !mod->active) {
             continue;
         }
-        if (request.kind == RequestKind::Disable && !mod->enabledApplied && !mod->active) {
-            continue;
+
+        if (request.action == LifecycleAction::Reactivate) {
+            mod->loadFailed = false;
+            mod->failureReason.clear();
+            mod->suspendedByProvider = false;
+            if (!mod->cvarIsEnabled->getValue()) {
+                mod->cvarIsEnabled->setValue(true);
+            }
+        }
+        apply_lifecycle_change(*mod, false);
+
+        if (request.action == LifecycleAction::Reactivate) {
+            std::string error;
+            if (mod->loadFailed) {
+                error =
+                    mod->failureReason.empty() ? "The mod failed to activate" : mod->failureReason;
+            } else if (mod->cvarIsEnabled->getValue() && !mod->active) {
+                error = "A required provider is unavailable";
+            }
+            complete_operation(request.operation, error.empty(), std::move(error));
         }
-        apply_lifecycle_change(*mod, request.kind == RequestKind::Reload);
     }
 
     svc::modules_lifecycle_applied();
@@ -1100,17 +1226,23 @@ void ModLoader::tick() {
     apply_pending_requests();
 
     for (auto& mod : mods()) {
-        if (!mod.active || !mod.native) {
+        if (!mod.active || (!mod.native && !mod.runtime.has_value())) {
             continue;
         }
         try {
             ModError error = MOD_ERROR_INIT;
-            const auto result = mod.native->fn_update(&error);
+            const bool delegated = !mod.native;
+            const auto result = delegated ?
+                                    mod.runtime->service->update(
+                                        mod.runtime->providerContext, mod.context.get(), &error) :
+                                    mod.native->fn_update(&error);
             if (result != MOD_OK) {
-                fail_mod(mod, result, lifecycle_error_message("mod_update", result, error));
+                fail_mod(mod, result,
+                    lifecycle_error_message(
+                        delegated ? "runtime update" : "mod_update", result, error));
             }
         } catch (const std::exception& e) {
-            fail_mod(mod, MOD_ERROR, fmt::format("Exception in mod_update: {}", e.what()));
+            fail_mod(mod, MOD_ERROR, fmt::format("Exception in mod update: {}", e.what()));
         } catch (...) {
             fail_mod(mod, MOD_ERROR, "Unknown exception in mod_update");
         }
diff --git a/src/dusk/mods/loader/loader.hpp b/src/dusk/mods/loader/loader.hpp
index 6b9fd39232..d5708c9be1 100644
--- a/src/dusk/mods/loader/loader.hpp
+++ b/src/dusk/mods/loader/loader.hpp
@@ -1,10 +1,9 @@
 #pragma once
 
 #include <filesystem>
-#include <mutex>
 #include <string_view>
-#include "miniz.h"
 
+#include "dusk/archive.hpp"
 #include "dusk/mod_loader.hpp"
 
 namespace dusk::mods {
@@ -28,17 +27,14 @@ public:
 
 class ModBundleZip final : public ModBundle {
 public:
-    explicit ModBundleZip(std::vector<u8>&& data);
-    ~ModBundleZip() override;
+    explicit ModBundleZip(const std::filesystem::path& path);
+    ~ModBundleZip() override = default;
     std::vector<u8> readFile(const std::string& fileName) override;
     std::vector<std::string> getFileNames() override;
     size_t getFileSize(const std::string& fileName) override;
 
 private:
-    std::vector<uint8_t> zip_data;
-    mz_zip_archive res_zip{};
-    bool res_zip_open = false;
-    std::mutex m_mutex;
+    archive::ZipArchive m_archive;
 };
 
 class ModBundleDisk final : public ModBundle {
diff --git a/src/dusk/mods/loader/manifest.cpp b/src/dusk/mods/loader/manifest.cpp
new file mode 100644
index 0000000000..8c8243bd0a
--- /dev/null
+++ b/src/dusk/mods/loader/manifest.cpp
@@ -0,0 +1,203 @@
+#include "manifest.hpp"
+
+#include "loader.hpp"
+#include "natives.hpp"
+#include "packages.hpp"
+
+#include "dusk/mods/log_buffer.hpp"
+
+#include <borealis/io.hpp>
+#include <fmt/format.h>
+#include <nlohmann/json.hpp>
+
+#include <algorithm>
+#include <charconv>
+#include <stdexcept>
+#include <utility>
+
+using namespace std::string_literals;
+namespace fs = std::filesystem;
+
+namespace dusk::mods {
+namespace {
+
+class InvalidModDataException : public std::runtime_error {
+public:
+    explicit InvalidModDataException(const std::string& msg) : runtime_error(msg) {}
+    explicit InvalidModDataException(const char* msg) : runtime_error(msg) {}
+};
+
+void validate_mod_id(std::string_view const str) {
+    if (str.empty()) {
+        throw InvalidModDataException("Missing ID value in mod metadata");
+    }
+
+    bool lastWasPeriod = false;
+    for (auto const chr : str) {
+        if (chr == '.') {
+            if (lastWasPeriod) {
+                throw InvalidModDataException("Cannot have two consecutive periods in mod ID");
+            }
+            lastWasPeriod = true;
+            continue;
+        }
+
+        lastWasPeriod = false;
+
+        if (chr == '_')
+            continue;
+
+        if (chr >= '0' && chr <= '9')
+            continue;
+
+        if (chr >= 'a' && chr <= 'z')
+            continue;
+
+        if (chr >= 'A' && chr <= 'Z')
+            continue;
+
+        throw InvalidModDataException(
+            fmt::format("Invalid character '{}' in mod ID. Valid characters are period, "
+                        "underscore, and alphanumerics.",
+                chr));
+    }
+}
+
+bool bundle_has_file(ModBundle& bundle, const std::string& path) {
+    try {
+        bundle.getFileSize(path);
+        return true;
+    } catch (const std::runtime_error&) {
+        return false;
+    }
+}
+
+std::string resolve_image_path(ModBundle& bundle, const std::string& modId, std::string_view key,
+    const std::string& manifestPath, const std::string& defaultPath) {
+    if (!manifestPath.empty()) {
+        if (!is_safe_resource_path(manifestPath)) {
+            log::write(
+                modId, LOG_LEVEL_WARN, "invalid {} path '{}' in mod.json", key, manifestPath);
+        } else if (!bundle_has_file(bundle, manifestPath)) {
+            log::write(
+                modId, LOG_LEVEL_WARN, "{} path '{}' not found in bundle", key, manifestPath);
+        } else {
+            return manifestPath;
+        }
+    }
+    if (bundle_has_file(bundle, defaultPath)) {
+        return defaultPath;
+    }
+    return {};
+}
+
+uint16_t parse_runtime_version_component(std::string_view text, std::string_view fieldName) {
+    uint32_t value = 0;
+    const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), value);
+    if (text.empty() || error != std::errc{} || end != text.data() + text.size() ||
+        value > UINT16_MAX)
+    {
+        throw InvalidModDataException(fmt::format("Invalid {} in runtime version pin", fieldName));
+    }
+    return static_cast<uint16_t>(value);
+}
+
+std::optional<DelegatedModRuntime> parse_runtime(const nlohmann::json& manifest) {
+    const auto field = manifest.find("runtime");
+    if (field == manifest.end()) {
+        return std::nullopt;
+    }
+    if (!field->is_string()) {
+        throw InvalidModDataException("runtime must be a string");
+    }
+
+    const std::string pin = field->get<std::string>();
+    const auto at = pin.rfind('@');
+    if (at == std::string::npos || at == 0 || at + 1 == pin.size() || pin.find('@') != at ||
+        at >= MOD_META_SERVICE_ID_SIZE)
+    {
+        throw InvalidModDataException(
+            "runtime must be a service id followed by @major or @major.minor");
+    }
+
+    const std::string_view version{pin.data() + at + 1, pin.size() - at - 1};
+    const auto dot = version.find('.');
+    if (dot != std::string_view::npos && version.find('.', dot + 1) != std::string_view::npos) {
+        throw InvalidModDataException("runtime version pin has too many components");
+    }
+
+    DelegatedModRuntime result;
+    result.id = pin.substr(0, at);
+    result.major = parse_runtime_version_component(
+        dot == std::string_view::npos ? version : version.substr(0, dot), "major version");
+    if (dot != std::string_view::npos) {
+        result.minMinor = parse_runtime_version_component(version.substr(dot + 1), "minor version");
+    }
+    return result;
+}
+
+}  // namespace
+
+LoadedManifest load_manifest(const std::filesystem::path& modPath, ModBundle& bundle) {
+    const auto metaJson = bundle.readFile("mod.json");
+    auto j = nlohmann::json::parse(metaJson);
+
+    std::string metaId = j.value("id", "");
+    std::string metaName = j.value("name", "");
+    std::string metaVersion = j.value("version", "");
+    std::string metaAuthor = j.value("author", "");
+    std::string metaDescription = j.value("description", "");
+    std::string metaIcon = j.value("icon", "");
+    std::string metaBanner = j.value("banner", "");
+
+    validate_mod_id(metaId);
+
+    if (metaName.empty()) {
+        metaName = borealis::io::fs_path_to_string(modPath.stem());
+    }
+    if (metaVersion.empty()) {
+        metaVersion = "?"s;
+    }
+    if (metaAuthor.empty()) {
+        metaAuthor = "unknown"s;
+    }
+
+    std::string iconPath = resolve_image_path(bundle, metaId, "icon", metaIcon, "res/icon.png"s);
+    std::string bannerPath =
+        resolve_image_path(bundle, metaId, "banner", metaBanner, "res/banner.png"s);
+
+    return LoadedManifest{
+        .metadata =
+            {
+                std::move(metaId),
+                std::move(metaName),
+                std::move(metaVersion),
+                std::move(metaAuthor),
+                std::move(metaDescription),
+                std::move(iconPath),
+                std::move(bannerPath),
+            },
+        .runtime = parse_runtime(j),
+    };
+}
+
+bool inspect_mod_bundle(
+    const fs::path& path, ModMetadata& metadata, std::string& error, bool* hasNative) noexcept {
+    try {
+        auto bundle = load_bundle(path, false);
+        metadata = load_manifest(path, *bundle).metadata;
+        if (hasNative != nullptr) {
+            *hasNative = std::ranges::any_of(bundle->getFileNames(),
+                [](const auto& name) { return has_native_library_extension(name); });
+        }
+        error.clear();
+        return true;
+    } catch (const std::exception& exception) {
+        error = exception.what();
+    } catch (...) {
+        error = "Unknown bundle validation error";
+    }
+    return false;
+}
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/manifest.hpp b/src/dusk/mods/loader/manifest.hpp
new file mode 100644
index 0000000000..e3eea70298
--- /dev/null
+++ b/src/dusk/mods/loader/manifest.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "dusk/mod_loader.hpp"
+
+namespace dusk::mods {
+
+struct LoadedManifest {
+    ModMetadata metadata;
+    std::optional<DelegatedModRuntime> runtime;
+};
+
+LoadedManifest load_manifest(const std::filesystem::path& modPath, ModBundle& bundle);
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/native_module.cpp b/src/dusk/mods/loader/native_module.cpp
index aa4a369fb0..0d4eb6a984 100644
--- a/src/dusk/mods/loader/native_module.cpp
+++ b/src/dusk/mods/loader/native_module.cpp
@@ -9,7 +9,8 @@
 namespace {
 #if defined(_WIN32)
 void* pl_dlopen(const std::filesystem::path& p) {
-    return LoadLibraryW(p.wstring().c_str());
+    return LoadLibraryExW(p.wstring().c_str(), nullptr,
+        LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS);
 }
 void* pl_dlsym(void* h, const char* name) {
     return reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(h), name));
@@ -30,11 +31,7 @@ std::string pl_dlerror() {
 #else
 #include <dlfcn.h>
 void* pl_dlopen(const std::filesystem::path& p) {
-    int flags = RTLD_LAZY | RTLD_LOCAL;
-#if defined(RTLD_DEEPBIND)
-    flags |= RTLD_DEEPBIND;
-#endif
-    return dlopen(p.c_str(), flags);
+    return dlopen(p.c_str(), RTLD_LAZY | RTLD_LOCAL);
 }
 void* pl_dlsym(void* h, const char* name) {
     return dlsym(h, name);
@@ -47,11 +44,10 @@ std::string pl_dlerror() {
     return e ? e : "(unknown error)";
 }
 #endif
-}
+}  // namespace
 
 namespace dusk::mods::loader {
-NativeModule::NativeModule() noexcept : handle(nullptr) {
-}
+NativeModule::NativeModule() noexcept : handle(nullptr) {}
 
 NativeModule::NativeModule(NativeModule&& other) noexcept {
     handle = other.handle;
diff --git a/src/dusk/mods/loader/native_module.hpp b/src/dusk/mods/loader/native_module.hpp
index ff2acf9632..2632496f96 100644
--- a/src/dusk/mods/loader/native_module.hpp
+++ b/src/dusk/mods/loader/native_module.hpp
@@ -22,8 +22,6 @@ public:
 
 #if defined(_WIN32)
     static constexpr auto LibraryExtension = ".dll";
-#elif defined(__APPLE__)
-    static constexpr auto LibraryExtension = ".dylib";
 #else
     static constexpr auto LibraryExtension = ".so";
 #endif
diff --git a/src/dusk/mods/loader/natives.cpp b/src/dusk/mods/loader/natives.cpp
new file mode 100644
index 0000000000..e3802f4b52
--- /dev/null
+++ b/src/dusk/mods/loader/natives.cpp
@@ -0,0 +1,620 @@
+#include "natives.hpp"
+
+#include "loader.hpp"
+#include "native_module.hpp"
+
+#include "dusk/data.hpp"
+#include "dusk/mods/log_buffer.hpp"
+#include "dusk/mods/svc/registry.hpp"
+
+#include <borealis/io.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <utility>
+#include <variant>
+
+using namespace std::string_view_literals;
+namespace fs = std::filesystem;
+
+#if defined(_WIN32)
+#if defined(_M_ARM64)
+static constexpr std::string_view k_nativePlatform = "windows-arm64"sv;
+#elif defined(_M_X64)
+static constexpr std::string_view k_nativePlatform = "windows-amd64"sv;
+#elif defined(_M_IX86)
+static constexpr std::string_view k_nativePlatform = "windows-x86"sv;
+#else
+static constexpr std::string_view k_nativePlatform = ""sv;
+#endif
+static constexpr std::string_view k_nativeLibName = "mod.dll"sv;
+#elif defined(__ANDROID__)
+#if defined(__aarch64__)
+static constexpr std::string_view k_nativePlatform = "android-aarch64"sv;
+#elif defined(__x86_64__)
+static constexpr std::string_view k_nativePlatform = "android-x86_64"sv;
+#else
+static constexpr std::string_view k_nativePlatform = ""sv;
+#endif
+static constexpr std::string_view k_nativeLibName = "mod.so"sv;
+#elif defined(__APPLE__)
+#include <TargetConditionals.h>
+#if TARGET_OS_IOS
+static constexpr std::string_view k_nativePlatform = "ios-arm64"sv;
+#elif TARGET_OS_TV
+static constexpr std::string_view k_nativePlatform = "tvos-arm64"sv;
+#elif defined(__aarch64__)
+static constexpr std::string_view k_nativePlatform = "macos-arm64"sv;
+#elif defined(__x86_64__)
+static constexpr std::string_view k_nativePlatform = "macos-x86_64"sv;
+#else
+static constexpr std::string_view k_nativePlatform = ""sv;
+#endif
+static constexpr std::string_view k_nativeLibName = "mod.so"sv;
+#elif defined(__linux__)
+#if defined(__aarch64__)
+static constexpr std::string_view k_nativePlatform = "linux-aarch64"sv;
+#elif defined(__x86_64__)
+static constexpr std::string_view k_nativePlatform = "linux-x86_64"sv;
+#elif defined(__i386__)
+static constexpr std::string_view k_nativePlatform = "linux-x86"sv;
+#else
+static constexpr std::string_view k_nativePlatform = ""sv;
+#endif
+static constexpr std::string_view k_nativeLibName = "mod.so"sv;
+#else
+static constexpr std::string_view k_nativePlatform = ""sv;
+static constexpr std::string_view k_nativeLibName = ""sv;
+#endif
+
+namespace dusk::mods {
+
+bool has_native_library_extension(std::string_view name) {
+    const auto endsWith = [name](std::string_view extension) {
+        if (name.size() < extension.size()) {
+            return false;
+        }
+        const auto suffix = name.substr(name.size() - extension.size());
+        return std::ranges::equal(suffix, extension, [](char lhs, char rhs) {
+            const auto lower = [](char value) {
+                return value >= 'A' && value <= 'Z' ? static_cast<char>(value + ('a' - 'A')) :
+                                                      value;
+            };
+            return lower(lhs) == lower(rhs);
+        });
+    };
+    return endsWith(".dll"sv) || endsWith(".so"sv) || endsWith(".dylib"sv);
+}
+
+namespace {
+
+constexpr std::string_view k_nativeLibDir = "lib/"sv;
+
+class DirectoryRollback {
+public:
+    ~DirectoryRollback() {
+        if (!mPath.empty()) {
+            std::error_code ec;
+            fs::remove_all(mPath, ec);
+        }
+    }
+
+    void set_path(fs::path path) { mPath = std::move(path); }
+    void release() { mPath.clear(); }
+
+private:
+    fs::path mPath;
+};
+
+struct NativeRuntimeLocation {
+    std::string entry;
+    std::vector<std::string> runtimeEntries;
+    bool anyLibs = false;
+};
+
+struct NativeLocateFailure {
+    NativeModStatus status;
+    std::string logMessage;
+};
+
+using NativeLocateResult = std::variant<NativeRuntimeLocation, NativeLocateFailure>;
+
+NativeLocateResult locate_native_runtime(ModBundle& bundle) {
+    NativeRuntimeLocation result;
+    const std::string platformPrefix = fmt::format("{}{}/", k_nativeLibDir, k_nativePlatform);
+    const std::string nativeEntry = platformPrefix + std::string{k_nativeLibName};
+    for (const auto& name : bundle.getFileNames()) {
+        if (name.find('/') == std::string::npos && has_native_library_extension(name)) {
+            return NativeLocateFailure{
+                NativeModStatus::InvalidBundle,
+                fmt::format(
+                    "native library '{}' found at the root (natives go in /lib/{{platform}})",
+                    name),
+            };
+        }
+        if (!name.starts_with(k_nativeLibDir)) {
+            continue;
+        }
+
+        const std::string_view libPath{
+            name.data() + k_nativeLibDir.size(), name.size() - k_nativeLibDir.size()};
+        const auto platformEnd = libPath.find('/');
+        if (platformEnd != std::string_view::npos) {
+            const auto entryName = libPath.substr(platformEnd + 1);
+            if (entryName.find('/') == std::string_view::npos &&
+                (entryName == "mod.dll"sv || entryName == "mod.so"sv))
+            {
+                result.anyLibs = true;
+            }
+        }
+
+        if (!k_nativePlatform.empty() && name.starts_with(platformPrefix)) {
+            const std::string_view relativeName{
+                name.data() + platformPrefix.size(), name.size() - platformPrefix.size()};
+            if (!is_safe_resource_path(relativeName)) {
+                continue;
+            }
+            result.runtimeEntries.push_back(name);
+        }
+        if (name == nativeEntry) {
+            result.entry = name;
+        }
+    }
+    std::ranges::sort(result.runtimeEntries);
+    result.runtimeEntries.erase(
+        std::unique(result.runtimeEntries.begin(), result.runtimeEntries.end()),
+        result.runtimeEntries.end());
+    return result;
+}
+
+// True if the first `capacity` bytes of `str` contain a NUL.
+bool terminated_within(const char* str, size_t capacity) {
+    return std::memchr(str, '\0', capacity) != nullptr;
+}
+
+bool parse_meta(NativeMod& native, LoadedMod& mod) {
+    const ModMeta* meta = native.meta;
+    if (meta->struct_size < sizeof(ModMeta)) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "mod_meta descriptor has invalid size {}",
+            meta->struct_size);
+        mod.nativeStatus = NativeModStatus::InvalidMetadata;
+        return false;
+    }
+    const auto* cursor = static_cast<const uint8_t*>(meta->records_begin);
+    const auto* end = static_cast<const uint8_t*>(meta->records_end);
+    if (cursor == nullptr || end == nullptr || cursor > end ||
+        (reinterpret_cast<uintptr_t>(cursor) & 7) != 0)
+    {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "mod_meta section bounds are invalid");
+        mod.nativeStatus = NativeModStatus::InvalidMetadata;
+        return false;
+    }
+
+    ModMetaParsed parsed;
+    size_t headerCount = 0;
+    const auto invalid = [&](std::string_view why) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "invalid metadata record at offset {}: {}",
+            cursor - static_cast<const uint8_t*>(meta->records_begin), why);
+        mod.nativeStatus = NativeModStatus::InvalidMetadata;
+        return false;
+    };
+
+    while (cursor < end) {
+        if (end - cursor < 8) {
+            return invalid("trailing bytes");
+        }
+        uint64_t first = 0;
+        std::memcpy(&first, cursor, sizeof(first));
+        if (first == 0) {  // linker padding / bounds sentinel
+            cursor += 8;
+            continue;
+        }
+
+        const auto* rec = reinterpret_cast<const ModMetaRecord*>(cursor);
+        const size_t size = rec->size;
+        if (size < 8 || size % 8 != 0 || size > static_cast<size_t>(end - cursor)) {
+            return invalid("bad record size");
+        }
+
+        switch (rec->kind) {
+        case MOD_META_PAD:
+            break;
+        case MOD_META_HEADER: {
+            if (size < sizeof(ModMetaHeader)) {
+                return invalid("truncated header record");
+            }
+            const auto* header = reinterpret_cast<const ModMetaHeader*>(rec);
+            ++headerCount;
+            parsed.abiVersion = header->abi_version;
+            break;
+        }
+        case MOD_META_IMPORT: {
+            if (size < sizeof(ModMetaImport)) {
+                return invalid("truncated import record");
+            }
+            auto* record = reinterpret_cast<ModMetaImport*>(const_cast<uint8_t*>(cursor));
+            if (!terminated_within(record->service_id.chars, sizeof(record->service_id.chars))) {
+                return invalid("unterminated import service id");
+            }
+            parsed.imports.push_back(record);
+            break;
+        }
+        case MOD_META_EXPORT: {
+            if (size < sizeof(ModMetaExport)) {
+                return invalid("truncated export record");
+            }
+            auto* record = reinterpret_cast<ModMetaExport*>(const_cast<uint8_t*>(cursor));
+            if (!terminated_within(record->service_id.chars, sizeof(record->service_id.chars))) {
+                return invalid("unterminated export service id");
+            }
+            parsed.exports.push_back(record);
+            break;
+        }
+        case MOD_META_HOOK_FN: {
+            if (size < sizeof(ModMetaHookFn)) {
+                return invalid("truncated hook record");
+            }
+            parsed.hookFns.push_back(
+                reinterpret_cast<ModMetaHookFn*>(const_cast<uint8_t*>(cursor)));
+            break;
+        }
+        case MOD_META_HOOK_MEM: {
+            if (size <= sizeof(ModMetaHookMem)) {
+                return invalid("truncated hook record");
+            }
+            auto* record = reinterpret_cast<ModMetaHookMem*>(const_cast<uint8_t*>(cursor));
+            const char* strings = reinterpret_cast<const char*>(cursor) + sizeof(ModMetaHookMem);
+            const size_t capacity = size - sizeof(ModMetaHookMem);
+            if (!terminated_within(strings, capacity)) {
+                return invalid("unterminated hook vtable symbol");
+            }
+            const size_t vtableLen = std::char_traits<char>::length(strings);
+            if (!terminated_within(strings + vtableLen + 1, capacity - vtableLen - 1)) {
+                return invalid("unterminated hook display name");
+            }
+            parsed.hookMems.push_back(record);
+            break;
+        }
+        case MOD_META_HOOK_MEM_EXT: {
+            if (size <= sizeof(ModMetaHookMemExt)) {
+                return invalid("truncated extended hook record");
+            }
+            auto* record = reinterpret_cast<ModMetaHookMemExt*>(const_cast<uint8_t*>(cursor));
+            if (record->pmf_size <= MOD_META_HOOK_MEM_CAPACITY ||
+                record->pmf_size > MOD_META_HOOK_MEM_EXT_CAPACITY || record->materialize == nullptr)
+            {
+                return invalid("bad extended hook member-pointer size");
+            }
+            const char* strings = reinterpret_cast<const char*>(cursor) + sizeof(ModMetaHookMemExt);
+            const size_t capacity = size - sizeof(ModMetaHookMemExt);
+            if (!terminated_within(strings, capacity)) {
+                return invalid("unterminated extended hook vtable symbol");
+            }
+            const size_t vtableLen = std::char_traits<char>::length(strings);
+            if (!terminated_within(strings + vtableLen + 1, capacity - vtableLen - 1)) {
+                return invalid("unterminated extended hook display name");
+            }
+            parsed.hookMemExts.push_back(record);
+            break;
+        }
+        case MOD_META_HOOK_NAME: {
+            if (size <= sizeof(ModMetaHookName)) {
+                return invalid("truncated hook record");
+            }
+            auto* record = reinterpret_cast<ModMetaHookName*>(const_cast<uint8_t*>(cursor));
+            const char* name = reinterpret_cast<const char*>(cursor) + sizeof(ModMetaHookName);
+            if (!terminated_within(name, size - sizeof(ModMetaHookName))) {
+                return invalid("unterminated hook symbol name");
+            }
+            parsed.hookNames.push_back(record);
+            break;
+        }
+        default:
+            // Additive record kinds may appear within a format version; skip them.
+            log::write(mod.metadata.id, LOG_LEVEL_DEBUG, "skipping unknown metadata record kind {}",
+                rec->kind);
+            break;
+        }
+        cursor += size;
+    }
+
+    if (headerCount != 1) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "expected 1 metadata header record, found {}",
+            headerCount);
+        mod.nativeStatus = NativeModStatus::InvalidMetadata;
+        return false;
+    }
+    if (parsed.abiVersion != MOD_ABI_VERSION) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "expects ABI v{} but engine is v{}, skipping",
+            parsed.abiVersion, MOD_ABI_VERSION);
+        mod.nativeStatus = NativeModStatus::ApiVersionMismatch;
+        return false;
+    }
+
+    native.parsed = std::move(parsed);
+    return true;
+}
+
+std::string native_status_message(const NativeModStatus status) {
+    switch (status) {
+    case NativeModStatus::BuildDisabled:
+        return "Code mods are disabled on this Dusklight build";
+    case NativeModStatus::ModMissingPlatform:
+        return fmt::format("Mod not supported on this platform ({})", k_nativePlatform);
+    case NativeModStatus::ApiVersionMismatch:
+        // TODO: differentiate whether mod or Dusklight is out of date
+        return "Mod ABI version mismatch";
+    case NativeModStatus::MissingExport:
+        return "Missing required mod API exports";
+    case NativeModStatus::InvalidMetadata:
+        return "Invalid mod metadata records";
+    case NativeModStatus::InvalidBundle:
+        return "Invalid mod bundle layout (old mod?)";
+    case NativeModStatus::Unknown:
+        return "Unknown mod load failure";
+    case NativeModStatus::None:
+    case NativeModStatus::Loaded:
+        break;
+    }
+    return "native mod failed to load";
+}
+
+}  // namespace
+
+fs::path ModLoader::external_native_lib_path(const LoadedMod& mod) const {
+    if (k_nativeLibName.empty()) {
+        return {};
+    }
+    const auto& libDir = m_searchDirs[mod.searchDirIndex].nativeLibDir;
+    if (libDir.empty()) {
+        return {};
+    }
+    const auto filename = fmt::format("{}{}", mod.metadata.id,
+        borealis::io::fs_path_to_string(fs::path{k_nativeLibName}.extension()));
+    fs::path path = libDir / fs::path{filename};
+    std::error_code ec;
+    if (!fs::is_regular_file(path, ec)) {
+        return {};
+    }
+    return path;
+}
+
+void ModLoader::load_native(
+    LoadedMod& mod, const std::string& dllEntry, const std::vector<std::string>& runtimeEntries) {
+    if (!EnableCodeMods) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "Code mods are not available in this build");
+        mod.nativeStatus = NativeModStatus::BuildDisabled;
+        return;
+    }
+
+    const fs::path cacheDir = m_cacheDir / mod.metadata.id;
+    const fs::path scratchDir = cacheDir / "data";
+    std::error_code ec;
+    fs::create_directories(scratchDir, ec);
+    if (ec) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to create mod directory {}: {}",
+            data::abbreviated_path_string(scratchDir), ec.message());
+        return;
+    }
+    mod.dir = fs::absolute(scratchDir);
+    mod.dirUtf8 = borealis::io::fs_path_to_string(mod.dir);
+
+    fs::path libPath;
+    fs::path runtimeDir;
+    DirectoryRollback runtimeDirRollback;
+    if (mod.nativeInPlace) {
+        if (!dllEntry.empty()) {
+            libPath = mod.modPath / dllEntry;
+        } else if (auto external = external_native_lib_path(mod); !external.empty()) {
+            libPath = std::move(external);
+        } else {
+            log::write(mod.metadata.id, LOG_LEVEL_ERROR,
+                "no native library named {} found; skipping", k_nativeLibName);
+            mod.nativeStatus = NativeModStatus::ModMissingPlatform;
+            return;
+        }
+        runtimeDir = libPath.parent_path();
+    } else {
+        if (dllEntry.empty()) {
+            log::write(mod.metadata.id, LOG_LEVEL_ERROR,
+                "no native library named {} found; skipping", k_nativeLibName);
+            mod.nativeStatus = NativeModStatus::ModMissingPlatform;
+            return;
+        }
+
+        // Every generation gets a new directory. The main module and all of its runtime
+        // libraries therefore have fresh paths and can coexist with a previous generation
+        // that is still unwinding after a reload.
+        runtimeDir = cacheDir / fmt::format("g{}", ++mod.cacheGeneration);
+        runtimeDirRollback.set_path(runtimeDir);
+        fs::create_directories(runtimeDir, ec);
+        if (ec) {
+            log::write(mod.metadata.id, LOG_LEVEL_ERROR,
+                "failed to create native runtime directory {}: {}",
+                data::abbreviated_path_string(runtimeDir), ec.message());
+            return;
+        }
+
+        const std::string platformPrefix = fmt::format("{}{}/", k_nativeLibDir, k_nativePlatform);
+        for (const auto& entry : runtimeEntries) {
+            if (!entry.starts_with(platformPrefix)) {
+                continue;
+            }
+            const std::string_view relativeName{
+                entry.data() + platformPrefix.size(), entry.size() - platformPrefix.size()};
+            if (!is_safe_resource_path(relativeName)) {
+                log::write(mod.metadata.id, LOG_LEVEL_ERROR,
+                    "unsafe native runtime path '{}'; skipping", entry);
+                return;
+            }
+
+            const fs::path outputPath = runtimeDir / fs::path{relativeName};
+            fs::create_directories(outputPath.parent_path(), ec);
+            if (ec) {
+                log::write(mod.metadata.id, LOG_LEVEL_ERROR,
+                    "failed to create directory for {}: {}", entry, ec.message());
+                return;
+            }
+
+            std::vector<u8> data;
+            try {
+                data = mod.bundle->readFile(entry);
+            } catch (const std::exception& e) {
+                log::write(
+                    mod.metadata.id, LOG_LEVEL_ERROR, "failed to extract {}: {}", entry, e.what());
+                return;
+            }
+
+            std::ofstream out(outputPath, std::ios::binary | std::ios::out);
+            if (!out) {
+                log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to write {}", entry);
+                return;
+            }
+            out.write(reinterpret_cast<const char*>(data.data()),
+                static_cast<std::streamsize>(data.size()));
+            if (!out) {
+                log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to write {}", entry);
+                return;
+            }
+        }
+
+        libPath = runtimeDir / fs::path{dllEntry}.filename();
+    }
+
+    auto nativeMod = std::make_unique<NativeMod>();
+    try {
+        nativeMod->handle = std::make_unique<loader::NativeModule>(libPath);
+    } catch (const std::runtime_error& e) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "failed to open {}: {}",
+            data::abbreviated_path_string(libPath), e.what());
+        return;
+    }
+
+    nativeMod->meta = nativeMod->handle->LookupSymbol<const ModMeta*>("mod_meta");
+    nativeMod->contextSymbol = nativeMod->handle->LookupSymbol<ModContext**>("mod_ctx");
+    nativeMod->fn_initialize = nativeMod->handle->LookupSymbol<ModInitializeFn>("mod_initialize");
+    nativeMod->fn_update = nativeMod->handle->LookupSymbol<ModUpdateFn>("mod_update");
+    nativeMod->fn_shutdown = nativeMod->handle->LookupSymbol<ModShutdownFn>("mod_shutdown");
+
+    if (!nativeMod->meta || !nativeMod->contextSymbol || !nativeMod->fn_initialize ||
+        !nativeMod->fn_update || !nativeMod->fn_shutdown)
+    {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR,
+            "{} missing required mod API exports; skipping",
+            data::abbreviated_path_string(libPath));
+        mod.nativeStatus = NativeModStatus::MissingExport;
+        return;
+    }
+
+    if (!parse_meta(*nativeMod, mod)) {
+        return;
+    }
+
+    if (nativeMod->contextSymbol == nullptr) {
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "missing required mod_ctx export");
+        mod.nativeStatus = NativeModStatus::MissingExport;
+        return;
+    }
+    *nativeMod->contextSymbol = mod.context.get();
+
+    mod.nativePath = fs::absolute(libPath);
+    mod.nativeDir = fs::absolute(runtimeDir);
+    mod.nativeDirUtf8 = borealis::io::fs_path_to_string(mod.nativeDir);
+    mod.native = std::move(nativeMod);
+    mod.nativeStatus = NativeModStatus::Loaded;
+    runtimeDirRollback.release();
+}
+
+bool ModLoader::load_native_if_present(LoadedMod& mod) {
+    const auto result = locate_native_runtime(*mod.bundle);
+    if (const auto* failure = std::get_if<NativeLocateFailure>(&result)) {
+        mod.nativeStatus = failure->status;
+        log::write(mod.metadata.id, LOG_LEVEL_ERROR, "{}", failure->logMessage);
+        fail_mod(mod, MOD_ERROR, native_status_message(failure->status));
+        return false;
+    }
+
+    const auto& native = std::get<NativeRuntimeLocation>(result);
+    if (mod.runtime.has_value() &&
+        (native.anyLibs || (mod.nativeInPlace && !external_native_lib_path(mod).empty())))
+    {
+        mod.nativeStatus = NativeModStatus::InvalidBundle;
+        fail_mod(mod, MOD_CONFLICT, "A mod cannot declare both runtime and native code");
+        return false;
+    }
+    if (!native.anyLibs && !(mod.nativeInPlace && !external_native_lib_path(mod).empty())) {
+        mod.nativeStatus = NativeModStatus::None;
+        return true;
+    }
+
+    mod.nativeStatus = NativeModStatus::Unknown;
+    load_native(mod, native.entry, native.runtimeEntries);
+    if (mod.nativeStatus != NativeModStatus::Loaded) {
+        fail_mod(mod, MOD_ERROR, native_status_message(mod.nativeStatus));
+        return false;
+    }
+    return true;
+}
+
+void ModLoader::unload_native(LoadedMod& mod) {
+    if (!mod.native) {
+        return;
+    }
+    // Deferred dlclose: this mod's code may still be on the stack below the current tick
+    m_retiredNatives.push_back(
+        {std::move(mod.native), mod.nativeInPlace ? fs::path{} : std::move(mod.nativeDir)});
+    mod.nativePath.clear();
+    mod.nativeDir.clear();
+    mod.nativeDirUtf8.clear();
+}
+
+void ModLoader::drain_retired_natives() {
+    for (auto& retired : m_retiredNatives) {
+        retired.native.reset();
+        if (!retired.directory.empty()) {
+            std::error_code ec;
+            fs::remove_all(retired.directory, ec);
+        }
+    }
+    m_retiredNatives.clear();
+}
+
+bool ModLoader::ensure_native_loaded(LoadedMod& mod) {
+    if (mod.native || mod.nativeStatus == NativeModStatus::None) {
+        return true;
+    }
+    return load_native_if_present(mod);
+}
+
+ModManifestInfo build_manifest_info(const ModMetaParsed& parsed) {
+    ModManifestInfo info;
+    info.imports.reserve(parsed.imports.size());
+    for (const auto* record : parsed.imports) {
+        if (!svc::valid_service_id(record->service_id.chars)) {
+            continue;
+        }
+        info.imports.push_back({
+            .id = record->service_id.chars,
+            .major = record->major_version,
+            .minMinor = record->min_minor_version,
+            .required = (record->rec.flags & SERVICE_IMPORT_OPTIONAL) == 0,
+        });
+    }
+    info.exports.reserve(parsed.exports.size());
+    for (const auto* record : parsed.exports) {
+        if (!svc::valid_service_id(record->service_id.chars)) {
+            continue;
+        }
+        info.exports.push_back({
+            .id = record->service_id.chars,
+            .major = record->major_version,
+        });
+    }
+    return info;
+}
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/natives.hpp b/src/dusk/mods/loader/natives.hpp
new file mode 100644
index 0000000000..657f3d011a
--- /dev/null
+++ b/src/dusk/mods/loader/natives.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string_view>
+
+namespace dusk::mods {
+
+struct ModManifestInfo;
+struct ModMetaParsed;
+
+bool has_native_library_extension(std::string_view name);
+ModManifestInfo build_manifest_info(const ModMetaParsed& parsed);
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/packages.cpp b/src/dusk/mods/loader/packages.cpp
new file mode 100644
index 0000000000..071f5b276e
--- /dev/null
+++ b/src/dusk/mods/loader/packages.cpp
@@ -0,0 +1,201 @@
+#include "packages.hpp"
+
+#include "loader.hpp"
+#include "manifest.hpp"
+
+#include "dusk/data.hpp"
+
+#include <borealis/io.hpp>
+#include <borealis/log.hpp>
+#include <borealis/update.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+namespace fs = std::filesystem;
+
+namespace dusk::mods {
+namespace {
+
+constexpr borealis::Log Log{"dusk::mods::loader"};
+
+}  // namespace
+
+std::unique_ptr<ModBundle> load_bundle(const fs::path& modPath, bool fromDir) {
+    if (fromDir) {
+        return std::make_unique<ModBundleDisk>(modPath);
+    } else {
+        return std::make_unique<ModBundleZip>(modPath);
+    }
+}
+
+int compare_package_versions(std::string_view lhs, std::string_view rhs) {
+    const auto left = borealis::update::parse_version(lhs);
+    const auto right = borealis::update::parse_version(rhs);
+    if (left && right) {
+        return borealis::update::compare_version(*left, *right);
+    }
+    return static_cast<int>(left.has_value()) - static_cast<int>(right.has_value());
+}
+
+std::vector<PackageCandidate> scan_packages(std::span<const ModSearchDir> searchDirs) {
+    std::vector<PackageCandidate> packages;
+    for (size_t dirIndex = 0; dirIndex < searchDirs.size(); ++dirIndex) {
+        const auto& searchDir = searchDirs[dirIndex];
+        std::error_code error;
+        bool alreadyScanned = false;
+        for (size_t earlier = 0; earlier < dirIndex && !alreadyScanned; ++earlier) {
+            alreadyScanned = fs::equivalent(searchDirs[earlier].path, searchDir.path, error);
+        }
+        if (alreadyScanned || !fs::is_directory(searchDir.path)) {
+            continue;
+        }
+        std::vector<fs::directory_entry> entries;
+        for (const auto& entry : fs::directory_iterator{searchDir.path}) {
+            if ((entry.is_directory() && fs::exists(entry.path() / "mod.json")) ||
+                (entry.is_regular_file() && entry.path().extension() == ".dusk"))
+            {
+                entries.push_back(entry);
+            }
+        }
+        std::ranges::sort(entries, {}, &fs::directory_entry::path);
+        for (const auto& entry : entries) {
+            try {
+                const bool fromDirectory = entry.is_directory();
+                auto bundle = load_bundle(entry.path(), fromDirectory);
+                packages.push_back({
+                    .path = fs::absolute(entry.path()),
+                    .metadata = load_manifest(entry.path(), *bundle).metadata,
+                    .searchDirIndex = static_cast<uint32_t>(dirIndex),
+                    .fromDirectory = fromDirectory,
+                    .symlink = entry.is_symlink(),
+                });
+            } catch (const std::exception& exception) {
+                Log.error("bad mod package {}: {}",
+                    data::abbreviated_path_string(entry.path()), exception.what());
+            }
+        }
+    }
+    return packages;
+}
+
+const PackageCandidate* select_package(std::span<const PackageCandidate> packages,
+    std::string_view modId) {
+    const PackageCandidate* selected = nullptr;
+    for (const auto& package : packages) {
+        if (package.metadata.id != modId) {
+            continue;
+        }
+        const int order = selected ?
+            compare_package_versions(package.metadata.version, selected->metadata.version) : 1;
+        if (order > 0 || (order == 0 &&
+            (package.searchDirIndex < selected->searchDirIndex ||
+                (package.searchDirIndex == selected->searchDirIndex && package.path < selected->path))))
+        {
+            selected = &package;
+        }
+    }
+    return selected;
+}
+
+void record_package_sources(LoadedMod& mod, std::span<const PackageCandidate> packages) {
+    mod.hasUserPackage = false;
+    mod.hasBundledCopy = false;
+    for (const auto& package : packages) {
+        if (package.metadata.id != mod.metadata.id) {
+            continue;
+        }
+        if (package.searchDirIndex != 0) {
+            mod.hasBundledCopy = true;
+        } else if (!package.fromDirectory && !package.symlink) {
+            mod.hasUserPackage = true;
+        }
+    }
+}
+
+PackageInstallResult install_package(const fs::path& path, const fs::path& destination,
+    std::string_view modId) {
+    const auto userDir = destination.parent_path();
+    std::error_code error;
+    std::string validationError;
+    const auto destinationStatus = fs::symlink_status(destination, error);
+    if (error == std::errc::no_such_file_or_directory) {
+        error.clear();
+    }
+    if (error) {
+        return {.replaced = false,
+            .error = fmt::format("Could not inspect the destination: {}", error.message())};
+    }
+    if (fs::exists(destinationStatus)) {
+        ModMetadata existingMetadata;
+        if (!fs::is_regular_file(destinationStatus) ||
+            !inspect_mod_bundle(destination, existingMetadata, validationError) ||
+            existingMetadata.id != modId)
+        {
+            return {
+                .replaced = false,
+                .error = "The destination filename is already used by another package",
+            };
+        }
+    }
+    std::vector<fs::path> duplicates;
+    for (fs::directory_iterator entry{userDir, error}, end; !error && entry != end;
+        entry.increment(error))
+    {
+        const auto& candidate = entry->path();
+        if (candidate.extension() != ".dusk") {
+            continue;
+        }
+        const bool regularFile = entry->is_regular_file(error);
+        if (error) {
+            break;
+        }
+        if (!regularFile) {
+            continue;
+        }
+        ModMetadata candidateMetadata;
+        if (inspect_mod_bundle(candidate, candidateMetadata, validationError) &&
+            candidateMetadata.id == modId)
+        {
+            duplicates.push_back(candidate);
+        }
+    }
+    if (error) {
+        return {.replaced = false,
+            .error = fmt::format("Could not scan the mods directory: {}", error.message())};
+    }
+
+    std::string replaceError;
+    if (!borealis::io::atomic_replace(path, destination, replaceError)) {
+        return {
+            .replaced = false,
+            .error = std::move(replaceError),
+        };
+    }
+
+    std::string cleanupError;
+    for (const auto& duplicate : duplicates) {
+        // Replacing a file on a case-insensitive filesystem can preserve its old spelling.
+        const bool destinationAlias =
+            fs::equivalent(duplicate, destination, error) && !fs::is_symlink(duplicate, error);
+        error.clear();
+        if (destinationAlias) {
+            if (duplicate.filename() == destination.filename()) {
+                continue;
+            }
+            fs::rename(duplicate, destination, error);
+        } else {
+            fs::remove(duplicate, error);
+        }
+        if (error) {
+            cleanupError = fmt::format("Installed, but could not consolidate '{}': {}",
+                data::abbreviated_path_string(duplicate), error.message());
+            Log.warn("{}", cleanupError);
+        }
+    }
+    return {.replaced = true, .error = std::move(cleanupError)};
+}
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/packages.hpp b/src/dusk/mods/loader/packages.hpp
new file mode 100644
index 0000000000..0271dca5fe
--- /dev/null
+++ b/src/dusk/mods/loader/packages.hpp
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "dusk/mod_loader.hpp"
+
+#include <filesystem>
+#include <memory>
+#include <span>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk::mods {
+
+struct PackageCandidate {
+    std::filesystem::path path;
+    ModMetadata metadata;
+    uint32_t searchDirIndex = 0;
+    bool fromDirectory = false;
+    bool symlink = false;
+};
+
+std::vector<PackageCandidate> scan_packages(std::span<const ModSearchDir> searchDirs);
+int compare_package_versions(std::string_view lhs, std::string_view rhs);
+const PackageCandidate* select_package(
+    std::span<const PackageCandidate> packages, std::string_view modId);
+void record_package_sources(LoadedMod& mod, std::span<const PackageCandidate> packages);
+
+std::unique_ptr<ModBundle> load_bundle(const std::filesystem::path& modPath, bool fromDir);
+
+struct PackageInstallResult {
+    bool replaced = false;
+    std::string error;
+};
+
+PackageInstallResult install_package(const std::filesystem::path& path,
+    const std::filesystem::path& destination, std::string_view modId);
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/loader/prepatch.cpp b/src/dusk/mods/loader/prepatch.cpp
new file mode 100644
index 0000000000..26c802a3cd
--- /dev/null
+++ b/src/dusk/mods/loader/prepatch.cpp
@@ -0,0 +1,260 @@
+#include "prepatch.hpp"
+
+#include <atomic>
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include <borealis/log.hpp>
+
+#if DUSK_HAS_PREPATCH
+#include <mach-o/dyld.h>
+#include <mach-o/loader.h>
+#endif
+
+namespace dusk::mods::prepatch {
+namespace {
+
+constexpr borealis::Log Log{"dusk::mods::prepatch"};
+
+constexpr std::string_view kSiteMagic = "PS01";
+constexpr size_t kSiteHeaderSize = 12;
+constexpr size_t kGatewaySize = 28;
+constexpr size_t kOriginalStubOffset = 20;
+
+constexpr uint32_t kBranchMask = 0xfc000000u;
+constexpr uint32_t kBranch = 0x14000000u;
+constexpr uint32_t kLdarX16X16 = 0xc8dffe10u;
+constexpr uint32_t kCbzX16Stub = 0xb4000050u;
+constexpr uint32_t kBrX16 = 0xd61f0200u;
+constexpr uint32_t kBtiC = 0xd503245fu;
+
+struct SiteHeader {
+    char magic[4];
+    int32_t targetDelta;
+    int32_t slotDelta;
+};
+static_assert(sizeof(SiteHeader) == kSiteHeaderSize);
+
+struct Range {
+    uintptr_t begin = 0;
+    uintptr_t end = 0;
+
+    bool contains(uintptr_t address, size_t size) const {
+        return address >= begin && address <= end && size <= end - address;
+    }
+};
+
+struct State {
+    std::vector<Range> executableRanges;
+    std::vector<Range> writableRanges;
+    std::string failureReason = "not initialized";
+    bool loaded = false;
+    bool initialized = false;
+};
+State s_state;
+
+void fail(std::string reason) {
+    s_state.failureReason = std::move(reason);
+    Log.error("prepatch backend unavailable: {}", s_state.failureReason);
+}
+
+void unavailable(std::string reason) {
+    s_state.failureReason = std::move(reason);
+    Log.info("prepatch backend unavailable: {}", s_state.failureReason);
+}
+
+bool add_delta(uintptr_t address, int64_t delta, uintptr_t& out) {
+    if (delta >= 0) {
+        const auto offset = static_cast<uintptr_t>(delta);
+        if (address > std::numeric_limits<uintptr_t>::max() - offset) {
+            return false;
+        }
+        out = address + offset;
+    } else {
+        const auto offset = static_cast<uintptr_t>(-(delta + 1)) + 1;
+        if (address < offset) {
+            return false;
+        }
+        out = address - offset;
+    }
+    return true;
+}
+
+bool branch_target(uintptr_t address, uint32_t instruction, uintptr_t& out) {
+    if ((instruction & kBranchMask) != kBranch) {
+        return false;
+    }
+    int64_t words = instruction & 0x03ffffffu;
+    if ((words & 0x02000000) != 0) {
+        words -= int64_t{1} << 26;
+    }
+    return add_delta(address, words * 4, out);
+}
+
+const Range* containing(const std::vector<Range>& ranges, uintptr_t address, size_t size) {
+    for (const auto& range : ranges) {
+        if (range.contains(address, size)) {
+            return &range;
+        }
+    }
+    return nullptr;
+}
+
+#if DUSK_HAS_PREPATCH
+bool slide_address(intptr_t slide, uint64_t vmaddr, uintptr_t& out) {
+    if (vmaddr > std::numeric_limits<uintptr_t>::max()) {
+        return false;
+    }
+    return add_delta(static_cast<uintptr_t>(vmaddr), slide, out);
+}
+#endif
+
+}  // namespace
+
+void initialize() {
+    if (s_state.initialized) {
+        return;
+    }
+    s_state.initialized = true;
+
+#if DUSK_HAS_PREPATCH
+    const auto* imageHeader = reinterpret_cast<const mach_header_64*>(_dyld_get_image_header(0));
+    if (imageHeader == nullptr || imageHeader->magic != MH_MAGIC_64 ||
+        imageHeader->cputype != CPU_TYPE_ARM64 ||
+        (imageHeader->cpusubtype & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM64E ||
+        (imageHeader->cpusubtype & CPU_SUBTYPE_ARM64_PTR_AUTH_MASK) != 0)
+    {
+        fail("main image is not a supported 64-bit arm64 Mach-O image");
+        return;
+    }
+
+    const intptr_t slide = _dyld_get_image_vmaddr_slide(0);
+    const auto* commands = reinterpret_cast<const uint8_t*>(imageHeader + 1);
+    size_t commandOffset = 0;
+    for (uint32_t i = 0; i < imageHeader->ncmds; ++i) {
+        if (commandOffset > imageHeader->sizeofcmds ||
+            imageHeader->sizeofcmds - commandOffset < sizeof(load_command))
+        {
+            fail("main image has malformed load commands");
+            return;
+        }
+        const auto* command = reinterpret_cast<const load_command*>(commands + commandOffset);
+        if (command->cmdsize < sizeof(load_command) ||
+            command->cmdsize > imageHeader->sizeofcmds - commandOffset)
+        {
+            fail("main image has malformed load commands");
+            return;
+        }
+        if (command->cmd == LC_SEGMENT_64) {
+            if (command->cmdsize < sizeof(segment_command_64)) {
+                fail("main image has a truncated segment command");
+                return;
+            }
+            const auto* segment = reinterpret_cast<const segment_command_64*>(command);
+            const uint64_t vmEnd = segment->vmaddr + segment->vmsize;
+            if (vmEnd < segment->vmaddr) {
+                fail("main image segment range overflows");
+                return;
+            }
+            uintptr_t begin = 0;
+            uintptr_t end = 0;
+            if (!slide_address(slide, segment->vmaddr, begin) ||
+                !slide_address(slide, vmEnd, end) || end < begin)
+            {
+                fail("main image runtime segment range overflows");
+                return;
+            }
+            constexpr vm_prot_t kRx = VM_PROT_READ | VM_PROT_EXECUTE;
+            constexpr vm_prot_t kRw = VM_PROT_READ | VM_PROT_WRITE;
+            if (segment->initprot == kRx && segment->maxprot == kRx) {
+                s_state.executableRanges.push_back({begin, end});
+            } else if (segment->initprot == kRw && segment->maxprot == kRw) {
+                s_state.writableRanges.push_back({begin, end});
+            }
+        }
+        commandOffset += command->cmdsize;
+    }
+    if (commandOffset != imageHeader->sizeofcmds || s_state.executableRanges.empty() ||
+        s_state.writableRanges.empty())
+    {
+        fail("main image has no usable executable or writable segments");
+        return;
+    }
+
+    s_state.failureReason.clear();
+    s_state.loaded = true;
+#else
+    unavailable("prepatch support is not available in this build");
+#endif
+}
+
+bool available() {
+    return s_state.loaded;
+}
+
+const char* unavailable_reason() {
+    return s_state.failureReason.c_str();
+}
+
+std::optional<Site> lookup(void* runtimeTarget) {
+    if (!s_state.loaded || runtimeTarget == nullptr) {
+        return std::nullopt;
+    }
+    const auto target = reinterpret_cast<uintptr_t>(runtimeTarget);
+    if (containing(s_state.executableRanges, target, sizeof(uint32_t)) == nullptr) {
+        return std::nullopt;
+    }
+
+    uint32_t entry = 0;
+    std::memcpy(&entry, reinterpret_cast<const void*>(target), sizeof(entry));
+    uintptr_t gateway = 0;
+    if (!branch_target(target, entry, gateway) || gateway < kSiteHeaderSize) {
+        return std::nullopt;
+    }
+    const uintptr_t headerAddress = gateway - kSiteHeaderSize;
+    if (containing(s_state.executableRanges, headerAddress, kSiteHeaderSize + kGatewaySize) ==
+        nullptr)
+    {
+        return std::nullopt;
+    }
+
+    SiteHeader header{};
+    std::memcpy(&header, reinterpret_cast<const void*>(headerAddress), sizeof(header));
+    if (std::memcmp(header.magic, kSiteMagic.data(), kSiteMagic.size()) != 0) {
+        return std::nullopt;
+    }
+    uintptr_t recordedTarget = 0;
+    uintptr_t slot = 0;
+    if (!add_delta(gateway, header.targetDelta, recordedTarget) || recordedTarget != target ||
+        !add_delta(gateway, header.slotDelta, slot) || (slot & (alignof(void*) - 1)) != 0 ||
+        containing(s_state.writableRanges, slot, sizeof(void*)) == nullptr)
+    {
+        return std::nullopt;
+    }
+
+    uint32_t instructions[7]{};
+    std::memcpy(instructions, reinterpret_cast<const void*>(gateway), sizeof(instructions));
+    uintptr_t original = 0;
+    if (instructions[2] != kLdarX16X16 || instructions[3] != kCbzX16Stub ||
+        instructions[4] != kBrX16 || instructions[5] != kBtiC ||
+        target > std::numeric_limits<uintptr_t>::max() - 4 ||
+        !branch_target(gateway + 24, instructions[6], original) || original != target + 4)
+    {
+        return std::nullopt;
+    }
+
+    return Site{
+        reinterpret_cast<void**>(slot), reinterpret_cast<void*>(gateway + kOriginalStubOffset)};
+}
+
+void publish(const Site& site, void* trampoline) {
+    std::atomic_ref slot{*site.slot};
+    slot.store(trampoline, std::memory_order_release);
+}
+
+}  // namespace dusk::mods::prepatch
diff --git a/src/dusk/mods/loader/prepatch.hpp b/src/dusk/mods/loader/prepatch.hpp
new file mode 100644
index 0000000000..3b742d003b
--- /dev/null
+++ b/src/dusk/mods/loader/prepatch.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <optional>
+
+namespace dusk::mods::prepatch {
+
+struct Site {
+    void** slot = nullptr;
+    void* original = nullptr;
+};
+
+void initialize();
+bool available();
+const char* unavailable_reason();
+// Returns the target function's prepatched hook site, or nullopt if it is not prepatched.
+std::optional<Site> lookup(void* runtimeTarget);
+// Publishes a trampoline (or nullptr to deactivate).
+void publish(const Site& site, void* trampoline);
+
+}  // namespace dusk::mods::prepatch
diff --git a/src/dusk/mods/log_buffer.cpp b/src/dusk/mods/log_buffer.cpp
index bfee810767..70a2a6f8e5 100644
--- a/src/dusk/mods/log_buffer.cpp
+++ b/src/dusk/mods/log_buffer.cpp
@@ -55,26 +55,26 @@ void emit(Source source, const std::string& modId, LogLevel level, const std::st
         slot.message.assign(message);
     }
 
-    AuroraLogLevel auroraLevel = LOG_INFO;
+    auto logLevel = borealis::LogLevel::Info;
     switch (level) {
     case LOG_LEVEL_TRACE:
+        logLevel = borealis::LogLevel::Trace;
+        break;
     case LOG_LEVEL_DEBUG:
-        auroraLevel = LOG_DEBUG;
+        logLevel = borealis::LogLevel::Debug;
         break;
     case LOG_LEVEL_INFO:
-        auroraLevel = LOG_INFO;
+        logLevel = borealis::LogLevel::Info;
         break;
     case LOG_LEVEL_WARN:
-        auroraLevel = LOG_WARNING;
+        logLevel = borealis::LogLevel::Warning;
         break;
     case LOG_LEVEL_ERROR:
-        auroraLevel = LOG_ERROR;
+        logLevel = borealis::LogLevel::Error;
         break;
     }
-    if (aurora::g_config.logLevel <= auroraLevel) {
-        aurora::log_internal(auroraLevel, modId.c_str(), message.c_str(),
-            static_cast<unsigned int>(message.length()));
-    }
+    const borealis::Log modLog{modId.c_str()};
+    modLog.report(logLevel, "{}", message);
 }
 
 Range copy_since(uint64_t sinceSeq, std::vector<Line>& out) {
diff --git a/src/dusk/mods/log_buffer.hpp b/src/dusk/mods/log_buffer.hpp
index 33a143705d..2787ccb07f 100644
--- a/src/dusk/mods/log_buffer.hpp
+++ b/src/dusk/mods/log_buffer.hpp
@@ -1,13 +1,12 @@
 #pragma once
 
-#include <cstdint>
-#include <string>
-#include <string_view>
-#include <vector>
+#include "mods/svc/log.h"
 
 #include <fmt/format.h>
 
-#include "mods/svc/log.h"
+#include <cstdint>
+#include <string>
+#include <vector>
 
 namespace dusk::mods::log {
 
diff --git a/src/dusk/mods/manifest.cpp b/src/dusk/mods/manifest.cpp
index 7e83dfb8f6..e60039a37f 100644
--- a/src/dusk/mods/manifest.cpp
+++ b/src/dusk/mods/manifest.cpp
@@ -6,17 +6,13 @@
 
 #include <algorithm>
 #include <cstring>
-#include <filesystem>
 #include <limits>
 #include <utility>
 #include <vector>
 
-#include <SDL3/SDL_filesystem.h>
 #include <zstd.h>
 
-#include "aurora/lib/logging.hpp"
-
-#include "dusk/io.hpp"
+#include <borealis/log.hpp>
 
 #if defined(_WIN32)
 #define WIN32_LEAN_AND_MEAN
@@ -32,7 +28,7 @@
 namespace dusk::mods::manifest {
 namespace {
 
-aurora::Module Log("dusk::mods::manifest");
+constexpr borealis::Log Log{"dusk::mods::manifest"};
 
 constexpr char kMagic[8] = {'S', 'Y', 'M', 'G', 'E', 'N', '\0', '\0'};
 constexpr uint32_t kVersion = 2;
@@ -63,6 +59,31 @@ struct Entry {
 };
 static_assert(sizeof(Entry) == 24);
 
+/*
+ * `symgen manifest --embed` appends the symbol manifest to the linked executable as an added
+ * section and patches this descriptor with its location.
+ */
+struct SymdbDescriptor {
+    volatile uint64_t magic;
+    volatile uint64_t rva;
+    volatile uint64_t size;
+};
+constexpr uint64_t kDescriptorMagic = 0x52444842444d5953ull;  // "SYMDBHDR"
+#if defined(_WIN32)
+#pragma section(".symdbh", read)
+__declspec(allocate(".symdbh"))
+#if defined(__clang__)
+__attribute__((used))
+#endif
+constinit SymdbDescriptor s_symdbDescriptor{kDescriptorMagic, 0, 0};
+#elif defined(__APPLE__)
+__attribute__((section("__DATA,__symdbh"), used)) constinit SymdbDescriptor s_symdbDescriptor{
+    kDescriptorMagic, 0, 0};
+#else
+__attribute__((section("symdbh"), used)) constinit SymdbDescriptor s_symdbDescriptor{
+    kDescriptorMagic, 0, 0};
+#endif
+
 struct State {
     std::vector<uint8_t> data;
     const Entry* entries = nullptr;
@@ -71,7 +92,7 @@ struct State {
     uint64_t stringsLen = 0;
     uintptr_t imageBase = 0;
     // (rva, nameOff) of entries flagged kFlagInlineSites, sorted by rva
-    std::vector<std::pair<uint64_t, uint32_t> > inlineSites;
+    std::vector<std::pair<uint64_t, uint32_t>> inlineSites;
     bool loaded = false;
     bool initialized = false;
 };
@@ -149,13 +170,28 @@ bool running_image_identity(std::vector<uint8_t>& outId, uintptr_t& outBase) {
 #elif defined(__linux__)
     struct Ctx {
         std::vector<uint8_t>* id;
+        uintptr_t probe;
         uintptr_t base = 0;
         bool found = false;
-    } ctx{&outId};
+    } ctx{&outId, reinterpret_cast<uintptr_t>(&s_symdbDescriptor)};
     dl_iterate_phdr(
         [](dl_phdr_info* info, size_t, void* data) -> int {
             auto* ctx = static_cast<Ctx*>(data);
-            // The first callback is the main executable.
+            // Select the image containing our descriptor: the game is not always the
+            // first entry (on Android it is libmain.so, behind the app process).
+            bool contains = false;
+            for (int i = 0; i < info->dlpi_phnum; ++i) {
+                const auto& phdr = info->dlpi_phdr[i];
+                if (phdr.p_type == PT_LOAD && ctx->probe >= info->dlpi_addr + phdr.p_vaddr &&
+                    ctx->probe - (info->dlpi_addr + phdr.p_vaddr) < phdr.p_memsz)
+                {
+                    contains = true;
+                    break;
+                }
+            }
+            if (!contains) {
+                return 0;
+            }
             ctx->base = info->dlpi_addr;
             for (int i = 0; i < info->dlpi_phnum; ++i) {
                 const auto& phdr = info->dlpi_phdr[i];
@@ -178,7 +214,7 @@ bool running_image_identity(std::vector<uint8_t>& outId, uintptr_t& outBase) {
                     p = desc + ((note->n_descsz + 3) & ~3u);
                 }
             }
-            return 1;  // only inspect the main executable
+            return 1;  // matched our image; stop either way
         },
         &ctx);
     outBase = ctx.base;
@@ -190,13 +226,6 @@ bool running_image_identity(std::vector<uint8_t>& outId, uintptr_t& outBase) {
 #endif
 }
 
-std::filesystem::path manifest_path() {
-    const char* basePath = SDL_GetBasePath();
-    std::filesystem::path dir =
-        basePath != nullptr ? std::filesystem::path{basePath} : std::filesystem::current_path();
-    return dir / "dusklight.symdb";
-}
-
 std::string hex_string(const uint8_t* data, size_t len) {
     std::string out;
     out.reserve(len * 2);
@@ -216,40 +245,12 @@ void initialize() {
     }
     s_state.initialized = true;
 
-    const auto path = manifest_path();
-    std::error_code ec;
-    if (!std::filesystem::exists(path, ec)) {
-        Log.info("no symbol manifest at {}; by-name resolution unavailable",
-            io::fs_path_to_string(path));
+    if (s_symdbDescriptor.magic != kDescriptorMagic) {
+        Log.error("symbol manifest descriptor is corrupt");
         return;
     }
-    std::vector<uint8_t> data;
-    try {
-        data = io::FileStream::ReadAllBytes(path);
-    } catch (const std::exception& e) {
-        Log.error("failed to read symbol manifest {}: {}", io::fs_path_to_string(path), e.what());
-        return;
-    }
-    if (data.size() < sizeof(Header)) {
-        Log.error(
-            "symbol manifest {} is truncated ({} bytes)", io::fs_path_to_string(path), data.size());
-        return;
-    }
-
-    Header header{};
-    std::memcpy(&header, data.data(), sizeof(header));
-    if (std::memcmp(header.magic, kMagic, sizeof(kMagic)) != 0 || header.version != kVersion) {
-        Log.error("symbol manifest {} has wrong magic/version", io::fs_path_to_string(path));
-        return;
-    }
-    const auto compression = static_cast<Compression>(header.compression);
-    if ((compression != Compression::None && compression != Compression::Zstd) ||
-        header.buildIdLen > sizeof(header.buildId) ||
-        header.compressedLen > data.size() - sizeof(Header) ||
-        header.uncompressedLen > std::numeric_limits<size_t>::max() ||
-        (compression == Compression::None && header.compressedLen != header.uncompressedLen))
-    {
-        Log.error("symbol manifest {} is malformed", io::fs_path_to_string(path));
+    if (s_symdbDescriptor.rva == 0) {
+        Log.info("no symbol manifest embedded; by-name resolution unavailable");
         return;
     }
 
@@ -259,41 +260,67 @@ void initialize() {
         Log.error("cannot determine the running image's build id; ignoring symbol manifest");
         return;
     }
+
+    const auto* blob = reinterpret_cast<const uint8_t*>(imageBase + s_symdbDescriptor.rva);
+    const auto blobLen = static_cast<size_t>(s_symdbDescriptor.size);
+    if (blobLen < sizeof(Header)) {
+        Log.error("embedded symbol manifest is truncated ({} bytes)", blobLen);
+        return;
+    }
+
+    Header header{};
+    std::memcpy(&header, blob, sizeof(header));
+    if (std::memcmp(header.magic, kMagic, sizeof(kMagic)) != 0 || header.version != kVersion) {
+        Log.error("embedded symbol manifest has wrong magic/version");
+        return;
+    }
+    const auto compression = static_cast<Compression>(header.compression);
+    if ((compression != Compression::None && compression != Compression::Zstd) ||
+        header.buildIdLen > sizeof(header.buildId) ||
+        header.compressedLen > blobLen - sizeof(Header) ||
+        header.uncompressedLen > std::numeric_limits<size_t>::max() ||
+        (compression == Compression::None && header.compressedLen != header.uncompressedLen))
+    {
+        Log.error("embedded symbol manifest is malformed");
+        return;
+    }
+
+    // The manifest travels inside the image it describes, so a mismatch here means broken
+    // build tooling rather than a stale file — but it still guards resolved addresses.
     if (imageId.size() != header.buildIdLen ||
         std::memcmp(imageId.data(), header.buildId, imageId.size()) != 0)
     {
-        Log.error("symbol manifest {} is stale: built for {}, running image is {}",
-            io::fs_path_to_string(path), hex_string(header.buildId, header.buildIdLen),
+        Log.error("embedded symbol manifest is stale: built for {}, running image is {}",
+            hex_string(header.buildId, header.buildIdLen),
             hex_string(imageId.data(), imageId.size()));
         return;
     }
 
     const auto compressedLen = static_cast<size_t>(header.compressedLen);
     const auto uncompressedLen = static_cast<size_t>(header.uncompressedLen);
-    std::vector<uint8_t> payload;
-    const auto* storedPayload = data.data() + sizeof(Header);
+    std::vector<uint8_t> data;
+    const auto* storedPayload = blob + sizeof(Header);
     if (compression == Compression::None) {
-        payload.assign(storedPayload, storedPayload + compressedLen);
+        data.assign(storedPayload, storedPayload + compressedLen);
     } else {
-        payload.resize(uncompressedLen);
+        data.resize(uncompressedLen);
         const size_t decompressedLen =
-            ZSTD_decompress(payload.data(), payload.size(), storedPayload, compressedLen);
+            ZSTD_decompress(data.data(), data.size(), storedPayload, compressedLen);
         if (ZSTD_isError(decompressedLen)) {
-            Log.error("failed to decompress symbol manifest {}: {}", io::fs_path_to_string(path),
+            Log.error("failed to decompress embedded symbol manifest: {}",
                 ZSTD_getErrorName(decompressedLen));
             return;
         }
-        if (decompressedLen != payload.size()) {
-            Log.error("symbol manifest {} decompressed to {} bytes, expected {}",
-                io::fs_path_to_string(path), decompressedLen, payload.size());
+        if (decompressedLen != data.size()) {
+            Log.error("embedded symbol manifest decompressed to {} bytes, expected {}",
+                decompressedLen, data.size());
             return;
         }
     }
-    data = std::move(payload);
 
     const uint64_t entriesEnd = uint64_t{header.entryCount} * sizeof(Entry);
     if (entriesEnd > data.size()) {
-        Log.error("decompressed symbol manifest {} is malformed", io::fs_path_to_string(path));
+        Log.error("decompressed embedded symbol manifest is malformed");
         return;
     }
 
diff --git a/src/dusk/mods/manifest.hpp b/src/dusk/mods/manifest.hpp
index c6bc03f038..586759a8b1 100644
--- a/src/dusk/mods/manifest.hpp
+++ b/src/dusk/mods/manifest.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
+#include "mods/svc/hook.h"
+
 #include <cstdint>
 #include <vector>
 
-#include "mods/svc/hook.h"
-
 namespace dusk::mods::manifest {
 
 // Symbol flags mirrored from symgen.
diff --git a/src/dusk/mods/path.hpp b/src/dusk/mods/path.hpp
new file mode 100644
index 0000000000..4213c3fbf6
--- /dev/null
+++ b/src/dusk/mods/path.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <algorithm>
+#include <string>
+#include <string_view>
+
+namespace dusk::mods {
+
+inline std::string safe_filename(std::string_view value) {
+    std::string result{value};
+    std::ranges::replace_if(
+        result,
+        [](char character) {
+            return !((character >= 'a' && character <= 'z') ||
+                     (character >= 'A' && character <= 'Z') ||
+                     (character >= '0' && character <= '9') || character == '.' ||
+                     character == '_' || character == '-');
+        },
+        '_');
+    return result;
+}
+
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/queue.cpp b/src/dusk/mods/queue.cpp
new file mode 100644
index 0000000000..4be07cb2a3
--- /dev/null
+++ b/src/dusk/mods/queue.cpp
@@ -0,0 +1,769 @@
+#include "queue.hpp"
+
+#include "dusk/hash.hpp"
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/path.hpp"
+#include "dusk/ui/ui.hpp"
+
+#include <borealis/http.hpp>
+#include <borealis/io.hpp>
+#include <borealis/task.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <fstream>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace dusk::mods::queue {
+namespace {
+
+using clock = std::chrono::steady_clock;
+
+struct VerifyResult {
+    std::string error;
+    ModMetadata metadata;
+    std::filesystem::path stagedPath;
+    bool canceled = false;
+};
+
+enum class PendingIntent { None, Pause, Cancel };
+
+struct QueueItem {
+    std::string key;
+    Request request;
+    State state = State::Queued;
+    std::filesystem::path partialPath;
+    uint64_t completed = 0;
+    uint64_t total = 0;
+    std::string message;
+    int retryCount = 0;
+    clock::time_point retryAt{};
+    borealis::Task<borealis::http::Result> task;
+    borealis::Task<VerifyResult> verification;
+    ModOperationHandle operation;
+    PendingIntent pendingIntent = PendingIntent::None;
+};
+
+std::vector<QueueItem> queueItems;
+uint64_t nextQueueKey = 1;
+
+QueueItem* find_queue_item(std::string_view key) {
+    const auto item = std::ranges::find(queueItems, key,
+        [](const QueueItem& candidate) { return std::string_view{candidate.key}; });
+    return item == queueItems.end() ? nullptr : &*item;
+}
+
+QueueItem* find_queue_item_by_mod_id(std::string_view id) {
+    const auto item = std::ranges::find(queueItems, id,
+        [](const QueueItem& candidate) { return std::string_view{candidate.request.id}; });
+    return item == queueItems.end() ? nullptr : &*item;
+}
+
+const Url* url_source(const QueueItem& item) {
+    return std::get_if<Url>(&item.request.source);
+}
+
+const LocalFile* local_source(const QueueItem& item) {
+    return std::get_if<LocalFile>(&item.request.source);
+}
+
+std::string lowercase(std::string value) {
+    std::ranges::transform(value, value.begin(), [](char character) {
+        return character >= 'A' && character <= 'Z' ? static_cast<char>(character + ('a' - 'A')) :
+                                                      character;
+    });
+    return value;
+}
+
+bool valid_sha256(std::string_view value) {
+    return value.size() == 64 && std::ranges::all_of(value, [](char character) {
+        return (character >= '0' && character <= '9') || (character >= 'a' && character <= 'f') ||
+               (character >= 'A' && character <= 'F');
+    });
+}
+
+std::string sha256_file(
+    const std::filesystem::path& path, borealis::TaskContext& context, std::string& error) {
+    std::ifstream input{path, std::ios::binary};
+    if (!input) {
+        error = "Could not open the downloaded package";
+        return {};
+    }
+
+    hash::Sha256 hash;
+    std::array<uint8_t, 64 * 1024> buffer{};
+    uint64_t completed = 0;
+    while (input) {
+        if (context.cancel_requested()) {
+            error = "Canceled";
+            return {};
+        }
+        input.read(reinterpret_cast<char*>(buffer.data()), buffer.size());
+        const auto count = input.gcount();
+        if (count > 0) {
+            hash.update(std::span{buffer.data(), static_cast<size_t>(count)});
+            completed += static_cast<uint64_t>(count);
+            context.report_progress(completed);
+        }
+    }
+    if (!input.eof()) {
+        error = "Could not read the downloaded package";
+        return {};
+    }
+
+    return hash.finish();
+}
+
+std::filesystem::path staging_path(
+    const std::filesystem::path& stagingDir, std::string_view modId, std::string_view key) {
+    return stagingDir / fmt::format("{}-{}.dusk.part", safe_filename(modId), safe_filename(key));
+}
+
+bool copy_to_staging(const std::filesystem::path& source, const std::filesystem::path& destination,
+    uint64_t total, borealis::TaskContext& context, std::string& error) {
+    std::error_code filesystemError;
+    std::filesystem::create_directories(destination.parent_path(), filesystemError);
+    if (filesystemError) {
+        error =
+            fmt::format("Could not create the staging directory: {}", filesystemError.message());
+        return false;
+    }
+    std::ifstream input{source, std::ios::binary};
+    std::ofstream output{destination, std::ios::binary | std::ios::trunc};
+    if (!input || !output) {
+        error = "Could not stage the local package";
+        return false;
+    }
+    std::array<char, 64 * 1024> buffer{};
+    uint64_t completed = 0;
+    while (input) {
+        if (context.cancel_requested()) {
+            error = "Canceled";
+            output.close();
+            std::filesystem::remove(destination, filesystemError);
+            return false;
+        }
+        input.read(buffer.data(), buffer.size());
+        const auto count = input.gcount();
+        if (count > 0) {
+            output.write(buffer.data(), count);
+            completed += static_cast<uint64_t>(count);
+            context.report_progress(completed, total);
+        }
+    }
+    output.close();
+    if (!input.eof() || !output) {
+        error = "Could not copy the local package";
+        std::filesystem::remove(destination, filesystemError);
+        return false;
+    }
+    return true;
+}
+
+VerifyResult verify_url_package(const std::filesystem::path& path, const Request& request,
+    const Url& source, const std::filesystem::path& stagingDir, std::string key,
+    borealis::TaskContext& context) {
+    std::error_code ec;
+    const auto actualSize = std::filesystem::file_size(path, ec);
+    if (ec) {
+        return {.error = fmt::format("Could not read the downloaded package: {}", ec.message())};
+    }
+    if (actualSize != source.size) {
+        return {.error = "Package size mismatch"};
+    }
+
+    std::string error;
+    const auto actualHash = sha256_file(path, context, error);
+    if (!error.empty()) {
+        return {.error = std::move(error)};
+    }
+    if (context.cancel_requested()) {
+        return {.canceled = true};
+    }
+    if (actualHash != lowercase(source.sha256)) {
+        return {.error = "Package checksum mismatch"};
+    }
+
+    ModMetadata metadata;
+    if (!inspect_mod_bundle(path, metadata, error)) {
+        return {.error = fmt::format("Invalid mod package: {}", error)};
+    }
+    if (metadata.id != request.id) {
+        return {.error = "Package ID does not match the catalog entry"};
+    }
+    if (metadata.version != request.version) {
+        return {.error = "Package version does not match the catalog entry"};
+    }
+    if (context.cancel_requested()) {
+        return {.canceled = true};
+    }
+    const auto stagedPath = staging_path(stagingDir, metadata.id, key);
+    std::filesystem::create_directories(stagedPath.parent_path(), ec);
+    if (ec) {
+        return {.error = fmt::format("Could not create the staging directory: {}", ec.message())};
+    }
+    std::string replaceError;
+    if (!borealis::io::atomic_replace(path, stagedPath, replaceError)) {
+        return {.error = std::move(replaceError)};
+    }
+    return {.metadata = std::move(metadata), .stagedPath = stagedPath};
+}
+
+VerifyResult verify_local_package(const LocalFile& source, const std::filesystem::path& stagingDir,
+    std::string key, borealis::TaskContext& context) {
+    std::error_code ec;
+    const auto size = std::filesystem::file_size(source.path, ec);
+    if (ec) {
+        return {.error = fmt::format("Could not read the local package: {}", ec.message())};
+    }
+    context.report_progress(0, size);
+    const auto stagedPath = stagingDir / fmt::format("{}.dusk.part", key);
+    std::string error;
+    if (!copy_to_staging(source.path, stagedPath, size, context, error)) {
+        return {.error = std::move(error), .canceled = context.cancel_requested()};
+    }
+    // Validate the bytes handed to the loader; the source may change during copying.
+    ModMetadata metadata;
+    if (!inspect_mod_bundle(stagedPath, metadata, error)) {
+        std::filesystem::remove(stagedPath, ec);
+        return {.error = fmt::format("Invalid mod package: {}", error)};
+    }
+    return {.metadata = std::move(metadata), .stagedPath = stagedPath};
+}
+
+void remove_partial(const QueueItem& item) {
+    std::error_code ec;
+    if (!item.partialPath.empty()) {
+        std::filesystem::remove(item.partialPath, ec);
+        auto metadataPath = item.partialPath;
+        metadataPath += ".borealis-resume.json";
+        std::filesystem::remove(metadataPath, ec);
+    }
+}
+
+void fail(QueueItem& item, std::string message, bool discardPartial) {
+    item.task = {};
+    item.verification = {};
+    item.state = State::Failed;
+    item.message = std::move(message);
+    item.pendingIntent = PendingIntent::None;
+    if (discardPartial) {
+        remove_partial(item);
+        item.completed = 0;
+    }
+    const char* title =
+        local_source(item) != nullptr ? "Mod package failed" : "Mod download failed";
+    ui::push_toast({
+        .type = "warning",
+        .title = title,
+        .content = fmt::format("{}: {}", item.request.name, item.message),
+        .duration = std::chrono::seconds{6},
+    });
+}
+
+bool retryable(const borealis::http::Result& result) {
+    if (result.error == borealis::http::Error::Network ||
+        result.error == borealis::http::Error::Timeout)
+    {
+        return true;
+    }
+    const int status = result.response.statusCode;
+    return result.error == borealis::http::Error::None &&
+           (status == 408 || status == 425 || status == 429 || status >= 500);
+}
+
+void schedule_retry(QueueItem& item, std::string message) {
+    ++item.retryCount;
+    const int delaySeconds = std::min(30, 1 << std::min(item.retryCount, 4));
+    item.retryAt = clock::now() + std::chrono::seconds{delaySeconds};
+    item.state = State::Retrying;
+    item.message = std::move(message);
+    item.task = {};
+}
+
+void start_download(QueueItem& item) {
+    const auto* source = url_source(item);
+    if (source == nullptr) {
+        fail(item, "The install source is not a URL", false);
+        return;
+    }
+    const auto userDir = ModLoader::instance().user_mods_dir();
+    if (userDir.empty()) {
+        fail(item, "No writable mods directory is configured", false);
+        return;
+    }
+
+    item.partialPath =
+        userDir / ".downloads" / fmt::format("{}.dusk.part", safe_filename(item.request.id));
+    std::error_code ec;
+    std::filesystem::create_directories(item.partialPath.parent_path(), ec);
+    if (ec) {
+        fail(item, fmt::format("Could not create the download directory: {}", ec.message()), false);
+        return;
+    }
+
+    item.pendingIntent = PendingIntent::None;
+    item.message.clear();
+    item.total = source->size;
+    item.state = State::Downloading;
+    item.task = borealis::http::start({
+        .url = source->url,
+        .downloadTo = item.partialPath,
+        .connectTimeout = std::chrono::seconds{10},
+        .idleTimeout = std::chrono::seconds{15},
+        .totalTimeout = std::nullopt,
+    });
+}
+
+void start_local_verification(QueueItem& item) {
+    const auto* source = local_source(item);
+    if (source == nullptr) {
+        fail(item, "The install source is not a local file", false);
+        return;
+    }
+    const auto userDir = ModLoader::instance().user_mods_dir();
+    if (userDir.empty()) {
+        fail(item, "No writable mods directory is configured", false);
+        return;
+    }
+    item.state = State::Verifying;
+    item.message.clear();
+    item.completed = 0;
+    std::error_code error;
+    item.total = std::filesystem::file_size(source->path, error);
+    const auto stagingDir = userDir / ".staging";
+    const auto local = *source;
+    item.verification =
+        borealis::spawn([local, stagingDir, key = item.key](borealis::TaskContext& context) {
+            return verify_local_package(local, stagingDir, key, context);
+        });
+}
+
+void finish_download(QueueItem& item) {
+    const auto progress = item.task.progress();
+    item.completed = std::max(item.completed, progress.completed);
+
+    std::optional<borealis::http::Result> completed;
+    std::string taskError;
+    bool taskFailed = false;
+    try {
+        completed = item.task.try_take();
+    } catch (const std::exception& exception) {
+        taskError = exception.what();
+        taskFailed = true;
+    } catch (...) {
+        taskError = "The download failed";
+        taskFailed = true;
+    }
+    if (!completed && !taskFailed) {
+        return;
+    }
+    item.task = {};
+
+    switch (std::exchange(item.pendingIntent, PendingIntent::None)) {
+    case PendingIntent::Cancel:
+        remove_partial(item);
+        item.completed = 0;
+        item.state = State::Canceled;
+        return;
+    case PendingIntent::Pause:
+        return;
+    case PendingIntent::None:
+        break;
+    }
+
+    if (taskFailed) {
+        schedule_retry(item, std::move(taskError));
+        return;
+    }
+
+    if (completed->error != borealis::http::Error::None || completed->response.statusCode < 200 ||
+        completed->response.statusCode >= 300)
+    {
+        const auto message = !completed->message.empty() ? completed->message :
+                             completed->response.statusCode != 0 ?
+                                                           fmt::format("Server returned HTTP {}",
+                                                               completed->response.statusCode) :
+                                                           "The download failed";
+        if (retryable(*completed)) {
+            schedule_retry(item, message);
+        } else {
+            fail(item, message, true);
+        }
+        return;
+    }
+
+    const auto* source = url_source(item);
+    if (source == nullptr) {
+        fail(item, "The install source changed", true);
+        return;
+    }
+    item.completed = source->size;
+    item.state = State::Verifying;
+    item.message.clear();
+    const auto stagingDir = ModLoader::instance().user_mods_dir() / ".staging";
+    item.verification =
+        borealis::spawn([path = item.partialPath, request = item.request, source = *source,
+                            stagingDir, key = item.key](borealis::TaskContext& context) {
+            return verify_url_package(path, request, source, stagingDir, key, context);
+        });
+}
+
+void finish_verification(QueueItem& item) {
+    VerifyResult result;
+    try {
+        auto completed = item.verification.try_take();
+        if (!completed) {
+            return;
+        }
+        result = std::move(*completed);
+    } catch (const std::exception& exception) {
+        result.error = exception.what();
+    } catch (...) {
+        result.error = "Package verification failed";
+    }
+    item.verification = {};
+    if (result.canceled || item.pendingIntent == PendingIntent::Cancel) {
+        item.pendingIntent = PendingIntent::None;
+        if (!result.stagedPath.empty()) {
+            std::error_code error;
+            std::filesystem::remove(result.stagedPath, error);
+        }
+        remove_partial(item);
+        item.state = State::Canceled;
+        item.completed = 0;
+        return;
+    }
+    if (!result.error.empty()) {
+        fail(item, std::move(result.error), true);
+        return;
+    }
+    remove_partial(item);
+    item.partialPath = result.stagedPath;
+    if (const auto duplicate = find_queue_item_by_mod_id(result.metadata.id);
+        duplicate != nullptr && duplicate != &item && !is_terminal(duplicate->state))
+    {
+        fail(item, "This mod already has an active install", true);
+        return;
+    }
+    if (local_source(item) != nullptr && !item.request.id.empty() &&
+        (item.request.id != result.metadata.id || item.request.version != result.metadata.version))
+    {
+        fail(item, "The local package changed after confirmation", true);
+        return;
+    }
+    item.request.id = result.metadata.id;
+    item.request.name = result.metadata.name;
+    item.request.version = result.metadata.version;
+    item.completed = item.total;
+    item.state = State::Handoff;
+    item.operation = ModLoader::instance().request_install(std::move(result.stagedPath));
+}
+
+Item snapshot(const QueueItem& item) {
+    Item result{
+        .id = item.key,
+        .modId = item.request.id,
+        .name = item.request.name,
+        .version = item.request.version,
+        .state = item.state,
+        .completed = item.completed,
+        .total = item.total,
+        .message = item.message,
+        .local = local_source(item) != nullptr,
+        .icon = item.request.icon,
+    };
+    if (item.task) {
+        result.completed = std::max(result.completed, item.task.progress().completed);
+    }
+    if (item.verification) {
+        const auto progress = item.verification.progress();
+        result.completed = progress.completed;
+        if (progress.total) {
+            result.total = *progress.total;
+        }
+    }
+    if (item.state == State::Retrying) {
+        const auto remaining = item.retryAt - clock::now();
+        result.retrySeconds = std::max(
+            0, static_cast<int>(std::chrono::ceil<std::chrono::seconds>(remaining).count()));
+    }
+    return result;
+}
+
+}  // namespace
+
+bool enqueue(Request request, std::string* keyOut) {
+    const auto* source = std::get_if<Url>(&request.source);
+    const auto* local = std::get_if<LocalFile>(&request.source);
+    if (source != nullptr) {
+        if (request.id.empty() || request.version.empty() || source->size == 0 ||
+            !source->url.starts_with("https://") || !valid_sha256(source->sha256))
+        {
+            return false;
+        }
+    } else if (local == nullptr || request.id.empty() || request.version.empty()) {
+        return false;
+    }
+    const auto total = source == nullptr ? 0 : source->size;
+    if (request.name.empty()) {
+        request.name = request.id;
+    }
+
+    if (auto* existing = find_queue_item_by_mod_id(request.id)) {
+        if (!is_terminal(existing->state)) {
+            return false;
+        }
+        existing->request = std::move(request);
+        existing->state = State::Queued;
+        existing->completed = 0;
+        existing->total = total;
+        existing->partialPath.clear();
+        existing->message.clear();
+        existing->retryCount = 0;
+        existing->operation.reset();
+        existing->pendingIntent = PendingIntent::None;
+        if (keyOut != nullptr) {
+            *keyOut = existing->key;
+        }
+        return true;
+    }
+
+    const auto key = fmt::format("queue-{}", nextQueueKey++);
+    if (keyOut != nullptr) {
+        *keyOut = key;
+    }
+    queueItems.push_back({.key = key, .request = std::move(request), .total = total});
+    return true;
+}
+
+void update() {
+    for (auto item = queueItems.begin(); item != queueItems.end();) {
+        if (item->task && item->task.ready()) {
+            finish_download(*item);
+        }
+        if (item->state == State::Verifying && item->verification && item->verification.ready()) {
+            finish_verification(*item);
+        }
+        if (item->state == State::Handoff && item->operation &&
+            item->operation->state != ModOperation::State::Pending)
+        {
+            item->message = item->operation->message;
+            item->state = item->operation->state == ModOperation::State::Succeeded ?
+                              State::Installed :
+                              State::InstallFailed;
+            item->operation.reset();
+        }
+        ++item;
+    }
+
+    for (auto& item : queueItems) {
+        if (item.task || item.verification || item.operation) {
+            return;
+        }
+        if (is_terminal(item.state) || item.state == State::Paused) {
+            continue;
+        }
+        if (item.state == State::Downloading || item.state == State::Verifying) {
+            return;
+        }
+        if (item.state == State::Retrying && clock::now() < item.retryAt) {
+            return;
+        }
+        if (item.state == State::Queued || item.state == State::Retrying) {
+            if (local_source(item) != nullptr) {
+                start_local_verification(item);
+            } else {
+                start_download(item);
+            }
+        }
+        return;
+    }
+}
+
+void shutdown() noexcept {
+    for (auto& item : queueItems) {
+        if (item.task) {
+            item.task.cancel();
+        }
+        if (item.verification) {
+            item.verification.cancel();
+        }
+    }
+    queueItems.clear();
+}
+
+std::vector<Item> items() {
+    std::vector<Item> result;
+    result.reserve(queueItems.size());
+    for (const auto& item : queueItems) {
+        result.push_back(snapshot(item));
+    }
+    return result;
+}
+
+std::optional<Item> find(std::string_view id) {
+    const auto* item = find_queue_item(id);
+    return item == nullptr ? std::nullopt : std::optional<Item>{snapshot(*item)};
+}
+
+std::optional<Item> find_by_mod_id(std::string_view id) {
+    const auto* item = find_queue_item_by_mod_id(id);
+    return item == nullptr ? std::nullopt : std::optional<Item>{snapshot(*item)};
+}
+
+bool has_active_items() {
+    return std::ranges::any_of(
+        queueItems, [](const QueueItem& item) { return !is_terminal(item.state); });
+}
+
+size_t item_count() noexcept {
+    return queueItems.size();
+}
+
+size_t active_count() noexcept {
+    return static_cast<size_t>(std::ranges::count_if(
+        queueItems, [](const QueueItem& item) { return !is_terminal(item.state); }));
+}
+
+std::optional<Item> first_active() {
+    const auto item = std::ranges::find_if(
+        queueItems, [](const QueueItem& candidate) { return !is_terminal(candidate.state); });
+    return item == queueItems.end() ? std::nullopt : std::optional<Item>{snapshot(*item)};
+}
+
+size_t active_items_ahead(std::string_view id) noexcept {
+    size_t result = 0;
+    for (const auto& item : queueItems) {
+        if (item.request.id == id) {
+            break;
+        }
+        if (!is_terminal(item.state)) {
+            ++result;
+        }
+    }
+    return result;
+}
+
+void pause(std::string_view id) {
+    auto* item = find_queue_item(id);
+    if (item == nullptr || local_source(*item) != nullptr ||
+        item->pendingIntent == PendingIntent::Cancel)
+    {
+        return;
+    }
+    if (item->state == State::Queued || item->state == State::Retrying) {
+        item->state = State::Paused;
+        return;
+    }
+    if (item->state == State::Downloading && item->task) {
+        item->completed = std::max(item->completed, item->task.progress().completed);
+        item->pendingIntent = PendingIntent::Pause;
+        item->state = State::Paused;
+        item->task.cancel();
+    }
+}
+
+void resume(std::string_view id) {
+    auto* item = find_queue_item(id);
+    if (item == nullptr || item->state != State::Paused ||
+        item->pendingIntent == PendingIntent::Cancel)
+    {
+        return;
+    }
+    item->state = State::Queued;
+}
+
+void retry(std::string_view id) {
+    auto* item = find_queue_item(id);
+    if (item == nullptr) {
+        return;
+    }
+    if (item->state == State::InstallFailed) {
+        auto* mod = ModLoader::instance().find_mod(item->request.id);
+        if (mod != nullptr) {
+            if (mod->activation_failed()) {
+                item->message.clear();
+                item->state = State::Handoff;
+                item->operation = ModLoader::instance().request_reactivate(item->request.id);
+            } else {
+                item->message.clear();
+                item->state = State::Installed;
+            }
+            return;
+        }
+    } else if (item->state != State::Failed) {
+        return;
+    }
+    remove_partial(*item);
+    item->completed = 0;
+    item->retryCount = 0;
+    item->message.clear();
+    item->state = State::Queued;
+}
+
+void cancel(std::string_view id) {
+    auto* item = find_queue_item(id);
+    if (item == nullptr || item->state == State::Handoff || is_terminal(item->state)) {
+        return;
+    }
+    if (item->task) {
+        item->pendingIntent = PendingIntent::Cancel;
+        item->message = "Canceling...";
+        item->task.cancel();
+        return;
+    }
+    if (item->verification) {
+        item->pendingIntent = PendingIntent::Cancel;
+        item->message = "Canceling...";
+        item->verification.cancel();
+        return;
+    }
+    remove_partial(*item);
+    item->pendingIntent = PendingIntent::None;
+    item->completed = 0;
+    item->state = State::Canceled;
+}
+
+void clear(std::string_view id) {
+    const auto item = std::ranges::find(
+        queueItems, id, [](const QueueItem& candidate) { return std::string_view{candidate.key}; });
+    if (item != queueItems.end() && is_terminal(item->state)) {
+        queueItems.erase(item);
+    }
+}
+
+void remove_by_mod_id(std::string_view id) {
+    std::erase_if(queueItems,
+        [id](const QueueItem& item) { return std::string_view{item.request.id} == id; });
+}
+
+void pause_all() {
+    std::vector<std::string> ids;
+    for (const auto& item : queueItems) {
+        if (item.state == State::Queued || item.state == State::Retrying ||
+            item.state == State::Downloading)
+        {
+            ids.push_back(item.key);
+        }
+    }
+    for (const auto& id : ids) {
+        pause(id);
+    }
+}
+
+void clear_finished() {
+    std::erase_if(queueItems, [](const QueueItem& item) { return is_terminal(item.state); });
+}
+
+}  // namespace dusk::mods::queue
diff --git a/src/dusk/mods/queue.hpp b/src/dusk/mods/queue.hpp
new file mode 100644
index 0000000000..85481d6b4a
--- /dev/null
+++ b/src/dusk/mods/queue.hpp
@@ -0,0 +1,101 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <variant>
+#include <vector>
+
+namespace dusk::mods::queue {
+
+enum class State {
+    Queued,
+    Downloading,
+    Paused,
+    Retrying,
+    Verifying,
+    Handoff,
+    Installed,
+    InstallFailed,
+    Failed,
+    Canceled,
+};
+
+[[nodiscard]] constexpr bool is_terminal(State state) noexcept {
+    return state == State::Installed || state == State::InstallFailed || state == State::Failed ||
+           state == State::Canceled;
+}
+
+[[nodiscard]] constexpr bool is_install_result(State state) noexcept {
+    return state == State::Installed || state == State::InstallFailed;
+}
+
+struct Url {
+    std::string url;
+    std::string sha256;
+    uint64_t size = 0;
+};
+
+struct LocalFile {
+    std::filesystem::path path;
+};
+
+using Source = std::variant<Url, LocalFile>;
+
+struct Icon {
+    std::string url;
+    uint32_t width = 0;
+    uint32_t height = 0;
+};
+
+struct Request {
+    std::string id;
+    std::string name;
+    std::string version;
+    Source source;
+    std::optional<Icon> icon;
+};
+
+struct Item {
+    // Queue key, independent of the mod ID.
+    std::string id;
+    std::string modId;
+    std::string name;
+    std::string version;
+    State state = State::Queued;
+    uint64_t completed = 0;
+    uint64_t total = 0;
+    std::string message;
+    int retrySeconds = 0;
+    bool local = false;
+    std::optional<Icon> icon;
+};
+
+/** Adds an install, replacing failed or canceled work for the same package ID. */
+bool enqueue(Request request, std::string* key = nullptr);
+
+void update();
+void shutdown() noexcept;
+
+[[nodiscard]] std::vector<Item> items();
+[[nodiscard]] std::optional<Item> find(std::string_view key);
+[[nodiscard]] std::optional<Item> find_by_mod_id(std::string_view id);
+[[nodiscard]] bool has_active_items();
+[[nodiscard]] size_t item_count() noexcept;
+[[nodiscard]] size_t active_count() noexcept;
+[[nodiscard]] std::optional<Item> first_active();
+[[nodiscard]] size_t active_items_ahead(std::string_view id) noexcept;
+
+void pause(std::string_view id);
+void resume(std::string_view id);
+void retry(std::string_view id);
+void cancel(std::string_view id);
+void clear(std::string_view id);
+void remove_by_mod_id(std::string_view id);
+void pause_all();
+void clear_finished();
+
+}  // namespace dusk::mods::queue
diff --git a/src/dusk/mods/svc/actor.cpp b/src/dusk/mods/svc/actor.cpp
new file mode 100644
index 0000000000..19aa8c9c20
--- /dev/null
+++ b/src/dusk/mods/svc/actor.cpp
@@ -0,0 +1,401 @@
+#include "mods/svc/actor.h"
+
+#include "actor.hpp"
+#include "internal.hpp"
+#include "registry.hpp"
+
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/loader/loader.hpp"
+
+#include "d/d_stage.h"
+#include "f_op/f_op_actor_tag.h"
+#include "f_pc/f_pc_deletor.h"
+
+#include <aurora/lib/logging.hpp>
+
+#include <vector>
+
+namespace dusk::mods::svc::actor_impl {
+namespace {
+
+aurora::Module Log("dusk::mods::actor");
+
+SlotMap<std::unique_ptr<ActorSlot>> s_slots;
+std::unordered_map<s16, ActorHandle> procNameToHandle;
+std::unordered_map<std::string, ActorHandle> fullNameToHandle;
+
+ActorSlot* get_actor_slot(void* actorPtr) {
+    auto* actor = static_cast<fopAc_ac_c*>(actorPtr);
+    const auto handle = procNameToHandle.find(actor->name);
+    if (handle == procNameToHandle.end()) {
+        return nullptr;
+    }
+    auto* slot = s_slots.find(handle->second);
+    return slot != nullptr ? slot->value.get() : nullptr;
+}
+
+int actor_is_delete(void* actorPtr) {
+    auto* slot = get_actor_slot(actorPtr);
+    if (slot == nullptr || slot->forceDelete) {
+        return 1;
+    }
+    return slot->isDeleteFunction(actorPtr);
+}
+
+int actor_delete(void* actorPtr) {
+    auto* slot = get_actor_slot(actorPtr);
+    if (slot == nullptr) {
+        return 1;
+    }
+    const bool forceDelete = slot->forceDelete;
+    const int result = slot->deleteFunction(actorPtr);
+    return forceDelete ? 1 : result;
+}
+
+ModResult register_actor(ModContext* ctx, const ActorProfileDesc* desc, ProfileName* outProfileName,
+    ActorHandle* outActorHandle) {
+    auto* owner = mod_from_context(ctx);
+    if (owner == nullptr || desc == nullptr || outProfileName == nullptr ||
+        outActorHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (desc->name[0] == '\0' || std::memchr(desc->name, '\0', sizeof(desc->name)) == nullptr ||
+        desc->process_size < sizeof(fopAc_ac_c) || desc->create_function == nullptr ||
+        desc->delete_function == nullptr || desc->execute_function == nullptr ||
+        desc->is_delete_function == nullptr || desc->draw_function == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    // If another mod has already registered an actor with this name, note a conflict
+    if (get_stageinfo_from_full_name(desc->name)) {
+        return MOD_CONFLICT;
+    }
+
+    const auto handle = s_slots.emplace(*owner,
+        std::make_unique<ActorSlot>(
+            ActorSlot{{desc->create_function, actor_delete, desc->execute_function, actor_is_delete,
+                          desc->draw_function},
+                desc->delete_function, desc->is_delete_function, false,
+                {
+                    {},  // Set after registered
+                    0,   // Set after registered to a slot
+                    -1   // Use the default argument
+                },
+                {
+                    /* Layer ID     */ fpcLy_CURRENT_e,
+                    /* List ID      */ desc->priority_group,
+                    /* List Prio    */ fpcPi_CURRENT_e,  // Always fpcPi_CURRENT_e
+                    /* Proc Name    */ 0,
+                    /* Proc SubMtd  */ &g_fpcLf_Method.base,  // usually: &g_fpcLf_Method.base
+                    /* Size         */ (u32)desc->process_size,
+                    /* Size Other   */ 0,                     // Always 0
+                    /* Parameters   */ 0,                     // Always 0
+                    /* Leaf SubMtd  */ &g_fopAc_Method.base,  // usually &g_fopAc_Method.base
+                    /* Draw Prio    */ desc->draw_priority,
+                    /* Actor SubMtd */ nullptr,  // set this later
+                    /* Status       */ desc->status,
+                    /* Group        */ desc->group,
+                    /* Cull Type    */ desc->cull_type,
+                }}));
+
+    s32 procNameFull = fpcNm_MAX_NUM + s_slots.index_of(handle);
+    if (procNameFull >= 0x7FFF) {
+        s_slots.erase(handle);
+        Log.error("Hit registered actor limit (0x7FFF) while registering actor {}", desc->name);
+        return MOD_ERROR;
+    }
+
+    ActorSlot& slot = *s_slots.find(handle)->value.get();
+    strncpy(slot.objNameInf.name, desc->name, sizeof(slot.objNameInf.name) - 1);
+    slot.profile.sub_method = &slot.methodTable;
+    s16 procName = (s16)procNameFull;
+    procNameToHandle[procName] = handle;
+    fullNameToHandle[std::string(slot.objNameInf.name)] = handle;
+    slot.objNameInf.procname = (s16)procName;
+    slot.profile.base.base.name = procName;
+    *outProfileName = procName;
+    *outActorHandle = handle;
+
+    return MOD_OK;
+}
+
+// Must be called before the slot associated with the handle is erased
+void remove_handle_from_maps(ActorHandle handle) {
+    auto entry = s_slots.find(handle);
+    if (entry == nullptr) {
+        return;
+    }
+
+    std::string fullName = entry->value->objNameInf.name;
+
+    const auto it = fullNameToHandle.find(fullName);
+    if (it != fullNameToHandle.end()) {
+        fullNameToHandle.erase(it);
+    }
+
+    const auto it2 = procNameToHandle.find(entry->value->profile.base.base.name);
+    if (it2 != procNameToHandle.end()) {
+        procNameToHandle.erase(it2);
+    }
+}
+
+void request_delete_all_actors_of_name(s16 procName) {
+    node_class* node = g_fopAcTg_Queue.mpHead;
+    while (node != nullptr) {
+        node_class* next = NODE_GET_NEXT(node);
+        auto* actor =
+            static_cast<fopAc_ac_c*>(reinterpret_cast<create_tag_class*>(node)->mpTagData);
+        if (actor->name == procName) {
+            fopAcM_delete(actor);
+        }
+        node = next;
+    }
+}
+
+bool finish_delete_all_actors_of_name(s16 procName) {
+    bool complete = true;
+
+    node_class* node = g_fpcDtTg_Queue.mpHead;
+    while (node != nullptr) {
+        node_class* next = NODE_GET_NEXT(node);
+        auto* tag = reinterpret_cast<delete_tag_class*>(node);
+        auto* proc = static_cast<base_process_class*>(tag->base.mpTagData);
+        if (proc->name == procName) {
+            tag->timer = 0;
+            const int deleteStatus = fpcDtTg_Do(
+                tag, [](void* proc) { return fpcDt_deleteMethod((base_process_class*)proc); });
+            if (deleteStatus == 0) {
+                complete = false;
+            }
+        }
+        node = next;
+    }
+    return complete;
+}
+
+bool has_actor_of_name(s16 procName) {
+    node_class* node = g_fopAcTg_Queue.mpHead;
+    while (node != nullptr) {
+        auto* actor =
+            static_cast<fopAc_ac_c*>(reinterpret_cast<create_tag_class*>(node)->mpTagData);
+        if (actor->name == procName) {
+            return true;
+        }
+        node = NODE_GET_NEXT(node);
+    }
+    return false;
+}
+
+ModResult unregister_actor(ModContext* ctx, ActorHandle handle) {
+    auto* owner = mod_from_context(ctx);
+    if (owner == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* slot = s_slots.find_owned(handle, *owner);
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    const s16 actorProcName = slot->value->profile.base.base.name;
+    slot->value->forceDelete = true;
+    request_delete_all_actors_of_name(actorProcName);
+    const bool deletesFinished = finish_delete_all_actors_of_name(actorProcName);
+    if (!deletesFinished || has_actor_of_name(actorProcName)) {
+        slot->value->forceDelete = false;
+        Log.warn("Actor profile '{}' could not be unregistered synchronously",
+            slot->value->objNameInf.name);
+        return MOD_UNAVAILABLE;
+    }
+
+    remove_handle_from_maps(handle);
+    s_slots.erase_owned(handle, *owner);
+
+    return MOD_OK;
+}
+
+ModResult create_actor(
+    ModContext* ctx, ProfileName name, const ActorSpawnParams* params, ActorId* outId) {
+    cXyz pos = {params->position.x, params->position.y, params->position.z};
+    csXyz angle = {params->angle.x, params->angle.y, params->angle.z};
+    cXyz scale = {params->scale.x, params->scale.y, params->scale.z};
+    fpc_ProcID id = fopAcM_create(name, 0xFFFF, params->parameters, &pos, params->room_num, &angle,
+        &scale, params->argument, params->create_function);
+
+    if (id == fpcM_ERROR_PROCESS_ID_e) {
+        Log.error("Error Creating Actor with profile name {}", name);
+        return MOD_ERROR;
+    }
+
+    if (outId) {
+        *outId = id;
+    }
+    return MOD_OK;
+}
+
+ModResult create_actor_from_name(
+    ModContext* ctx, const char* name, const ActorSpawnParams* params, ActorId* outId) {
+    dStage_objectNameInf* objectName = dStage_searchName(name);
+    if (objectName == nullptr) {
+        Log.error("Attempted to create actor ({}) but it can't be found!", name);
+        return MOD_ERROR;
+    }
+
+    ActorSpawnParams copy = *params;
+    copy.argument = objectName->argument;
+
+    return create_actor(ctx, objectName->procname, &copy, outId);
+}
+
+ModResult create_child_actor(ModContext* ctx, ProfileName name, ActorId parentID,
+    const ActorSpawnParams* params, ActorId* outId) {
+    cXyz pos = {params->position.x, params->position.y, params->position.z};
+    csXyz angle = {params->angle.x, params->angle.y, params->angle.z};
+    cXyz scale = {params->scale.x, params->scale.y, params->scale.z};
+    fpc_ProcID id = fopAcM_createChild(name, parentID, params->parameters, &pos, params->room_num,
+        &angle, &scale, params->argument, params->create_function);
+
+    if (id == fpcM_ERROR_PROCESS_ID_e) {
+        Log.error("Error Creating Actor with profile name {} as child of actor with id {}", name,
+            parentID);
+        return MOD_ERROR;
+    }
+
+    if (outId) {
+        *outId = id;
+    }
+    return MOD_OK;
+}
+
+ModResult create_child_actor_from_name(ModContext* ctx, const char* name, ActorId parentID,
+    const ActorSpawnParams* params, ActorId* outId) {
+    dStage_objectNameInf* objectName = dStage_searchName(name);
+    if (objectName == nullptr) {
+        Log.error("Attempted to create actor ({}) but it can't be found!", name);
+        return MOD_ERROR;
+    }
+
+    ActorSpawnParams copy = *params;
+    copy.argument = objectName->argument;
+
+    return create_child_actor(ctx, objectName->procname, parentID, &copy, outId);
+}
+
+ModResult get_actor_id(ModContext* ctx, ProfileName name, ActorId* outId) {
+    fopAc_ac_c* actor = fopAcM_SearchByName(name);
+    if (actor == nullptr) {
+        Log.error("Attempting to get actor by profile name ({}) but it doesn't exist!", name);
+        return MOD_ERROR;
+    }
+
+    *outId = fopAcM_GetID(actor);
+    return MOD_OK;
+}
+
+ModResult get_actor_room_num(ModContext* ctx, ActorId actorId, int8_t* outRoomNum) {
+    fopAc_ac_c* actor = fopAcM_SearchByID(actorId);
+    if (actor == nullptr) {
+        Log.error("Attempted to get room number of actor Id ({}) but it doesn't exist!", actorId);
+        return MOD_ERROR;
+    }
+
+    *outRoomNum = fopAcM_GetRoomNo(actor);
+    return MOD_OK;
+}
+
+ModResult delete_actor(ModContext* ctx, ActorId actorId) {
+    if (mod_from_context(ctx) == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    fopAc_ac_c* actor = fopAcM_SearchByID(actorId);
+    if (actor == nullptr) {
+        Log.warn("Attempted to delete actor with ID ({}) but it doesn't exist!", actorId);
+        return MOD_OK;
+    }
+    return fopAcM_delete(actor) != 0 ? MOD_OK : MOD_UNAVAILABLE;
+}
+
+}  // namespace
+
+process_profile_definition* get_profile_from_proc_name(s16 name) {
+    const auto& it = procNameToHandle.find(name);
+    if (it == procNameToHandle.end()) {
+        return nullptr;
+    }
+    auto entry = s_slots.find(it->second);
+    if (entry) {
+        return &entry->value->profile.base.base;
+    }
+    return nullptr;
+}
+
+const char* get_full_name_from_proc_name(s16 name) {
+    const auto& it = procNameToHandle.find(name);
+    if (it == procNameToHandle.end()) {
+        return "";
+    }
+    auto entry = s_slots.find(it->second);
+    if (entry) {
+        return entry->value->objNameInf.name;
+    }
+    return "";
+}
+
+dStage_objectNameInf* get_stageinfo_from_full_name(const std::string& name) {
+    const auto& it = fullNameToHandle.find(name);
+    if (it == fullNameToHandle.end()) {
+        return nullptr;
+    }
+    auto entry = s_slots.find(it->second);
+    if (entry) {
+        return &entry->value->objNameInf;
+    }
+    return nullptr;
+}
+
+void actor_remove_mod(LoadedMod& mod) {
+    std::vector<ActorHandle> handles;
+    s_slots.for_each([&](const ActorHandle handle, const auto& slot) {
+        if (slot.owner == &mod) {
+            handles.push_back(handle);
+        }
+    });
+
+    for (const auto handle : handles) {
+        const auto result = unregister_actor(mod.context.get(), handle);
+        if (result != MOD_OK) {
+            Log.error("Actor profile could not be removed during mod deactivation");
+        }
+    }
+}
+
+}  // namespace dusk::mods::svc::actor_impl
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr ActorService s_actorService{
+    .header = SERVICE_HEADER(ActorService, ACTOR_SERVICE_MAJOR, ACTOR_SERVICE_MINOR),
+    .register_actor = actor_impl::register_actor,
+    .unregister_actor = actor_impl::unregister_actor,
+    .create_actor_from_name = actor_impl::create_actor_from_name,
+    .create_actor = actor_impl::create_actor,
+    .create_child_actor_from_name = actor_impl::create_child_actor_from_name,
+    .create_child_actor = actor_impl::create_child_actor,
+    .get_actor_id = actor_impl::get_actor_id,
+    .get_actor_room_num = actor_impl::get_actor_room_num,
+    .delete_actor = actor_impl::delete_actor,
+};
+
+}
+
+constinit const ServiceModule g_actorModule{
+    .id = ACTOR_SERVICE_ID,
+    .majorVersion = ACTOR_SERVICE_MAJOR,
+    .minorVersion = ACTOR_SERVICE_MINOR,
+    .service = &s_actorService,
+    .modDeactivating = actor_impl::actor_remove_mod,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/actor.hpp b/src/dusk/mods/svc/actor.hpp
new file mode 100644
index 0000000000..7e68760503
--- /dev/null
+++ b/src/dusk/mods/svc/actor.hpp
@@ -0,0 +1,24 @@
+#pragma once
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include "f_op/f_op_actor_mng.h"
+
+namespace dusk::mods::svc::actor_impl {
+
+struct ActorSlot {
+    actor_method_class methodTable;
+    int (*deleteFunction)(void*);
+    int (*isDeleteFunction)(void*);
+    bool forceDelete;
+    dStage_objectNameInf objNameInf;
+    actor_process_profile_definition profile;
+};
+
+process_profile_definition* get_profile_from_proc_name(s16 name);
+
+dStage_objectNameInf* get_stageinfo_from_full_name(const std::string& name);
+
+const char* get_full_name_from_proc_name(s16 name);  // Returns "" when not found
+
+};  // namespace dusk::mods::svc::actor_impl
diff --git a/src/dusk/mods/svc/camera.cpp b/src/dusk/mods/svc/camera.cpp
new file mode 100644
index 0000000000..b93ea00e62
--- /dev/null
+++ b/src/dusk/mods/svc/camera.cpp
@@ -0,0 +1,266 @@
+#include "internal.hpp"
+#include "registry.hpp"
+
+#include "dusk/camera_operators.hpp"
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/camera.h"
+
+#include "SSystem/SComponent/c_angle.h"
+#include "d/d_camera.h"
+#include "d/d_com_inf_game.h"
+#include "f_op/f_op_camera_mng.h"
+#include "f_op/f_op_view.h"
+#include "m_Do/m_Do_mtx.h"
+
+#include <algorithm>
+#include <aurora/gfx.hpp>
+#include <cstring>
+#include <exception>
+#include <fmt/format.h>
+#include <string>
+#include <vector>
+
+namespace dusk::mods::svc {
+namespace {
+
+void to_column_major(const Mtx44 in, float out[16]) {
+    for (int c = 0; c < 4; ++c) {
+        for (int r = 0; r < 4; ++r) {
+            out[c * 4 + r] = in[r][c];
+        }
+    }
+}
+
+void store_affine(const Mtx in, float out[16]) {
+    for (int c = 0; c < 4; ++c) {
+        for (int r = 0; r < 3; ++r) {
+            out[c * 4 + r] = in[r][c];
+        }
+        out[c * 4 + 3] = 0.0f;
+    }
+    out[15] = 1.0f;
+}
+
+/* affine * 4x4; operand-order mirror of cMtx_concatProjView */
+void concat_affine_proj(const Mtx a, const Mtx44 b, Mtx44 out) {
+    for (int r = 0; r < 3; ++r) {
+        for (int c = 0; c < 4; ++c) {
+            out[r][c] =
+                a[r][0] * b[0][c] + a[r][1] * b[1][c] + a[r][2] * b[2][c] + a[r][3] * b[3][c];
+        }
+    }
+    std::memcpy(out[3], b[3], sizeof(f32) * 4);
+}
+
+ModResult snapshot_view(const view_class* view, CameraInfo* outInfo) {
+    if (view == nullptr || !(view->near_ > 0.0f) || !(view->far_ > view->near_) ||
+        !(view->fovy > 0.0f) || view->fovy >= 180.0f || !(view->aspect > 0.0f))
+    {
+        return MOD_UNAVAILABLE;
+    }
+
+    // Build from the GXSetProjection values
+    const f32 p00 = view->projMtx[0][0];
+    const f32 p02 = view->projMtx[0][2];
+    const f32 p11 = view->projMtx[1][1];
+    const f32 p12 = view->projMtx[1][2];
+    const f32 p22 = view->projMtx[2][2];
+    const f32 p23 = view->projMtx[2][3];
+    if (view->projMtx[3][2] != -1.0f || p00 == 0.0f || p11 == 0.0f || p23 == 0.0f) {
+        return MOD_UNAVAILABLE;
+    }
+
+    // WebGPU-convention projection + Aurora reversed Z
+    const bool reversedZ = aurora::gfx::uses_reversed_z();
+    const f32 e = reversedZ ? -p22 : p22 - 1.0f;
+    const f32 f = reversedZ ? -p23 : p23;
+    Mtx44 proj{};
+    proj[0][0] = p00;
+    proj[0][2] = p02;
+    proj[1][1] = p11;
+    proj[1][2] = p12;
+    proj[2][2] = e;
+    proj[2][3] = f;
+    proj[3][2] = -1.0f;
+
+    // Analytic inverse of the sparse perspective form
+    Mtx44 invProj{};
+    invProj[0][0] = 1.0f / p00;
+    invProj[0][3] = p02 / p00;
+    invProj[1][1] = 1.0f / p11;
+    invProj[1][3] = p12 / p11;
+    invProj[2][3] = -1.0f;
+    invProj[3][2] = 1.0f / f;
+    invProj[3][3] = e / f;
+
+    Mtx44 projWorld;
+    cMtx_concatProjView(proj, view->viewMtx, projWorld);
+    Mtx44 worldProj;
+    concat_affine_proj(view->invViewMtx, invProj, worldProj);
+
+    store_affine(view->viewMtx, outInfo->view_from_world);
+    store_affine(view->invViewMtx, outInfo->world_from_view);
+    to_column_major(proj, outInfo->proj_from_view);
+    to_column_major(invProj, outInfo->view_from_proj);
+    to_column_major(projWorld, outInfo->proj_from_world);
+    to_column_major(worldProj, outInfo->world_from_proj);
+
+    outInfo->eye[0] = view->lookat.eye.x;
+    outInfo->eye[1] = view->lookat.eye.y;
+    outInfo->eye[2] = view->lookat.eye.z;
+    outInfo->fovy = view->fovy;
+    outInfo->aspect = view->aspect;
+    outInfo->near_plane = view->near_;
+    outInfo->far_plane = view->far_;
+    return MOD_OK;
+}
+
+ModResult camera_get_camera_from_view(
+    ModContext* context, const void* gameView, CameraInfo* outInfo) {
+    if (outInfo == nullptr || outInfo->struct_size < sizeof(CameraInfo) ||
+        mod_from_context(context) == nullptr || gameView == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const uint32_t structSize = outInfo->struct_size;
+    std::memset(outInfo, 0, sizeof(CameraInfo));
+    outInfo->struct_size = structSize;
+    return snapshot_view(static_cast<const view_class*>(gameView), outInfo);
+}
+
+struct CameraOperator {
+    std::string debugName;
+    int32_t priority = 0;
+    uint64_t sequence = 0;
+    CameraOperateFn operate = nullptr;
+    void* userData = nullptr;
+};
+
+SlotMap<CameraOperator> sOperators;
+uint64_t sNextOperatorSequence = 0;
+
+ModResult camera_register_operator(
+    ModContext* context, const CameraOperatorDesc* desc, CameraOperatorHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(CameraOperatorDesc) ||
+        desc->debug_name == nullptr || desc->debug_name[0] == '\0' || desc->operate == nullptr ||
+        outHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    *outHandle = sOperators.emplace(*mod, CameraOperator{
+                                              .debugName = desc->debug_name,
+                                              .priority = desc->priority,
+                                              .sequence = sNextOperatorSequence++,
+                                              .operate = desc->operate,
+                                              .userData = desc->user_data,
+                                          });
+    return MOD_OK;
+}
+
+ModResult camera_unregister_operator(ModContext* context, CameraOperatorHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return sOperators.erase_owned(handle, *mod) ? MOD_OK : MOD_INVALID_ARGUMENT;
+}
+
+CameraOperatorState make_operator_state(const dCamera_c& camera) {
+    return CameraOperatorState{
+        .struct_size = sizeof(CameraOperatorState),
+        .frame_counter = camera.mFrameCounter,
+        .ticks = camera.mTicks,
+        .aspect = mDoGph_gInf_c::getAspect(),
+        .eye = {camera.mEye.x, camera.mEye.y, camera.mEye.z},
+        .center = {camera.mCenter.x, camera.mCenter.y, camera.mCenter.z},
+        .fovy = camera.mFovy,
+        .bank_degrees = camera.mBank.Degree(),
+    };
+}
+
+bool run_operators(dCamera_c* camera) {
+    auto* mainCamera = dComIfGp_getCamera(0);
+    if (camera == nullptr || mainCamera == nullptr || &mainCamera->mCamera != camera) {
+        return false;
+    }
+
+    struct PendingOperator {
+        CameraOperatorHandle handle;
+        CameraOperator value;
+        LoadedMod* owner;
+    };
+    std::vector<PendingOperator> operators;
+    sOperators.for_each([&](CameraOperatorHandle handle, const auto& entry) {
+        operators.push_back({.handle = handle, .value = entry.value, .owner = entry.owner});
+    });
+    std::ranges::sort(operators, [](const PendingOperator& lhs, const PendingOperator& rhs) {
+        if (lhs.value.priority != rhs.value.priority) {
+            return lhs.value.priority > rhs.value.priority;
+        }
+        return lhs.value.sequence < rhs.value.sequence;
+    });
+
+    const auto initialState = make_operator_state(*camera);
+    for (const auto& entry : operators) {
+        if (!entry.owner->active || sOperators.find(entry.handle) == nullptr) {
+            continue;
+        }
+
+        auto state = initialState;
+        bool useState = false;
+        try {
+            useState =
+                entry.value.operate(entry.owner->context.get(), &state, entry.value.userData);
+        } catch (const std::exception& e) {
+            fail_mod(*entry.owner, MOD_ERROR,
+                fmt::format(
+                    "exception in camera operator '{}': {}", entry.value.debugName, e.what()));
+        } catch (...) {
+            fail_mod(*entry.owner, MOD_ERROR,
+                fmt::format("unknown exception in camera operator '{}'", entry.value.debugName));
+        }
+
+        if (!useState) {
+            continue;
+        }
+
+        camera->Reset(cXyz{state.center[0], state.center[1], state.center[2]},
+            cXyz{state.eye[0], state.eye[1], state.eye[2]}, state.fovy,
+            cAngle::Degree_to_SAngle(state.bank_degrees));
+        return true;
+    }
+    return false;
+}
+
+void camera_mod_detached(LoadedMod& mod) {
+    sOperators.erase_all(mod);
+}
+
+constexpr CameraService s_cameraService{
+    .header = SERVICE_HEADER(CameraService, CAMERA_SERVICE_MAJOR, CAMERA_SERVICE_MINOR),
+    .get_camera = camera_get_camera_from_view,
+    .register_camera_operator = camera_register_operator,
+    .unregister_camera_operator = camera_unregister_operator,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_cameraModule{
+    .id = CAMERA_SERVICE_ID,
+    .majorVersion = CAMERA_SERVICE_MAJOR,
+    .minorVersion = CAMERA_SERVICE_MINOR,
+    .service = &s_cameraService,
+    .modDetached = camera_mod_detached,
+};
+
+}  // namespace dusk::mods::svc
+
+bool dusk::mods::camera_run_operators(dCamera_c* camera) {
+    return svc::run_operators(camera);
+}
diff --git a/src/dusk/mods/svc/config.cpp b/src/dusk/mods/svc/config.cpp
index d919c0ab1f..cf8c249b3c 100644
--- a/src/dusk/mods/svc/config.cpp
+++ b/src/dusk/mods/svc/config.cpp
@@ -1,8 +1,9 @@
 #include "config.hpp"
 
+#include "internal.hpp"
 #include "registry.hpp"
 
-#include "aurora/lib/logging.hpp"
+#include <borealis/log.hpp>
 #include "dusk/config.hpp"
 #include "dusk/mods/loader/loader.hpp"
 #include "mods/svc/config.h"
@@ -15,33 +16,29 @@
 #include <memory>
 #include <string>
 #include <string_view>
-#include <unordered_map>
 #include <vector>
 
 namespace dusk::mods::svc {
 namespace {
 
-aurora::Module Log("dusk::mods::config");
+constexpr borealis::Log Log{"dusk::mods::config"};
 
-struct ModConfigVarEntry {
-    uint64_t handle = 0;
-    ConfigVarType type = CONFIG_VAR_BOOL;
-    std::unique_ptr<config::ConfigVarBase> var;
+enum class ConfigSlotKind : uint8_t {
+    Var,
+    Subscription,
 };
 
-struct ModConfigSubscription {
-    uint64_t handle = 0;
+struct ConfigSlot {
+    ConfigSlotKind kind = ConfigSlotKind::Var;
+    // Var payload
+    ConfigVarType type = CONFIG_VAR_BOOL;
+    std::unique_ptr<config::ConfigVarBase> var;
+    // Subscription payload
     uint64_t varHandle = 0;
     config::Subscription coreSubscription = 0;
 };
 
-struct ModConfigRecord {
-    std::vector<ModConfigVarEntry> vars;
-    std::vector<ModConfigSubscription> subscriptions;
-};
-
-std::unordered_map<const LoadedMod*, ModConfigRecord> s_modConfig;
-uint64_t s_nextHandle = 1;
+SlotMap<ConfigSlot> s_slots;
 bool s_dirty = false;
 std::chrono::steady_clock::time_point s_lastSave{};
 constexpr std::chrono::seconds kSaveDebounce{2};
@@ -130,17 +127,13 @@ bool valid_var_fragment(const char* name) {
 }
 
 config::ConfigVarBase* find_var(LoadedMod& mod, const uint64_t handle, uint32_t expectedType) {
-    const auto recordIt = s_modConfig.find(&mod);
-    if (recordIt == s_modConfig.end()) {
+    const auto* entry = s_slots.find_owned(handle, mod);
+    if (entry == nullptr || entry->value.kind != ConfigSlotKind::Var ||
+        entry->value.type != expectedType)
+    {
         return nullptr;
     }
-    const auto& vars = recordIt->second.vars;
-    const auto entry =
-        std::ranges::find_if(vars, [&](const auto& e) { return e.handle == handle; });
-    if (entry == vars.end() || entry->type != expectedType) {
-        return nullptr;
-    }
-    return entry->var.get();
+    return entry->value.var.get();
 }
 
 template <typename T>
@@ -154,17 +147,17 @@ ConfigVar<T>* find_typed_var(ModContext* context, ConfigVarHandle handle, uint32
 }
 
 void config_remove_mod(LoadedMod& mod) {
-    const auto it = s_modConfig.find(&mod);
-    if (it == s_modConfig.end()) {
-        return;
+    const auto entries = s_slots.take_all(mod);
+    for (const auto& entry : entries) {
+        if (entry.value.kind == ConfigSlotKind::Subscription) {
+            config::unsubscribe(entry.value.coreSubscription);
+        }
     }
-    for (const auto& sub : it->second.subscriptions) {
-        config::unsubscribe(sub.coreSubscription);
+    for (const auto& entry : entries) {
+        if (entry.value.kind == ConfigSlotKind::Var) {
+            config::unregister(*entry.value.var);
+        }
     }
-    for (const auto& entry : it->second.vars) {
-        config::unregister(*entry.var);
-    }
-    s_modConfig.erase(it);
 }
 
 ModResult config_register_var(
@@ -190,16 +183,16 @@ ModResult config_register_var(
     std::unique_ptr<config::ConfigVarBase> var;
     switch (desc->type) {
     case CONFIG_VAR_BOOL:
-        var = std::make_unique<ConfigVar<bool> >(fullName, desc->default_bool);
+        var = std::make_unique<ConfigVar<bool>>(fullName, desc->default_bool);
         break;
     case CONFIG_VAR_INT:
-        var = std::make_unique<ConfigVar<s64> >(fullName, desc->default_int);
+        var = std::make_unique<ConfigVar<s64>>(fullName, desc->default_int);
         break;
     case CONFIG_VAR_FLOAT:
-        var = std::make_unique<ConfigVar<f64> >(fullName, desc->default_float);
+        var = std::make_unique<ConfigVar<f64>>(fullName, desc->default_float);
         break;
     case CONFIG_VAR_STRING:
-        var = std::make_unique<ConfigVar<std::string> >(
+        var = std::make_unique<ConfigVar<std::string>>(
             fullName, desc->default_string != nullptr ? desc->default_string : "");
         break;
     default:
@@ -211,13 +204,10 @@ ModResult config_register_var(
     // reads the value right after registration anyway.
     config::Register(*var);
 
-    auto& record = s_modConfig[mod];
-    auto& entry = record.vars.emplace_back();
-    entry.handle = s_nextHandle++;
-    entry.type = desc->type;
-    entry.var = std::move(var);
+    const auto handle = s_slots.emplace(
+        *mod, ConfigSlot{.kind = ConfigSlotKind::Var, .type = desc->type, .var = std::move(var)});
     if (outHandle != nullptr) {
-        *outHandle = entry.handle;
+        *outHandle = handle;
     }
     return MOD_OK;
 }
@@ -227,29 +217,26 @@ ModResult config_unregister_var(ModContext* context, ConfigVarHandle var) {
     if (mod == nullptr || var == 0) {
         return MOD_INVALID_ARGUMENT;
     }
-    const auto recordIt = s_modConfig.find(mod);
-    if (recordIt != s_modConfig.end()) {
-        auto& record = recordIt->second;
-        const auto entry =
-            std::ranges::find_if(record.vars, [&](const auto& e) { return e.handle == var; });
-        if (entry != record.vars.end()) {
-            std::erase_if(record.subscriptions, [&](const ModConfigSubscription& sub) {
-                if (sub.varHandle != var) {
-                    return false;
-                }
-                config::unsubscribe(sub.coreSubscription);
-                return true;
-            });
-
-            // The persisted value is stashed and restored by a future registration of the
-            // same name.
-            config::unregister(*entry->var);
-            record.vars.erase(entry);
-            return MOD_OK;
-        }
+    const auto* entry = s_slots.find_owned(var, *mod);
+    if (entry == nullptr || entry->value.kind != ConfigSlotKind::Var) {
+        Log.error("[{}] config unregister failed: unknown handle {}", mod->metadata.id, var);
+        return MOD_INVALID_ARGUMENT;
     }
-    Log.error("[{}] config unregister failed: unknown handle {}", mod->metadata.id, var);
-    return MOD_INVALID_ARGUMENT;
+
+    // Only the owning mod can (currently) subscribe to a var
+    std::vector<uint64_t> bound;
+    s_slots.for_each([&](const uint64_t handle, const auto& e) {
+        if (e.value.kind == ConfigSlotKind::Subscription && e.value.varHandle == var) {
+            bound.push_back(handle);
+        }
+    });
+    for (const auto handle : bound) {
+        config::unsubscribe(s_slots.take(handle)->value.coreSubscription);
+    }
+
+    // The persisted value is stashed and restored by a future registration of the same name.
+    config::unregister(*s_slots.take(var)->value.var);
+    return MOD_OK;
 }
 
 ModResult config_get_bool(ModContext* context, ConfigVarHandle var, bool* outValue) {
@@ -361,22 +348,13 @@ ModResult config_subscribe(ModContext* context, ConfigVarHandle var, ConfigChang
     if (mod == nullptr || var == 0 || callback == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    const auto recordIt = s_modConfig.find(mod);
-    if (recordIt == s_modConfig.end()) {
-        return MOD_INVALID_ARGUMENT;
-    }
-    auto& record = recordIt->second;
-    const auto entry =
-        std::ranges::find_if(record.vars, [&](const auto& e) { return e.handle == var; });
-    if (entry == record.vars.end()) {
+    const auto* entry = s_slots.find_owned(var, *mod);
+    if (entry == nullptr || entry->value.kind != ConfigSlotKind::Var) {
         return MOD_INVALID_ARGUMENT;
     }
 
-    auto& sub = record.subscriptions.emplace_back();
-    sub.handle = s_nextHandle++;
-    sub.varHandle = var;
-    sub.coreSubscription = config::subscribe(entry->var->getName(),
-        [modPtr = mod, callback, userData, varHandle = var, type = entry->type](
+    const auto coreSubscription = config::subscribe(entry->value.var->getName(),
+        [modPtr = mod, callback, userData, varHandle = var, type = entry->value.type](
             config::ConfigVarBase& varBase, const void* previous) {
             const ConfigVarValue previousValue = translate_previous(type, previous);
             std::string stringStorage;
@@ -390,8 +368,13 @@ ModResult config_subscribe(ModContext* context, ConfigVarHandle var, ConfigChang
                 fail_mod(*modPtr, MOD_ERROR, "Unknown exception in config change callback");
             }
         });
+    const auto handle = s_slots.emplace(*mod, ConfigSlot{
+                                                  .kind = ConfigSlotKind::Subscription,
+                                                  .varHandle = var,
+                                                  .coreSubscription = coreSubscription,
+                                              });
     if (outHandle != nullptr) {
-        *outHandle = sub.handle;
+        *outHandle = handle;
     }
     return MOD_OK;
 }
@@ -401,19 +384,14 @@ ModResult config_unsubscribe(ModContext* context, ConfigSubscriptionHandle handl
     if (mod == nullptr || handle == 0) {
         return MOD_INVALID_ARGUMENT;
     }
-    const auto recordIt = s_modConfig.find(mod);
-    if (recordIt != s_modConfig.end()) {
-        auto& subscriptions = recordIt->second.subscriptions;
-        const auto sub =
-            std::ranges::find_if(subscriptions, [&](const auto& s) { return s.handle == handle; });
-        if (sub != subscriptions.end()) {
-            config::unsubscribe(sub->coreSubscription);
-            subscriptions.erase(sub);
-            return MOD_OK;
-        }
+    const auto* entry = s_slots.find_owned(handle, *mod);
+    if (entry == nullptr || entry->value.kind != ConfigSlotKind::Subscription) {
+        Log.error("[{}] config unsubscribe failed: unknown handle {}", mod->metadata.id, handle);
+        return MOD_INVALID_ARGUMENT;
     }
-    Log.error("[{}] config unsubscribe failed: unknown handle {}", mod->metadata.id, handle);
-    return MOD_INVALID_ARGUMENT;
+    config::unsubscribe(entry->value.coreSubscription);
+    s_slots.erase(handle);
+    return MOD_OK;
 }
 
 constexpr ConfigService s_configService{
diff --git a/src/dusk/mods/svc/file.cpp b/src/dusk/mods/svc/file.cpp
new file mode 100644
index 0000000000..8bbd4ced39
--- /dev/null
+++ b/src/dusk/mods/svc/file.cpp
@@ -0,0 +1,703 @@
+#include "registry.hpp"
+
+#include "internal.hpp"
+
+#include <aurora/lib/window.hpp>
+#include <borealis/file_select.hpp>
+#include <borealis/io.hpp>
+#include <borealis/log.hpp>
+#include "dusk/config.hpp"
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/file.h"
+
+#include <algorithm>
+#include <array>
+#include <cstdlib>
+#include <cstring>
+#include <exception>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <span>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr borealis::Log Log{"dusk::mods::file"};
+
+static_assert(static_cast<int>(FILE_OPEN_READ) == static_cast<int>(borealis::io::File::Mode::Read));
+static_assert(
+    static_cast<int>(FILE_OPEN_TRUNCATE) == static_cast<int>(borealis::io::File::Mode::Truncate));
+static_assert(
+    static_cast<int>(FILE_OPEN_APPEND) == static_cast<int>(borealis::io::File::Mode::Append));
+
+SlotMap<borealis::io::File> s_streams;
+std::unordered_map<void*, LoadedMod*> s_buffers;
+std::unordered_map<LoadedMod*, std::string> s_joinResults;
+ConfigVar<std::string> s_pickerOverride{"file.pickerOverride", ""};
+
+struct PendingPick {
+    LoadedMod* owner = nullptr;
+    FilePickFn callback = nullptr;
+    void* userData = nullptr;
+    std::optional<std::string> overrideLocation;
+    std::optional<std::string> exportSource;
+};
+
+std::shared_ptr<PendingPick> s_pendingPick;
+
+ModResult map_status(borealis::io::Status status) {
+    switch (status) {
+    case borealis::io::Status::Ok:
+        return MOD_OK;
+    case borealis::io::Status::NotFound:
+        return MOD_UNAVAILABLE;
+    case borealis::io::Status::Unsupported:
+        return MOD_UNSUPPORTED;
+    case borealis::io::Status::AlreadyExists:
+        return MOD_CONFLICT;
+    case borealis::io::Status::Failed:
+    default:
+        return MOD_ERROR;
+    }
+}
+
+ModResult map_picker_status(borealis::file_select::Status status) {
+    switch (status) {
+    case borealis::file_select::Status::Selected:
+        return MOD_OK;
+    case borealis::file_select::Status::Canceled:
+        return MOD_UNAVAILABLE;
+    case borealis::file_select::Status::Unsupported:
+        return MOD_UNSUPPORTED;
+    case borealis::file_select::Status::Busy:
+        return MOD_CONFLICT;
+    case borealis::file_select::Status::Failed:
+    default:
+        return MOD_ERROR;
+    }
+}
+
+void invoke_pick(const std::shared_ptr<PendingPick>& pending, ModResult status,
+    const std::vector<std::string>& locations, const std::string& error) {
+    if (s_pendingPick == pending) {
+        s_pendingPick.reset();
+    }
+    auto* owner = pending->owner;
+    const auto callback = pending->callback;
+    if (owner == nullptr || callback == nullptr || !owner->active) {
+        return;
+    }
+
+    std::vector<const char*> rawLocations;
+    rawLocations.reserve(locations.size());
+    for (const auto& location : locations) {
+        rawLocations.push_back(location.c_str());
+    }
+    try {
+        callback(owner->context.get(), status, rawLocations.empty() ? nullptr : rawLocations.data(),
+            static_cast<uint32_t>(rawLocations.size()), error.c_str(), pending->userData);
+    } catch (const std::exception& exception) {
+        fail_mod(*owner, MOD_ERROR,
+            std::string{"exception in file picker callback: "} + exception.what());
+    } catch (...) {
+        fail_mod(*owner, MOD_ERROR, "unknown exception in file picker callback");
+    }
+}
+
+bool valid_pick_options(const FilePickOptions* options) {
+    if (options == nullptr || options->struct_size < sizeof(FilePickOptions) ||
+        (options->filter_count != 0 && options->filters == nullptr))
+    {
+        return false;
+    }
+    for (uint32_t i = 0; i < options->filter_count; ++i) {
+        if (options->filters[i].name == nullptr || options->filters[i].pattern == nullptr) {
+            return false;
+        }
+    }
+    return true;
+}
+
+ModResult begin_pick(ModContext* context, const FilePickOptions* options, FilePickFn callback,
+    void* userData, bool folder) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || callback == nullptr || !valid_pick_options(options)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (s_pendingPick != nullptr || borealis::file_select::busy()) {
+        return MOD_CONFLICT;
+    }
+
+    auto pending = std::make_shared<PendingPick>(PendingPick{
+        .owner = mod,
+        .callback = callback,
+        .userData = userData,
+    });
+    const auto& overrideLocation = s_pickerOverride.getValue();
+    if (!overrideLocation.empty()) {
+        pending->overrideLocation = overrideLocation;
+        s_pendingPick = std::move(pending);
+        return MOD_OK;
+    }
+
+    s_pendingPick = pending;
+    const std::string defaultLocation =
+        options->default_location != nullptr ? options->default_location : "";
+    if (folder) {
+        borealis::file_select::open_folder(
+            {
+                .parentWindow = aurora::window::get_sdl_window(),
+                .defaultLocation = defaultLocation,
+            },
+            [pending](borealis::file_select::Result result) {
+                invoke_pick(
+                    pending, map_picker_status(result.status), result.locations, result.message);
+            });
+        return MOD_OK;
+    }
+
+    std::vector<borealis::file_select::Filter> filters;
+    filters.reserve(options->filter_count);
+    for (uint32_t i = 0; i < options->filter_count; ++i) {
+        filters.push_back({options->filters[i].name, options->filters[i].pattern});
+    }
+    borealis::file_select::open_file(
+        {
+            .parentWindow = aurora::window::get_sdl_window(),
+            .filters = std::move(filters),
+            .defaultLocation = defaultLocation,
+        },
+        [pending](borealis::file_select::Result result) {
+            invoke_pick(
+                pending, map_picker_status(result.status), result.locations, result.message);
+        });
+    return MOD_OK;
+}
+
+ModResult begin_export(ModContext* context, const char* sourceLocation, const char* suggestedName,
+    FilePickFn callback, void* userData) {
+    auto* mod = mod_from_context(context);
+    const std::string_view name = suggestedName != nullptr ? suggestedName : "";
+    if (mod == nullptr || sourceLocation == nullptr || callback == nullptr || name.empty() ||
+        name == "." || name == ".." || name.find_first_of("/\\") != std::string_view::npos)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (s_pendingPick != nullptr || borealis::file_select::busy()) {
+        return MOD_CONFLICT;
+    }
+    const auto available = borealis::io::check(sourceLocation);
+    if (available != borealis::io::Status::Ok) {
+        return map_status(available);
+    }
+
+    auto pending = std::make_shared<PendingPick>(PendingPick{
+        .owner = mod,
+        .callback = callback,
+        .userData = userData,
+    });
+    const auto& overrideLocation = s_pickerOverride.getValue();
+    if (!overrideLocation.empty()) {
+        pending->overrideLocation = overrideLocation;
+        pending->exportSource = sourceLocation;
+        s_pendingPick = std::move(pending);
+        return MOD_OK;
+    }
+
+    borealis::file_select::ExportOptions options{
+        .parentWindow = aurora::window::get_sdl_window(),
+        .sourceLocation = sourceLocation,
+        .suggestedName = suggestedName,
+    };
+    s_pendingPick = pending;
+    try {
+        borealis::file_select::export_file(
+            std::move(options), [pending](borealis::file_select::Result result) {
+                invoke_pick(
+                    pending, map_picker_status(result.status), result.locations, result.message);
+            });
+    } catch (...) {
+        if (s_pendingPick == pending) {
+            s_pendingPick.reset();
+        }
+        throw;
+    }
+    return MOD_OK;
+}
+
+ModResult file_pick_file(
+    ModContext* context, const FilePickOptions* options, FilePickFn callback, void* userData) {
+    return begin_pick(context, options, callback, userData, false);
+}
+
+ModResult file_pick_folder(
+    ModContext* context, const FilePickOptions* options, FilePickFn callback, void* userData) {
+    return begin_pick(context, options, callback, userData, true);
+}
+
+ModResult file_export_file(ModContext* context, const char* sourceLocation,
+    const char* suggestedName, FilePickFn callback, void* userData) {
+    try {
+        return begin_export(context, sourceLocation, suggestedName, callback, userData);
+    } catch (...) {
+        return MOD_ERROR;
+    }
+}
+
+ModResult file_display_name(
+    ModContext* context, const char* location, char* buffer, uint32_t bufferSize) {
+    if (mod_from_context(context) == nullptr || location == nullptr || buffer == nullptr ||
+        bufferSize == 0)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const std::string name = borealis::io::display_name(location);
+    if (name.size() + 1 > bufferSize) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    std::memcpy(buffer, name.c_str(), name.size() + 1);
+    return MOD_OK;
+}
+
+ModResult file_check(ModContext* context, const char* location) {
+    if (mod_from_context(context) == nullptr || location == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return map_status(borealis::io::check(location));
+}
+
+ModResult file_open(
+    ModContext* context, const char* location, FileOpenMode mode, FileStreamHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || location == nullptr || outHandle == nullptr || mode < FILE_OPEN_READ ||
+        mode > FILE_OPEN_APPEND)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    try {
+        const auto ioMode = static_cast<borealis::io::File::Mode>(mode);
+        if (mode != FILE_OPEN_READ) {
+            const auto available = borealis::io::check(location);
+            if (available != borealis::io::Status::Ok) {
+                return map_status(available);
+            }
+        }
+        auto result = borealis::io::open(location, ioMode);
+        if (result.status != borealis::io::Status::Ok) {
+            Log.warn("[{}] open '{}' failed: {}", mod->metadata.id,
+                borealis::io::display_name(location), result.message);
+            return map_status(result.status);
+        }
+        *outHandle = s_streams.emplace(*mod, std::move(result.file));
+        return MOD_OK;
+    } catch (...) {
+        return MOD_ERROR;
+    }
+}
+
+borealis::io::File* find_stream(ModContext* context, FileStreamHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return nullptr;
+    }
+    auto* entry = s_streams.find_owned(handle, *mod);
+    return entry != nullptr ? &entry->value : nullptr;
+}
+
+ModResult file_size(ModContext* context, FileStreamHandle handle, uint64_t* outSize) {
+    if (outSize == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outSize = 0;
+    auto* file = find_stream(context, handle);
+    if (file == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outSize = file->size();
+    return MOD_OK;
+}
+
+ModResult file_read(ModContext* context, FileStreamHandle handle, void* buffer, uint64_t length,
+    uint64_t* outRead) {
+    if (outRead == nullptr || (buffer == nullptr && length != 0)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outRead = 0;
+    auto* file = find_stream(context, handle);
+    if (file == nullptr || file->writable()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outRead = file->read(buffer, length);
+    return file->error().empty() ? MOD_OK : MOD_ERROR;
+}
+
+ModResult file_seek(ModContext* context, FileStreamHandle handle, uint64_t offset) {
+    auto* file = find_stream(context, handle);
+    if (file == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return file->seek(offset) ? MOD_OK : MOD_ERROR;
+}
+
+ModResult file_close(ModContext* context, FileStreamHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto entry = s_streams.take_owned(handle, *mod);
+    if (!entry.has_value()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return entry->value.close() ? MOD_OK : MOD_ERROR;
+}
+
+ModResult file_write(
+    ModContext* context, FileStreamHandle handle, const void* buffer, uint64_t length) {
+    if ((buffer == nullptr && length != 0) || length > std::numeric_limits<size_t>::max()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* file = find_stream(context, handle);
+    if (file == nullptr || !file->writable()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const auto bytes =
+        std::span{static_cast<const std::byte*>(buffer), static_cast<size_t>(length)};
+    return file->write(bytes) ? MOD_OK : MOD_ERROR;
+}
+
+ModResult file_flush(ModContext* context, FileStreamHandle handle) {
+    auto* file = find_stream(context, handle);
+    if (file == nullptr || !file->writable()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return file->flush() ? MOD_OK : MOD_ERROR;
+}
+
+ModResult file_write_all(ModContext* context, const char* location, const void* data, size_t size) {
+    if (mod_from_context(context) == nullptr || location == nullptr ||
+        (data == nullptr && size != 0))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    try {
+        const auto available = borealis::io::check(location);
+        if (available != borealis::io::Status::Ok) {
+            return map_status(available);
+        }
+        auto opened = borealis::io::open(location, borealis::io::File::Mode::Truncate);
+        if (opened.status != borealis::io::Status::Ok) {
+            return map_status(opened.status);
+        }
+        if (!opened.file.write(std::span{static_cast<const std::byte*>(data), size})) {
+            return MOD_ERROR;
+        }
+        return opened.file.close() ? MOD_OK : MOD_ERROR;
+    } catch (...) {
+        return MOD_ERROR;
+    }
+}
+
+ModResult file_read_all(ModContext* context, const char* location, FileBuffer* outBuffer) {
+    if (outBuffer == nullptr || outBuffer->struct_size < sizeof(FileBuffer)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    outBuffer->data = nullptr;
+    outBuffer->size = 0;
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || location == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    try {
+        auto opened = borealis::io::open(location);
+        if (opened.status != borealis::io::Status::Ok) {
+            return map_status(opened.status);
+        }
+        const uint64_t expectedSize = opened.file.size();
+        if (expectedSize > std::numeric_limits<size_t>::max()) {
+            return MOD_ERROR;
+        }
+        std::vector<unsigned char> bytes;
+        bytes.resize(static_cast<size_t>(expectedSize));
+        uint64_t total = 0;
+        while (total < expectedSize) {
+            const uint64_t count = opened.file.read(bytes.data() + total, expectedSize - total);
+            if (count == 0) {
+                return MOD_ERROR;
+            }
+            total += count;
+        }
+        if (expectedSize == 0) {
+            unsigned char chunk[64 * 1024];
+            while (true) {
+                const uint64_t count = opened.file.read(chunk, sizeof(chunk));
+                if (count == 0) {
+                    if (!opened.file.error().empty()) {
+                        return MOD_ERROR;
+                    }
+                    break;
+                }
+                bytes.insert(bytes.end(), chunk, chunk + count);
+            }
+        }
+        if (bytes.empty()) {
+            return MOD_OK;
+        }
+        std::unique_ptr<void, decltype(&std::free)> data{std::malloc(bytes.size()), &std::free};
+        if (!data) {
+            return MOD_ERROR;
+        }
+        std::memcpy(data.get(), bytes.data(), bytes.size());
+        s_buffers.emplace(data.get(), mod);
+        outBuffer->data = data.release();
+        outBuffer->size = bytes.size();
+        return MOD_OK;
+    } catch (...) {
+        return MOD_ERROR;
+    }
+}
+
+void file_free(ModContext* context, FileBuffer* buffer) {
+    if (buffer == nullptr || buffer->struct_size < sizeof(FileBuffer) || buffer->data == nullptr) {
+        return;
+    }
+    auto* mod = mod_from_context(context);
+    const auto found = s_buffers.find(buffer->data);
+    if (mod == nullptr || found == s_buffers.end() || found->second != mod) {
+        Log.error("[{}] file free: buffer is not owned by this mod", mod_id_from_context(context));
+        return;
+    }
+    s_buffers.erase(found);
+    std::free(buffer->data);
+    buffer->data = nullptr;
+    buffer->size = 0;
+}
+
+ModResult file_list(
+    ModContext* context, const char* folderLocation, FileListFn callback, void* userData) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || folderLocation == nullptr || callback == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    borealis::io::ListResult result;
+    try {
+        result = borealis::io::list(folderLocation);
+    } catch (...) {
+        return MOD_ERROR;
+    }
+    if (result.status != borealis::io::Status::Ok) {
+        return map_status(result.status);
+    }
+    try {
+        for (const auto& entry : result.entries) {
+            const FileEntry raw{
+                .name = entry.name.c_str(),
+                .location = entry.location.c_str(),
+                .is_directory = entry.isDirectory,
+            };
+            callback(mod->context.get(), &raw, userData);
+            if (!mod->active) {
+                return MOD_ERROR;
+            }
+        }
+        callback(mod->context.get(), nullptr, userData);
+    } catch (const std::exception& exception) {
+        fail_mod(
+            *mod, MOD_ERROR, std::string{"exception in file list callback: "} + exception.what());
+        return MOD_ERROR;
+    } catch (...) {
+        fail_mod(*mod, MOD_ERROR, "unknown exception in file list callback");
+        return MOD_ERROR;
+    }
+    return MOD_OK;
+}
+
+ModResult file_join(ModContext* context, const char* folderLocation, const char* relativePath,
+    const char** outLocation) {
+    if (outLocation != nullptr) {
+        *outLocation = nullptr;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || folderLocation == nullptr || relativePath == nullptr ||
+        outLocation == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto result = borealis::io::join(folderLocation, relativePath);
+    if (result.status != borealis::io::Status::Ok) {
+        return map_status(result.status);
+    }
+    auto& saved = s_joinResults[mod];
+    saved = std::move(result.location);
+    *outLocation = saved.c_str();
+    return MOD_OK;
+}
+
+ModResult file_create_child(
+    ModContext* context, const char* folderLocation, const char* name, const char** outLocation) {
+    if (outLocation != nullptr) {
+        *outLocation = nullptr;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || folderLocation == nullptr || name == nullptr || outLocation == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    try {
+        auto result = borealis::io::create_child(folderLocation, name);
+        if (result.status != borealis::io::Status::Ok) {
+            return map_status(result.status);
+        }
+        auto& saved = s_joinResults[mod];
+        saved = std::move(result.location);
+        *outLocation = saved.c_str();
+        return MOD_OK;
+    } catch (...) {
+        return MOD_ERROR;
+    }
+}
+
+void file_initialize() {
+    config::Register(s_pickerOverride);
+}
+
+bool file_available() {
+    const auto capabilities = borealis::file_select::capabilities();
+    return capabilities.canOpenFile || capabilities.canOpenFolder || capabilities.canExportFile;
+}
+
+ModResult copy_picker_override(
+    std::string_view source, std::string_view destination, std::string& error) {
+    try {
+        if (source == destination) {
+            return MOD_OK;
+        }
+        auto input = borealis::io::open(source);
+        if (input.status != borealis::io::Status::Ok) {
+            error = std::move(input.message);
+            return map_status(input.status);
+        }
+        auto output = borealis::io::open(destination, borealis::io::File::Mode::Truncate);
+        if (output.status != borealis::io::Status::Ok) {
+            error = std::move(output.message);
+            return map_status(output.status);
+        }
+        std::array<std::byte, 64 * 1024> buffer{};
+        while (true) {
+            const uint64_t read = input.file.read(buffer.data(), buffer.size());
+            if (read == 0) {
+                if (!input.file.error().empty()) {
+                    error = input.file.error();
+                    return MOD_ERROR;
+                }
+                break;
+            }
+            if (!output.file.write(std::span{buffer.data(), static_cast<size_t>(read)})) {
+                error = output.file.error();
+                return MOD_ERROR;
+            }
+        }
+        if (!output.file.close()) {
+            error = output.file.error();
+            return MOD_ERROR;
+        }
+        return MOD_OK;
+    } catch (const std::exception& exception) {
+        error = exception.what();
+        return MOD_ERROR;
+    } catch (...) {
+        error = "Unable to copy export source";
+        return MOD_ERROR;
+    }
+}
+
+void file_frame_begin() {
+    auto pending = s_pendingPick;
+    if (pending == nullptr || !pending->overrideLocation.has_value()) {
+        return;
+    }
+    if (!pending->exportSource.has_value()) {
+        invoke_pick(pending, MOD_OK, {*pending->overrideLocation}, "");
+        return;
+    }
+    std::string error;
+    const ModResult result =
+        copy_picker_override(*pending->exportSource, *pending->overrideLocation, error);
+    invoke_pick(pending, result,
+        result == MOD_OK ? std::vector<std::string>{*pending->overrideLocation} :
+                           std::vector<std::string>{},
+        error);
+}
+
+void file_remove_mod(LoadedMod& mod) {
+    const size_t streams = s_streams.erase_all(mod);
+    size_t buffers = 0;
+    std::erase_if(s_buffers, [&](const auto& entry) {
+        if (entry.second != &mod) {
+            return false;
+        }
+        std::free(entry.first);
+        ++buffers;
+        return true;
+    });
+    s_joinResults.erase(&mod);
+    if (s_pendingPick != nullptr && s_pendingPick->owner == &mod) {
+        s_pendingPick->owner = nullptr;
+        s_pendingPick->callback = nullptr;
+        s_pendingPick.reset();
+    }
+    if (streams != 0 || buffers != 0) {
+        Log.warn("[{}] reclaimed {} open stream(s) and {} file buffer(s)", mod.metadata.id, streams,
+            buffers);
+    }
+}
+
+void file_shutdown() {
+    config::unregister(s_pickerOverride);
+    s_pendingPick.reset();
+}
+
+constexpr FileService s_fileService{
+    .header = SERVICE_HEADER(FileService, FILE_SERVICE_MAJOR, FILE_SERVICE_MINOR),
+    .pick_file = file_pick_file,
+    .pick_folder = file_pick_folder,
+    .export_file = file_export_file,
+    .display_name = file_display_name,
+    .check = file_check,
+    .open = file_open,
+    .size = file_size,
+    .read = file_read,
+    .write = file_write,
+    .seek = file_seek,
+    .flush = file_flush,
+    .close = file_close,
+    .read_all = file_read_all,
+    .write_all = file_write_all,
+    .free = file_free,
+    .list = file_list,
+    .join = file_join,
+    .create_child = file_create_child,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_fileModule{
+    .id = FILE_SERVICE_ID,
+    .majorVersion = FILE_SERVICE_MAJOR,
+    .minorVersion = FILE_SERVICE_MINOR,
+    .service = &s_fileService,
+    .available = file_available,
+    .initialize = file_initialize,
+    .modDetached = file_remove_mod,
+    .frameBegin = file_frame_begin,
+    .shutdown = file_shutdown,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/flow.cpp b/src/dusk/mods/svc/flow.cpp
new file mode 100644
index 0000000000..9c5af25e4c
--- /dev/null
+++ b/src/dusk/mods/svc/flow.cpp
@@ -0,0 +1,1447 @@
+#include "flow.hpp"
+
+#include "registry.hpp"
+
+#include "dusk/logging.h"
+#include "dusk/mods/loader/loader.hpp"
+#include "dusk/settings.h"
+
+#include "helpers/bits.hpp"
+
+#include "JSystem/JMessage/control.h"
+#include "JSystem/JMessage/processor.h"
+#include "JSystem/JMessage/resource.h"
+#include "d/d_msg_class.h"
+
+#include <algorithm>
+#include <array>
+#include <cstring>
+#include <exception>
+#include <limits>
+#include <memory>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace dusk::flow {
+namespace {
+
+constexpr uint16_t kCustomMax = 0xfffe;
+constexpr uint16_t kGroupMax = 8;
+constexpr size_t kDebugNameMax = 256;
+
+struct ResourceInfo {
+    const uint8_t* bmg = nullptr;
+    uint16_t group = 0;
+    const uint8_t* nodes = nullptr;
+    const uint8_t* edges = nullptr;
+    uint16_t nodeCount = 0;
+    uint16_t edgeCount = 0;
+    const uint8_t* entries = nullptr;
+    uint16_t entryCount = 0;
+    uint16_t entrySize = 0;
+    const uint8_t* textBegin = nullptr;
+    const uint8_t* textEnd = nullptr;
+    bool valid = false;
+};
+
+struct PatchRecord {
+    FlowGraphHandle graph{};
+    mods::LoadedMod* owner = nullptr;
+    uint16_t group = 0;
+    uint16_t index = 0;
+    uint64_t sequence = 0;
+    bool edge = false;
+    bool active = false;
+    FlowNodeData node{};
+    uint16_t target = 0;
+};
+
+struct GraphRecord {
+    FlowGraphHandle handle{};
+    mods::LoadedMod* owner = nullptr;
+    uint16_t group = 0;
+    std::unordered_map<uint16_t, std::optional<FlowNodeData>> nodes;
+    std::unordered_map<uint16_t, uint16_t> edges;
+    std::vector<std::pair<uint16_t, uint16_t>> edgeRuns;
+    bool committed = false;
+};
+
+struct QueryRecord {
+    mods::LoadedMod* owner = nullptr;
+    std::string debugName;
+    FlowQueryFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+struct EventRecord {
+    mods::LoadedMod* owner = nullptr;
+    std::string debugName;
+    FlowEventFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+struct MessageVariantRecord {
+    uint8_t language = 0;
+    MessageEntryData entry{};
+    std::vector<uint8_t> text;
+};
+
+struct MessageRecord {
+    MessageHandle handle{};
+    MessageId id{};
+    uint16_t group = 0;
+    mods::LoadedMod* owner = nullptr;
+    std::unordered_map<uint8_t, std::shared_ptr<const MessageVariantRecord>> variants;
+};
+
+struct OverrideKey {
+    uint16_t group = 0;
+    uint16_t messageId = 0;
+    uint8_t language = 0;
+    bool operator==(const OverrideKey&) const = default;
+};
+
+struct OverrideKeyHash {
+    size_t operator()(const OverrideKey& key) const {
+        return static_cast<size_t>(key.group) << 24 | static_cast<size_t>(key.messageId) << 8 |
+               key.language;
+    }
+};
+
+struct OverrideRecord {
+    MessageOverrideHandle handle{};
+    mods::LoadedMod* owner = nullptr;
+    uint64_t sequence = 0;
+    bool callback = false;
+    std::vector<uint8_t> text;
+    MessageOverrideFn fn = nullptr;
+    void* userData = nullptr;
+};
+
+struct ActiveBinding {
+    std::vector<std::shared_ptr<const MessageVariantRecord>> variants;
+    std::vector<std::shared_ptr<const std::vector<uint8_t>>> texts;
+};
+
+std::unordered_map<const void*, ResourceInfo> s_resources;
+std::vector<PatchRecord> s_patches;
+std::unordered_map<FlowGraphHandle, GraphRecord> s_graphs;
+std::unordered_map<uint16_t, QueryRecord> s_queries;
+std::unordered_map<uint8_t, EventRecord> s_events;
+std::unordered_map<MessageId, std::shared_ptr<MessageRecord>> s_messages;
+std::unordered_map<MessageHandle, std::shared_ptr<MessageRecord>> s_messagesByHandle;
+std::unordered_map<OverrideKey, std::vector<OverrideRecord>, OverrideKeyHash> s_overrides;
+std::unordered_map<const JMessage::TControl*, ActiveBinding> s_bindings;
+std::unordered_map<const JMessage::TProcessor*, ActiveBinding> s_processorBindings;
+
+std::array<uint16_t, kGroupMax + 1> s_nextNode{};
+std::array<uint16_t, kGroupMax + 1> s_nextEdge{};
+uint16_t s_nextMessage = kCustomMessageMin;
+uint16_t s_nextQuery = kCustomQueryMin;
+uint16_t s_nextEvent = kCustomEventMin;
+std::vector<uint16_t> s_freeQueries;
+std::vector<uint8_t> s_freeEvents;
+std::array<std::vector<uint16_t>, kGroupMax + 1> s_freeNodes;
+std::array<std::vector<std::pair<uint16_t, uint16_t>>, kGroupMax + 1> s_freeEdgeRuns;
+std::vector<uint16_t> s_freeMessages;
+uint64_t s_nextHandle = 1;
+uint64_t s_nextSequence = 1;
+
+std::unordered_set<uint64_t> s_warnedConflicts;
+std::unordered_set<uint32_t> s_warnedMissingCallbacks;
+std::unordered_set<uint64_t> s_warnedUnresolved;
+
+uint8_t active_language() {
+    return static_cast<uint8_t>(getSettings().game.language.getValue());
+}
+
+bool valid_group(uint16_t group) {
+    return group <= kGroupMax;
+}
+
+bool valid_debug_name(const char* name) {
+    if (name == nullptr) {
+        return false;
+    }
+    const std::string_view value{name};
+    return !value.empty() && value.size() <= kDebugNameMax;
+}
+
+int32_t mod_priority(const mods::LoadedMod& mod) {
+    int32_t priority = 0;
+    for (const auto& candidate : mods::ModLoader::instance().mods()) {
+        ++priority;
+        if (&candidate == &mod) {
+            return priority;
+        }
+    }
+    return priority + 1;
+}
+
+const ResourceInfo* find_resource(const void* bmgData) {
+    const auto found = s_resources.find(bmgData);
+    return found != s_resources.end() && found->second.valid ? &found->second : nullptr;
+}
+
+bool parse_resource(const void* data, uint16_t group, ResourceInfo& out) {
+    const auto* bmg = static_cast<const uint8_t*>(data);
+    if (bmg == nullptr || std::memcmp(bmg, "MESGbmg1", 8) != 0) {
+        return false;
+    }
+    if (read_bits<uint32_t>(bmg + 8) < 0x20) {
+        return false;
+    }
+
+    out = {.bmg = bmg, .group = group};
+    const uint8_t* section = nullptr;
+    size_t sectionSize = 0;
+    if (detail::find_section(bmg, MULTI_CHAR('INF1'), section, sectionSize)) {
+        if (sectionSize < 16) {
+            return false;
+        }
+        out.entryCount = read_bits<uint16_t>(section + 8);
+        out.entrySize = read_bits<uint16_t>(section + 10);
+        if (out.entrySize < sizeof(MessageEntryData) ||
+            static_cast<size_t>(out.entryCount) * out.entrySize > sectionSize - 16)
+        {
+            return false;
+        }
+        out.entries = section + 16;
+    }
+    if (detail::find_section(bmg, MULTI_CHAR('DAT1'), section, sectionSize)) {
+        out.textBegin = section + 8;
+        out.textEnd = section + sectionSize;
+    }
+    if (detail::find_section(bmg, MULTI_CHAR('FLW1'), section, sectionSize)) {
+        if (sectionSize < 16) {
+            return false;
+        }
+        out.nodeCount = read_bits<uint16_t>(section + 8);
+        out.edgeCount = read_bits<uint16_t>(section + 10);
+        const auto nodesSize = static_cast<size_t>(out.nodeCount) * 8;
+        const auto edgesSize = static_cast<size_t>(out.edgeCount) * 2;
+        if (nodesSize + edgesSize > sectionSize - 16) {
+            return false;
+        }
+        out.nodes = section + 16;
+        out.edges = out.nodes + nodesSize;
+    }
+
+    if (out.nodeCount >= kCustomNodeMin || out.edgeCount >= kCustomEdgeMin ||
+        out.entryCount >= kCustomMessageMin)
+    {
+        return false;
+    }
+    for (uint16_t i = 0; i < out.entryCount; ++i) {
+        const uint8_t* entry = out.entries + static_cast<size_t>(i) * out.entrySize;
+        if (read_bits<uint16_t>(entry + 4) >= kCustomMessageMin) {
+            return false;
+        }
+    }
+    for (uint16_t i = 0; i < out.nodeCount; ++i) {
+        const uint8_t* node = out.nodes + static_cast<size_t>(i) * 8;
+        if (node[0] == 1 && (read_bits<uint16_t>(node + 2) >= kCustomMessageMin ||
+                                (read_bits<uint16_t>(node + 4) != kEnd &&
+                                    read_bits<uint16_t>(node + 4) >= kCustomNodeMin)))
+        {
+            return false;
+        }
+        if (node[0] == 2) {
+            const auto lastEdge = static_cast<uint32_t>(read_bits<uint16_t>(node + 6)) +
+                                  (node[1] == 0 ? 0 : node[1] - 1);
+            if (read_bits<uint16_t>(node + 2) >= kCustomQueryMin || lastEdge >= kCustomEdgeMin) {
+                return false;
+            }
+        }
+        if (node[0] == 3 && (node[1] >= kCustomEventMin ||
+                                (node[1] != 9 && read_bits<uint16_t>(node + 2) >= kCustomEdgeMin)))
+        {
+            return false;
+        }
+    }
+    for (uint16_t i = 0; i < out.edgeCount; ++i) {
+        const auto target = read_bits<uint16_t>(out.edges + static_cast<size_t>(i) * 2);
+        if (target != kEnd && target >= kCustomNodeMin) {
+            return false;
+        }
+    }
+    out.valid = true;
+    return true;
+}
+
+const GraphRecord* graph_for_node(uint16_t group, uint16_t index, bool requireCommitted) {
+    for (const auto& [handle, graph] : s_graphs) {
+        if (graph.group == group && graph.nodes.contains(index) &&
+            (!requireCommitted || graph.committed))
+        {
+            return &graph;
+        }
+    }
+    return nullptr;
+}
+
+const GraphRecord* graph_for_edge(uint16_t group, uint16_t index, bool requireCommitted) {
+    for (const auto& [handle, graph] : s_graphs) {
+        if (graph.group == group && graph.edges.contains(index) &&
+            (!requireCommitted || graph.committed))
+        {
+            return &graph;
+        }
+    }
+    return nullptr;
+}
+
+bool owner_has_message(const mods::LoadedMod& owner, uint16_t group, uint16_t id) {
+    const auto found = s_messages.find(id);
+    return found != s_messages.end() && found->second->owner == &owner &&
+           found->second->group == group;
+}
+
+bool valid_target_owner(const mods::LoadedMod& owner, uint16_t group, uint16_t target) {
+    if (target == kEnd || target < kCustomNodeMin) {
+        return true;
+    }
+    const auto* graph = graph_for_node(group, target, false);
+    return graph != nullptr && graph->owner == &owner;
+}
+
+bool valid_edge_owner(const mods::LoadedMod& owner, uint16_t group, uint16_t edge) {
+    if (edge < kCustomEdgeMin) {
+        return true;
+    }
+    const auto* graph = graph_for_edge(group, edge, false);
+    return graph != nullptr && graph->owner == &owner;
+}
+
+bool validate_node_owner(const mods::LoadedMod& owner, uint16_t group, const FlowNodeData& node) {
+    const auto* bytes = node.bytes;
+    switch (bytes[0]) {
+    case 1: {
+        const auto messageIndex = read_bits<uint16_t>(bytes + 2);
+        const auto target = read_bits<uint16_t>(bytes + 4);
+        if (messageIndex >= kCustomMessageMin &&
+            (messageIndex > kCustomMessageMax || !owner_has_message(owner, group, messageIndex)))
+        {
+            return false;
+        }
+        return valid_target_owner(owner, group, target);
+    }
+    case 2: {
+        const uint8_t resultCount = bytes[1];
+        const auto query = read_bits<uint16_t>(bytes + 2);
+        const auto firstEdge = read_bits<uint16_t>(bytes + 6);
+        if (resultCount == 0 || static_cast<uint32_t>(firstEdge) + resultCount - 1 > kCustomMax) {
+            return false;
+        }
+        if (query >= kCustomQueryMin) {
+            const auto found = s_queries.find(query);
+            if (query > kCustomMax || found == s_queries.end() || found->second.owner != &owner) {
+                return false;
+            }
+        } else if (query >= FLOW_QUERY_BUILTIN_COUNT) {
+            return false;
+        }
+        for (uint16_t i = 0; i < resultCount; ++i) {
+            if (!valid_edge_owner(owner, group, static_cast<uint16_t>(firstEdge + i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    case 3: {
+        const uint8_t event = bytes[1];
+        const auto edge = read_bits<uint16_t>(bytes + 2);
+        if (event >= kCustomEventMin) {
+            const auto found = s_events.find(event);
+            if (event == 0xff || found == s_events.end() || found->second.owner != &owner) {
+                return false;
+            }
+        } else if (event >= FLOW_EVENT_BUILTIN_COUNT) {
+            return false;
+        }
+        return event == 9 || valid_edge_owner(owner, group, edge);
+    }
+    default:
+        return false;
+    }
+}
+
+const PatchRecord* winning_patch(uint16_t group, uint16_t index, bool edge) {
+    const PatchRecord* winner = nullptr;
+    int32_t winnerPriority = 0;
+    const mods::LoadedMod* firstOwner = nullptr;
+    for (const auto& patch : s_patches) {
+        if (patch.group != group || patch.index != index || patch.edge != edge || !patch.active ||
+            !patch.owner->active)
+        {
+            continue;
+        }
+        if (firstOwner == nullptr) {
+            firstOwner = patch.owner;
+        } else if (firstOwner != patch.owner) {
+            const uint64_t key =
+                static_cast<uint64_t>(edge) << 63 | static_cast<uint64_t>(group) << 16 | index;
+            if (s_warnedConflicts.insert(key).second) {
+                DuskLog.warn("flow {} {}:{} is patched by multiple mods; later load wins",
+                    edge ? "edge" : "node", group, index);
+            }
+        }
+        const int32_t priority = mod_priority(*patch.owner);
+        if (winner == nullptr || priority > winnerPriority ||
+            (priority == winnerPriority && patch.sequence > winner->sequence))
+        {
+            winner = &patch;
+            winnerPriority = priority;
+        }
+    }
+    return winner;
+}
+
+bool target_in_resource(const ResourceInfo& resource, uint16_t target) {
+    if (target == kEnd) {
+        return true;
+    }
+    if (target < kCustomNodeMin) {
+        return target < resource.nodeCount;
+    }
+    return graph_for_node(resource.group, target, true) != nullptr;
+}
+
+bool edge_in_resource(const ResourceInfo& resource, uint16_t edge) {
+    if (edge < kCustomEdgeMin) {
+        return edge < resource.edgeCount;
+    }
+    return graph_for_edge(resource.group, edge, true) != nullptr;
+}
+
+bool node_resolves(const ResourceInfo& resource, const FlowNodeData& node) {
+    switch (node.bytes[0]) {
+    case 1: {
+        const auto messageIndex = read_bits<uint16_t>(node.bytes + 2);
+        const auto customMessage = s_messages.find(messageIndex);
+        const bool messageValid =
+            messageIndex < kCustomMessageMin ?
+                messageIndex < resource.entryCount :
+                customMessage != s_messages.end() &&
+                    customMessage->second->group == resource.group &&
+                    customMessage->second->variants.contains(active_language());
+        return messageValid && target_in_resource(resource, read_bits<uint16_t>(node.bytes + 4));
+    }
+    case 2: {
+        const auto query = read_bits<uint16_t>(node.bytes + 2);
+        if (node.bytes[1] == 0 || (query >= FLOW_QUERY_BUILTIN_COUNT && query < kCustomQueryMin) ||
+            query == kEnd)
+        {
+            return false;
+        }
+        const auto firstEdge = read_bits<uint16_t>(node.bytes + 6);
+        for (uint16_t i = 0; i < node.bytes[1]; ++i) {
+            if (!edge_in_resource(resource, static_cast<uint16_t>(firstEdge + i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    case 3: {
+        const uint8_t event = node.bytes[1];
+        if ((event >= FLOW_EVENT_BUILTIN_COUNT && event < kCustomEventMin) || event == 0xff) {
+            return false;
+        }
+        return event == 9 || edge_in_resource(resource, read_bits<uint16_t>(node.bytes + 2));
+    }
+    default:
+        return false;
+    }
+}
+
+bool valid_encoded_text(const uint8_t* text, size_t size) {
+    if (text == nullptr || size == 0) {
+        return false;
+    }
+    size_t offset = 0;
+    while (offset < size) {
+        if (text[offset] == 0) {
+            return offset + 1 == size;
+        }
+        if (text[offset] == JMessage::data::gcTagBegin) {
+            if (offset + 2 > size || text[offset + 1] < 5 || text[offset + 1] > size - offset) {
+                return false;
+            }
+            const size_t tagSize = text[offset + 1];
+            const uint32_t tag =
+                MSGTAG_GROUP(text[offset + 2]) | read_bits<uint16_t>(text + offset + 3);
+            const size_t argumentSize = tagSize - 5;
+            if (tag == MSGTAG_COLOR && argumentSize != 1 && argumentSize != 4 && argumentSize != 8)
+            {
+                return false;
+            }
+            offset += tagSize;
+        } else {
+            ++offset;
+        }
+    }
+    return false;
+}
+
+size_t encoded_text_size(const ResourceInfo& resource, const char* text) {
+    const auto* bytes = reinterpret_cast<const uint8_t*>(text);
+    if (bytes == nullptr || bytes < resource.textBegin || bytes >= resource.textEnd) {
+        return 0;
+    }
+    const auto maximum = static_cast<size_t>(resource.textEnd - bytes);
+    size_t offset = 0;
+    while (offset < maximum) {
+        if (bytes[offset] == 0) {
+            return offset + 1;
+        }
+        if (bytes[offset] == JMessage::data::gcTagBegin) {
+            if (offset + 2 > maximum || bytes[offset + 1] < 5 ||
+                bytes[offset + 1] > maximum - offset)
+            {
+                return 0;
+            }
+            offset += bytes[offset + 1];
+        } else {
+            ++offset;
+        }
+    }
+    return 0;
+}
+
+std::shared_ptr<const MessageVariantRecord> active_variant_shared(const MessageRecord& message) {
+    const auto found = message.variants.find(active_language());
+    return found != message.variants.end() ? found->second : nullptr;
+}
+
+std::shared_ptr<const std::vector<uint8_t>> resolve_override(
+    const ResourceInfo& resource, uint16_t messageId, const char* originalText) {
+    const OverrideKey key{resource.group, messageId, active_language()};
+    const auto found = s_overrides.find(key);
+    if (found == s_overrides.end()) {
+        return nullptr;
+    }
+    std::vector<OverrideRecord> candidates;
+    for (const auto& record : found->second) {
+        if (record.owner->active) {
+            candidates.push_back(record);
+        }
+    }
+    std::ranges::sort(candidates, [](const auto& left, const auto& right) {
+        const int32_t leftPriority = mod_priority(*left.owner);
+        const int32_t rightPriority = mod_priority(*right.owner);
+        return leftPriority != rightPriority ? leftPriority > rightPriority :
+                                               left.sequence > right.sequence;
+    });
+
+    const size_t originalSize = encoded_text_size(resource, originalText);
+    for (const auto& candidate : candidates) {
+        if (!candidate.callback) {
+            return std::make_shared<const std::vector<uint8_t>>(candidate.text);
+        }
+        const OverrideRecord local = candidate;
+        MessageTextData resolved{};
+        const MessageOverrideContext context{
+            resource.group,
+            messageId,
+            active_language(),
+            reinterpret_cast<const uint8_t*>(originalText),
+            originalSize,
+        };
+        try {
+            const bool accepted =
+                local.fn(local.owner->context.get(), &context, &resolved, local.userData);
+            if (accepted && valid_encoded_text(resolved.text, resolved.text_size)) {
+                return std::make_shared<const std::vector<uint8_t>>(
+                    resolved.text, resolved.text + resolved.text_size);
+            }
+            if (accepted) {
+                dusk::mods::fail_mod(*local.owner, MOD_INVALID_ARGUMENT,
+                    "message override returned malformed encoded text");
+            }
+        } catch (const std::exception& error) {
+            dusk::mods::fail_mod(*local.owner, MOD_ERROR,
+                fmt::format("exception in message override: {}", error.what()));
+        } catch (...) {
+            dusk::mods::fail_mod(*local.owner, MOD_ERROR, "unknown exception in message override");
+        }
+    }
+    return nullptr;
+}
+
+void retain_binding(JMessage::TControl* control, const JMessage::TProcessor* processor,
+    std::shared_ptr<const MessageVariantRecord> variant,
+    std::shared_ptr<const std::vector<uint8_t>> text) {
+    ActiveBinding* binding = nullptr;
+    if (control != nullptr) {
+        binding = &s_bindings[control];
+    } else if (processor != nullptr) {
+        binding = &s_processorBindings[processor];
+    } else {
+        return;
+    }
+    if (variant != nullptr &&
+        std::ranges::find(binding->variants, variant) == binding->variants.end())
+    {
+        binding->variants.push_back(std::move(variant));
+    }
+    if (text != nullptr && std::ranges::find(binding->texts, text) == binding->texts.end()) {
+        binding->texts.push_back(std::move(text));
+    }
+}
+
+JMessage::TControl* control_for_processor(const JMessage::TProcessor* processor) {
+    for (const auto& entry : s_bindings) {
+        const auto* control = entry.first;
+        if (control->pSequenceProcessor_ == processor || control->pRenderingProcessor_ == processor)
+        {
+            return const_cast<JMessage::TControl*>(control);
+        }
+    }
+    return nullptr;
+}
+
+ModResult add_patch(
+    GraphRecord& graph, uint16_t index, bool edge, const FlowNodeData* node, uint16_t target) {
+    if (index >= kCustomNodeMin || (edge && index >= kCustomEdgeMin) || (!edge && node == nullptr))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    PatchRecord record{
+        .graph = graph.handle,
+        .owner = graph.owner,
+        .group = graph.group,
+        .index = index,
+        .edge = edge,
+        .target = target,
+    };
+    if (node != nullptr) {
+        record.node = *node;
+    }
+    s_patches.push_back(record);
+    return MOD_OK;
+}
+
+void reset_state() {
+    s_resources.clear();
+    s_patches.clear();
+    s_graphs.clear();
+    s_queries.clear();
+    s_events.clear();
+    s_messages.clear();
+    s_messagesByHandle.clear();
+    s_overrides.clear();
+    s_bindings.clear();
+    s_processorBindings.clear();
+    s_nextNode.fill(kCustomNodeMin);
+    s_nextEdge.fill(kCustomEdgeMin);
+    s_nextMessage = kCustomMessageMin;
+    s_nextQuery = kCustomQueryMin;
+    s_nextEvent = kCustomEventMin;
+    s_freeQueries.clear();
+    s_freeEvents.clear();
+    for (auto& freeNodes : s_freeNodes) {
+        freeNodes.clear();
+    }
+    for (auto& freeRuns : s_freeEdgeRuns) {
+        freeRuns.clear();
+    }
+    s_freeMessages.clear();
+    s_nextHandle = 1;
+    s_nextSequence = 1;
+    s_warnedConflicts.clear();
+    s_warnedMissingCallbacks.clear();
+    s_warnedUnresolved.clear();
+}
+
+void remove_mod(mods::LoadedMod& mod) {
+    std::erase_if(s_patches, [&](const auto& patch) { return patch.owner == &mod; });
+
+    for (auto iterator = s_graphs.begin(); iterator != s_graphs.end();) {
+        auto& graph = iterator->second;
+        if (graph.owner == &mod) {
+            auto& freeNodes = s_freeNodes[graph.group];
+            for (const auto& [id, data] : graph.nodes) {
+                freeNodes.push_back(id);
+            }
+            auto& freeRuns = s_freeEdgeRuns[graph.group];
+            freeRuns.insert(freeRuns.end(), graph.edgeRuns.begin(), graph.edgeRuns.end());
+            iterator = s_graphs.erase(iterator);
+        } else {
+            ++iterator;
+        }
+    }
+
+    for (auto iterator = s_queries.begin(); iterator != s_queries.end();) {
+        if (iterator->second.owner == &mod) {
+            s_freeQueries.push_back(iterator->first);
+            iterator = s_queries.erase(iterator);
+        } else {
+            ++iterator;
+        }
+    }
+    for (auto iterator = s_events.begin(); iterator != s_events.end();) {
+        if (iterator->second.owner == &mod) {
+            s_freeEvents.push_back(iterator->first);
+            iterator = s_events.erase(iterator);
+        } else {
+            ++iterator;
+        }
+    }
+
+    for (auto iterator = s_messagesByHandle.begin(); iterator != s_messagesByHandle.end();) {
+        if (iterator->second->owner == &mod) {
+            s_freeMessages.push_back(iterator->second->id);
+            s_messages.erase(iterator->second->id);
+            iterator = s_messagesByHandle.erase(iterator);
+        } else {
+            ++iterator;
+        }
+    }
+    for (auto iterator = s_overrides.begin(); iterator != s_overrides.end();) {
+        std::erase_if(iterator->second, [&](const auto& record) { return record.owner == &mod; });
+        iterator = iterator->second.empty() ? s_overrides.erase(iterator) : std::next(iterator);
+    }
+}
+
+}  // namespace
+
+bool bind_resource(const void* bmgData, uint16_t group) {
+    if (bmgData == nullptr || !valid_group(group)) {
+        return false;
+    }
+    ResourceInfo resource;
+    if (!parse_resource(bmgData, group, resource)) {
+        DuskLog.error(
+            "message resource for group {} violates the custom ID reservation or is malformed",
+            group);
+        s_resources.insert_or_assign(
+            bmgData, ResourceInfo{.bmg = static_cast<const uint8_t*>(bmgData), .group = group});
+        return false;
+    }
+    s_resources.insert_or_assign(bmgData, resource);
+    for (const auto& patch : s_patches) {
+        if (patch.group != group || !patch.active) {
+            continue;
+        }
+        const bool resolves =
+            patch.edge ?
+                patch.index < resource.edgeCount && target_in_resource(resource, patch.target) :
+                patch.index < resource.nodeCount && node_resolves(resource, patch.node);
+        if (resolves) {
+            continue;
+        }
+        const uint64_t key = static_cast<uint64_t>(patch.edge) << 63 |
+                             static_cast<uint64_t>(group) << 32 | patch.index;
+        if (s_warnedUnresolved.insert(key).second) {
+            DuskLog.error("[{}] flow {} patch {}:{:#06x} is unresolved for the loaded resource",
+                patch.owner->metadata.id, patch.edge ? "edge" : "node", group, patch.index);
+        }
+    }
+    return true;
+}
+
+bool resolve_node(const void* bmgData, uint16_t nodeIndex, FlowNodeData& outNode) {
+    const auto* resource = find_resource(bmgData);
+    if (resource == nullptr || nodeIndex == kEnd) {
+        return false;
+    }
+    const auto unresolved = [&] {
+        const uint64_t key = static_cast<uint64_t>(resource->group) << 32 | nodeIndex;
+        if (s_warnedUnresolved.insert(key).second) {
+            DuskLog.error("flow node {}:{:#06x} is unresolved; terminating at END", resource->group,
+                nodeIndex);
+        }
+        return false;
+    };
+    if (nodeIndex < kCustomNodeMin) {
+        if (nodeIndex >= resource->nodeCount) {
+            return unresolved();
+        }
+        if (const auto* patch = winning_patch(resource->group, nodeIndex, false)) {
+            outNode = patch->node;
+        } else {
+            std::memcpy(outNode.bytes, resource->nodes + static_cast<size_t>(nodeIndex) * 8, 8);
+        }
+    } else {
+        const auto* graph = graph_for_node(resource->group, nodeIndex, true);
+        if (graph == nullptr) {
+            return unresolved();
+        }
+        outNode = *graph->nodes.at(nodeIndex);
+    }
+    if (!node_resolves(*resource, outNode)) {
+        return unresolved();
+    }
+    return true;
+}
+
+bool resolve_edge(const void* bmgData, uint16_t edgeIndex, uint16_t& outTarget) {
+    const auto* resource = find_resource(bmgData);
+    if (resource == nullptr) {
+        outTarget = kEnd;
+        return false;
+    }
+    const auto unresolved = [&] {
+        const uint64_t key =
+            uint64_t{1} << 63 | static_cast<uint64_t>(resource->group) << 32 | edgeIndex;
+        if (s_warnedUnresolved.insert(key).second) {
+            DuskLog.error(
+                "flow edge {}:{:#06x} is unresolved; targeting END", resource->group, edgeIndex);
+        }
+        outTarget = kEnd;
+        return false;
+    };
+    if (edgeIndex < kCustomEdgeMin) {
+        if (edgeIndex >= resource->edgeCount) {
+            return unresolved();
+        }
+        if (const auto* patch = winning_patch(resource->group, edgeIndex, true)) {
+            outTarget = patch->target;
+        } else {
+            outTarget = read_bits<uint16_t>(resource->edges + static_cast<size_t>(edgeIndex) * 2);
+        }
+    } else {
+        const auto* graph = graph_for_edge(resource->group, edgeIndex, true);
+        if (graph == nullptr) {
+            return unresolved();
+        }
+        outTarget = graph->edges.at(edgeIndex);
+    }
+    if (!target_in_resource(*resource, outTarget)) {
+        return unresolved();
+    }
+    return true;
+}
+
+bool resolve_message_entry(const void* bmgData, uint16_t messageIndex, MessageEntryData& outEntry) {
+    const auto* resource = find_resource(bmgData);
+    if (resource == nullptr) {
+        return false;
+    }
+    if (messageIndex < kCustomMessageMin) {
+        if (messageIndex >= resource->entryCount) {
+            return false;
+        }
+        std::memcpy(outEntry.bytes,
+            resource->entries + static_cast<size_t>(messageIndex) * resource->entrySize,
+            sizeof(outEntry.bytes));
+        return true;
+    }
+    const auto found = s_messages.find(messageIndex);
+    if (found == s_messages.end() || found->second->group != resource->group) {
+        return false;
+    }
+    const auto variant = active_variant_shared(*found->second);
+    if (variant == nullptr) {
+        return false;
+    }
+    outEntry = variant->entry;
+    return true;
+}
+
+uint16_t dispatch_query(uint16_t queryId, const void* speakerActor, uint16_t parameter,
+    uint8_t resultCount, FlowQueryPhase phase, uint16_t nodeIndex) {
+    const auto found = s_queries.find(queryId);
+    if (found == s_queries.end()) {
+        if (s_warnedMissingCallbacks.insert(queryId).second) {
+            DuskLog.warn("custom flow query {:#06x} is not registered; using result zero", queryId);
+        }
+        return 0;
+    }
+    const QueryRecord local = found->second;
+    const FlowQueryContext context{
+        speakerActor, parameter, resultCount, static_cast<uint8_t>(phase)};
+    try {
+        const uint16_t result = local.fn(local.owner->context.get(), &context, local.userData);
+        if (result < resultCount) {
+            return result;
+        }
+        dusk::mods::fail_mod(*local.owner, MOD_INVALID_ARGUMENT,
+            fmt::format("flow query '{}' returned {} for {} results at node {:#06x}",
+                local.debugName, result, resultCount, nodeIndex));
+    } catch (const std::exception& error) {
+        dusk::mods::fail_mod(*local.owner, MOD_ERROR,
+            fmt::format("exception in flow query '{}': {}", local.debugName, error.what()));
+    } catch (...) {
+        dusk::mods::fail_mod(*local.owner, MOD_ERROR,
+            fmt::format("unknown exception in flow query '{}'", local.debugName));
+    }
+    return 0;
+}
+
+void dispatch_event(uint8_t eventId, const void* speakerActor, const uint8_t parameters[4]) {
+    const auto found = s_events.find(eventId);
+    if (found == s_events.end()) {
+        const uint32_t warningKey = 0x10000 | eventId;
+        if (s_warnedMissingCallbacks.insert(warningKey).second) {
+            DuskLog.warn("custom flow event {:#04x} is not registered; continuing", eventId);
+        }
+        return;
+    }
+    const EventRecord local = found->second;
+    FlowEventContext context{.speaker_actor = speakerActor};
+    std::memcpy(context.parameters, parameters, sizeof(context.parameters));
+    try {
+        local.fn(local.owner->context.get(), &context, local.userData);
+    } catch (const std::exception& error) {
+        dusk::mods::fail_mod(*local.owner, MOD_ERROR,
+            fmt::format("exception in flow event '{}': {}", local.debugName, error.what()));
+    } catch (...) {
+        dusk::mods::fail_mod(*local.owner, MOD_ERROR,
+            fmt::format("unknown exception in flow event '{}'", local.debugName));
+    }
+}
+
+bool custom_message_group(uint16_t messageId, uint16_t& outGroup) {
+    const auto found = s_messages.find(messageId);
+    if (found == s_messages.end()) {
+        return false;
+    }
+    outGroup = found->second->group;
+    return true;
+}
+
+bool custom_message_for_control(
+    JMessage::TControl* control, uint16_t messageId, const void*& outEntry, const char*& outText) {
+    const auto found = s_messages.find(messageId);
+    if (found == s_messages.end()) {
+        return false;
+    }
+    const auto variant = active_variant_shared(*found->second);
+    if (variant == nullptr) {
+        return false;
+    }
+    outEntry = &variant->entry;
+    outText = reinterpret_cast<const char*>(variant->text.data());
+    retain_binding(control, nullptr, variant, nullptr);
+    return true;
+}
+
+static const JMessage::TResource* processor_resource_for_group(
+    const JMessage::TProcessor* processor, uint16_t group) {
+    if (processor == nullptr) {
+        return nullptr;
+    }
+    const auto matches_group = [group](const JMessage::TResource* resource) {
+        if (resource == nullptr) {
+            return false;
+        }
+        const auto* info = find_resource(resource->oParse_THeader_.getRaw());
+        return info != nullptr && info->group == group;
+    };
+    if (matches_group(processor->getResourceCache())) {
+        return processor->getResourceCache();
+    }
+    if (processor->getResourceContainer() == nullptr) {
+        return nullptr;
+    }
+    const auto* resources = processor->getResourceContainer()->getResourceContainer();
+    JGadget::TContainerEnumerator_const iterator{resources};
+    while (iterator) {
+        const JMessage::TResource& resource = *iterator;
+        if (matches_group(&resource)) {
+            return &resource;
+        }
+    }
+    return nullptr;
+}
+
+bool message_code_for_id(
+    const JMessage::TProcessor* processor, uint32_t messageId, uint32_t& outCode) {
+    if (processor == nullptr || messageId > std::numeric_limits<uint16_t>::max()) {
+        return false;
+    }
+    uint16_t group = 0;
+    if (!custom_message_group(static_cast<uint16_t>(messageId), group)) {
+        return false;
+    }
+    const auto* resource = processor_resource_for_group(processor, group);
+    if (resource == nullptr) {
+        return false;
+    }
+    outCode = static_cast<uint32_t>(resource->getGroupID()) << 16 | messageId;
+    return true;
+}
+
+bool custom_message_for_processor(JMessage::TControl* control,
+    const JMessage::TProcessor* processor, uint16_t messageIndex,
+    const JMessage::TResource*& outResource, const void*& outEntry, const char*& outText) {
+    const auto found = s_messages.find(messageIndex);
+    if (found == s_messages.end()) {
+        return false;
+    }
+    const auto* resource = processor_resource_for_group(processor, found->second->group);
+    const auto variant = active_variant_shared(*found->second);
+    if (resource == nullptr || variant == nullptr) {
+        return false;
+    }
+    outResource = resource;
+    outEntry = &variant->entry;
+    outText = reinterpret_cast<const char*>(variant->text.data());
+    retain_binding(control, processor, variant, nullptr);
+    return true;
+}
+
+static bool resolve_message_impl(JMessage::TControl* control, const JMessage::TProcessor* processor,
+    const void* bmgData, uint16_t messageIndex, const void* nativeEntry, const char* nativeText,
+    const void*& outEntry, const char*& outText) {
+    const auto* resource = find_resource(bmgData);
+    if (resource == nullptr) {
+        return false;
+    }
+    if (control != nullptr) {
+        s_bindings.try_emplace(control);
+    }
+    if (messageIndex >= kCustomMessageMin) {
+        const auto found = s_messages.find(messageIndex);
+        if (found == s_messages.end() || found->second->group != resource->group) {
+            return false;
+        }
+        const auto variant = active_variant_shared(*found->second);
+        if (variant == nullptr) {
+            return false;
+        }
+        outEntry = &variant->entry;
+        outText = reinterpret_cast<const char*>(variant->text.data());
+        retain_binding(control, processor, variant, nullptr);
+        return true;
+    }
+    if (nativeEntry == nullptr || nativeText == nullptr) {
+        return false;
+    }
+    const auto* bytes = static_cast<const uint8_t*>(nativeEntry);
+    const auto messageId = read_bits<uint16_t>(bytes + 4);
+    auto overrideText = resolve_override(*resource, messageId, nativeText);
+    if (overrideText == nullptr) {
+        return false;
+    }
+    outEntry = nativeEntry;
+    outText = reinterpret_cast<const char*>(overrideText->data());
+    retain_binding(control, processor, nullptr, overrideText);
+    return true;
+}
+
+bool resolve_message_for_control(JMessage::TControl* control, const void* bmgData,
+    uint16_t messageIndex, const void* nativeEntry, const char* nativeText, const void*& outEntry,
+    const char*& outText) {
+    return resolve_message_impl(
+        control, nullptr, bmgData, messageIndex, nativeEntry, nativeText, outEntry, outText);
+}
+
+bool resolve_message(const JMessage::TProcessor* processor, const void* bmgData,
+    uint16_t messageIndex, const void* nativeEntry, const char* nativeText, const void*& outEntry,
+    const char*& outText) {
+    return resolve_message_impl(control_for_processor(processor), processor, bmgData, messageIndex,
+        nativeEntry, nativeText, outEntry, outText);
+}
+
+void release_message_control(const JMessage::TControl* control) {
+    s_bindings.erase(control);
+}
+
+void release_message_processor(const JMessage::TProcessor* processor) {
+    s_processorBindings.erase(processor);
+}
+
+}  // namespace dusk::flow
+
+namespace dusk::mods::svc {
+namespace {
+
+ModResult begin_graph(ModContext* context, uint16_t group, FlowGraphHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outHandle == nullptr || !flow::valid_group(group)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const FlowGraphHandle handle = flow::s_nextHandle++;
+    flow::s_graphs.emplace(
+        handle, flow::GraphRecord{.handle = handle, .owner = mod, .group = group});
+    *outHandle = handle;
+    return MOD_OK;
+}
+
+flow::GraphRecord* owned_graph(ModContext* context, FlowGraphHandle handle) {
+    const auto* mod = mod_from_context(context);
+    const auto found = flow::s_graphs.find(handle);
+    return mod != nullptr && found != flow::s_graphs.end() && found->second.owner == mod ?
+               &found->second :
+               nullptr;
+}
+
+ModResult allocate_node(ModContext* context, FlowGraphHandle handle, uint16_t* outId) {
+    if (outId != nullptr) {
+        *outId = 0;
+    }
+    auto* graph = owned_graph(context, handle);
+    if (graph == nullptr || graph->committed || outId == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto& freeNodes = flow::s_freeNodes[graph->group];
+    uint16_t id = 0;
+    if (!freeNodes.empty()) {
+        id = freeNodes.back();
+        freeNodes.pop_back();
+    } else if (flow::s_nextNode[graph->group] < flow::kEnd) {
+        id = flow::s_nextNode[graph->group]++;
+    } else {
+        DuskLog.error("[{}] custom flow node pool for group {} is exhausted",
+            graph->owner->metadata.id, graph->group);
+        return MOD_UNAVAILABLE;
+    }
+    graph->nodes.emplace(id, std::nullopt);
+    *outId = id;
+    return MOD_OK;
+}
+
+ModResult add_edges(ModContext* context, FlowGraphHandle handle, const uint16_t* targets,
+    uint16_t count, uint16_t* outFirst) {
+    if (outFirst != nullptr) {
+        *outFirst = 0;
+    }
+    auto* graph = owned_graph(context, handle);
+    if (graph == nullptr || graph->committed || targets == nullptr || count == 0 ||
+        outFirst == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto& freeRuns = flow::s_freeEdgeRuns[graph->group];
+    const auto run =
+        std::ranges::find_if(freeRuns, [&](const auto& item) { return item.second >= count; });
+    uint16_t first = 0;
+    if (run != freeRuns.end()) {
+        first = run->first;
+        run->first += count;
+        run->second -= count;
+        if (run->second == 0) {
+            freeRuns.erase(run);
+        }
+    } else if (static_cast<uint32_t>(flow::s_nextEdge[graph->group]) + count <= flow::kEnd) {
+        first = flow::s_nextEdge[graph->group];
+        flow::s_nextEdge[graph->group] = static_cast<uint16_t>(first + count);
+    } else {
+        DuskLog.error("[{}] custom flow edge pool for group {} is exhausted",
+            graph->owner->metadata.id, graph->group);
+        return MOD_UNAVAILABLE;
+    }
+    for (uint16_t i = 0; i < count; ++i) {
+        graph->edges.emplace(static_cast<uint16_t>(first + i), targets[i]);
+    }
+    graph->edgeRuns.emplace_back(first, count);
+    *outFirst = first;
+    return MOD_OK;
+}
+
+ModResult fill_node(
+    ModContext* context, FlowGraphHandle handle, uint16_t nodeIndex, const FlowNodeData* node) {
+    auto* graph = owned_graph(context, handle);
+    if (graph == nullptr || graph->committed || node == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const auto slot = graph->nodes.find(nodeIndex);
+    if (slot == graph->nodes.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    slot->second = *node;
+    return MOD_OK;
+}
+
+ModResult patch_node(
+    ModContext* context, FlowGraphHandle handle, uint16_t nodeIndex, const FlowNodeData* node) {
+    auto* graph = owned_graph(context, handle);
+    if (graph == nullptr || graph->committed) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return flow::add_patch(*graph, nodeIndex, false, node, 0);
+}
+
+ModResult patch_edge(
+    ModContext* context, FlowGraphHandle handle, uint16_t edgeIndex, uint16_t targetNode) {
+    auto* graph = owned_graph(context, handle);
+    if (graph == nullptr || graph->committed) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return flow::add_patch(*graph, edgeIndex, true, nullptr, targetNode);
+}
+
+ModResult commit_graph(ModContext* context, FlowGraphHandle handle) {
+    auto* graph = owned_graph(context, handle);
+    const bool hasPatches =
+        graph != nullptr && std::ranges::any_of(flow::s_patches,
+                                [&](const auto& patch) { return patch.graph == handle; });
+    if (graph == nullptr || graph->committed ||
+        (graph->nodes.empty() && graph->edges.empty() && !hasPatches) ||
+        std::ranges::any_of(
+            graph->nodes, [](const auto& item) { return !item.second.has_value(); }))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    for (const auto& [id, node] : graph->nodes) {
+        if (!flow::validate_node_owner(*graph->owner, graph->group, *node)) {
+            return MOD_INVALID_ARGUMENT;
+        }
+    }
+    for (const auto& [id, target] : graph->edges) {
+        if (!flow::valid_target_owner(*graph->owner, graph->group, target)) {
+            return MOD_INVALID_ARGUMENT;
+        }
+    }
+    for (const auto& patch : flow::s_patches) {
+        if (patch.graph != handle) {
+            continue;
+        }
+        const bool valid = patch.edge ?
+                               flow::valid_target_owner(*graph->owner, graph->group, patch.target) :
+                               flow::validate_node_owner(*graph->owner, graph->group, patch.node);
+        if (!valid) {
+            return MOD_INVALID_ARGUMENT;
+        }
+    }
+    for (auto& patch : flow::s_patches) {
+        if (patch.graph == handle) {
+            patch.sequence = flow::s_nextSequence++;
+            patch.active = true;
+        }
+    }
+    graph->committed = true;
+    return MOD_OK;
+}
+
+ModResult remove_graph(ModContext* context, FlowGraphHandle handle) {
+    auto* graph = owned_graph(context, handle);
+    if (graph == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    std::erase_if(flow::s_patches, [&](const auto& patch) { return patch.graph == handle; });
+    flow::s_graphs.erase(handle);
+    return MOD_OK;
+}
+
+ModResult register_query(ModContext* context, const char* debugName, FlowQueryFn fn, void* userData,
+    FlowQueryId* outId) {
+    if (outId != nullptr) {
+        *outId = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !flow::valid_debug_name(debugName) || fn == nullptr || outId == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint16_t id = 0;
+    if (!flow::s_freeQueries.empty()) {
+        id = flow::s_freeQueries.back();
+        flow::s_freeQueries.pop_back();
+    } else if (flow::s_nextQuery <= flow::kCustomMax) {
+        id = flow::s_nextQuery++;
+    } else {
+        DuskLog.error("[{}] flow query pool exhausted (32767 registrations)", mod->metadata.id);
+        return MOD_UNAVAILABLE;
+    }
+    flow::s_queries.emplace(id, flow::QueryRecord{mod, debugName, fn, userData});
+    *outId = id;
+    return MOD_OK;
+}
+
+ModResult register_event(ModContext* context, const char* debugName, FlowEventFn fn, void* userData,
+    FlowEventId* outId) {
+    if (outId != nullptr) {
+        *outId = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !flow::valid_debug_name(debugName) || fn == nullptr || outId == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint8_t id = 0;
+    if (!flow::s_freeEvents.empty()) {
+        id = flow::s_freeEvents.back();
+        flow::s_freeEvents.pop_back();
+    } else if (flow::s_nextEvent <= 0xfe) {
+        id = static_cast<uint8_t>(flow::s_nextEvent++);
+    } else {
+        DuskLog.error("[{}] flow event pool exhausted (127 registrations)", mod->metadata.id);
+        return MOD_UNAVAILABLE;
+    }
+    flow::s_events.emplace(id, flow::EventRecord{mod, debugName, fn, userData});
+    *outId = id;
+    return MOD_OK;
+}
+
+ModResult override_message(ModContext* context, uint16_t group, uint16_t messageId,
+    uint8_t language, const uint8_t* text, size_t textSize, MessageOverrideHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outHandle == nullptr || !flow::valid_group(group) ||
+        messageId >= flow::kCustomMessageMin || !flow::valid_encoded_text(text, textSize))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    flow::OverrideRecord record{
+        .handle = flow::s_nextHandle++,
+        .owner = mod,
+        .sequence = flow::s_nextSequence++,
+        .text = {text, text + textSize},
+    };
+    *outHandle = record.handle;
+    flow::s_overrides[{group, messageId, language}].push_back(std::move(record));
+    return MOD_OK;
+}
+
+ModResult override_message_fn(ModContext* context, uint16_t group, uint16_t messageId,
+    uint8_t language, MessageOverrideFn fn, void* userData, MessageOverrideHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outHandle == nullptr || !flow::valid_group(group) ||
+        messageId >= flow::kCustomMessageMin || fn == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    flow::OverrideRecord record{
+        .handle = flow::s_nextHandle++,
+        .owner = mod,
+        .sequence = flow::s_nextSequence++,
+        .callback = true,
+        .fn = fn,
+        .userData = userData,
+    };
+    *outHandle = record.handle;
+    flow::s_overrides[{group, messageId, language}].push_back(std::move(record));
+    return MOD_OK;
+}
+
+ModResult remove_override(ModContext* context, MessageOverrideHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    for (auto iterator = flow::s_overrides.begin(); iterator != flow::s_overrides.end(); ++iterator)
+    {
+        const size_t removed = std::erase_if(iterator->second,
+            [&](const auto& record) { return record.handle == handle && record.owner == mod; });
+        if (removed != 0) {
+            if (iterator->second.empty()) {
+                flow::s_overrides.erase(iterator);
+            }
+            return MOD_OK;
+        }
+    }
+    return MOD_INVALID_ARGUMENT;
+}
+
+ModResult register_message(ModContext* context, uint16_t group, const MessageVariantData* variants,
+    size_t variantCount, MessageId* outId, MessageHandle* outHandle) {
+    if (outId != nullptr) {
+        *outId = 0;
+    }
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !flow::valid_group(group) || variants == nullptr || variantCount == 0 ||
+        outId == nullptr || outHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint16_t messageId = 0;
+    if (!flow::s_freeMessages.empty()) {
+        messageId = flow::s_freeMessages.back();
+        flow::s_freeMessages.pop_back();
+    } else if (flow::s_nextMessage <= flow::kCustomMessageMax) {
+        messageId = flow::s_nextMessage++;
+    } else {
+        DuskLog.error("[{}] custom message ID pool exhausted", mod->metadata.id);
+        return MOD_UNAVAILABLE;
+    }
+    auto message = std::make_shared<flow::MessageRecord>();
+    message->handle = flow::s_nextHandle++;
+    message->id = messageId;
+    message->group = group;
+    message->owner = mod;
+    for (size_t i = 0; i < variantCount; ++i) {
+        const auto& input = variants[i];
+        if (read_bits<uint32_t>(input.entry.bytes) != 0 ||
+            read_bits<uint16_t>(input.entry.bytes + 4) != 0 ||
+            !flow::valid_encoded_text(input.text, input.text_size) ||
+            message->variants.contains(input.language))
+        {
+            return MOD_INVALID_ARGUMENT;
+        }
+        auto variant = std::make_shared<flow::MessageVariantRecord>();
+        variant->language = input.language;
+        variant->entry = input.entry;
+        write_bits(variant->entry.bytes + 4, message->id);
+        variant->text.assign(input.text, input.text + input.text_size);
+        message->variants.emplace(input.language, std::move(variant));
+    }
+    flow::s_messages.emplace(message->id, message);
+    flow::s_messagesByHandle.emplace(message->handle, message);
+    *outId = message->id;
+    *outHandle = message->handle;
+    return MOD_OK;
+}
+
+ModResult remove_message(ModContext* context, MessageHandle handle) {
+    auto* mod = mod_from_context(context);
+    const auto found = flow::s_messagesByHandle.find(handle);
+    if (mod == nullptr || handle == 0 || found == flow::s_messagesByHandle.end() ||
+        found->second->owner != mod)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    flow::s_messages.erase(found->second->id);
+    flow::s_messagesByHandle.erase(found);
+    return MOD_OK;
+}
+
+constexpr FlowService s_flowService{
+    .header = SERVICE_HEADER(FlowService, FLOW_SERVICE_MAJOR, FLOW_SERVICE_MINOR),
+    .begin_graph = begin_graph,
+    .allocate_node = allocate_node,
+    .add_edges = add_edges,
+    .fill_node = fill_node,
+    .patch_node = patch_node,
+    .patch_edge = patch_edge,
+    .commit_graph = commit_graph,
+    .remove_graph = remove_graph,
+    .register_query = register_query,
+    .register_event = register_event,
+};
+
+constexpr MessageService s_messageService{
+    .header = SERVICE_HEADER(MessageService, MESSAGE_SERVICE_MAJOR, MESSAGE_SERVICE_MINOR),
+    .override_message = override_message,
+    .override_message_fn = override_message_fn,
+    .remove_override = remove_override,
+    .register_message = register_message,
+    .remove_message = remove_message,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_flowModule{
+    .id = FLOW_SERVICE_ID,
+    .majorVersion = FLOW_SERVICE_MAJOR,
+    .minorVersion = FLOW_SERVICE_MINOR,
+    .service = &s_flowService,
+    .initialize = flow::reset_state,
+    .modDetached = flow::remove_mod,
+    .shutdown = flow::reset_state,
+};
+
+constinit const ServiceModule g_messageModule{
+    .id = MESSAGE_SERVICE_ID,
+    .majorVersion = MESSAGE_SERVICE_MAJOR,
+    .minorVersion = MESSAGE_SERVICE_MINOR,
+    .service = &s_messageService,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/flow.hpp b/src/dusk/mods/svc/flow.hpp
new file mode 100644
index 0000000000..7e054a7e0a
--- /dev/null
+++ b/src/dusk/mods/svc/flow.hpp
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "helpers/bits.hpp"
+#include "mods/svc/flow.h"
+#include "mods/svc/message.h"
+
+#include <cstdint>
+
+namespace JMessage {
+struct TControl;
+struct TProcessor;
+struct TResource;
+}  // namespace JMessage
+
+namespace dusk::flow {
+
+inline constexpr uint16_t kCustomNodeMin = 0x8000;
+inline constexpr uint16_t kCustomEdgeMin = 0x8000;
+inline constexpr uint16_t kCustomMessageMin = 0x8000;
+inline constexpr uint16_t kCustomMessageMax = 0xfeff;
+inline constexpr uint16_t kCustomQueryMin = 0x8000;
+inline constexpr uint8_t kCustomEventMin = 0x80;
+inline constexpr uint16_t kEnd = 0xffff;
+
+/* Associates a parsed BMG resource with its service group and validates its reserved ranges. */
+bool bind_resource(const void* bmgData, uint16_t group);
+
+/* All resolver outputs are copies so callbacks may mutate service registrations safely. */
+bool resolve_node(const void* bmgData, uint16_t nodeIndex, FlowNodeData& outNode);
+bool resolve_edge(const void* bmgData, uint16_t edgeIndex, uint16_t& outTarget);
+bool resolve_message_entry(
+    const void* bmgData, uint16_t messageIndex, MessageEntryData& outEntry);
+
+uint16_t dispatch_query(uint16_t queryId, const void* speakerActor, uint16_t parameter,
+    uint8_t resultCount, FlowQueryPhase phase, uint16_t nodeIndex);
+void dispatch_event(uint8_t eventId, const void* speakerActor, const uint8_t parameters[4]);
+
+bool custom_message_group(uint16_t messageId, uint16_t& outGroup);
+bool custom_message_for_control(
+    JMessage::TControl* control, uint16_t messageId, const void*& outEntry, const char*& outText);
+
+/* JMessage bridges. Return true when the service supplied a custom or overridden value. */
+bool message_code_for_id(
+    const JMessage::TProcessor* processor, uint32_t messageId, uint32_t& outCode);
+bool custom_message_for_processor(JMessage::TControl* control,
+    const JMessage::TProcessor* processor, uint16_t messageIndex,
+    const JMessage::TResource*& outResource, const void*& outEntry, const char*& outText);
+bool resolve_message_for_control(JMessage::TControl* control, const void* bmgData,
+    uint16_t messageIndex, const void* nativeEntry, const char* nativeText, const void*& outEntry,
+    const char*& outText);
+bool resolve_message(const JMessage::TProcessor* processor, const void* bmgData,
+    uint16_t messageIndex, const void* nativeEntry, const char* nativeText, const void*& outEntry,
+    const char*& outText);
+void release_message_control(const JMessage::TControl* control);
+void release_message_processor(const JMessage::TProcessor* processor);
+
+namespace detail {
+inline bool find_section(
+    const uint8_t* bmg, uint32_t tag, const uint8_t*& outSection, size_t& outSize) {
+    const uint32_t sectionCount = read_bits<uint32_t>(bmg + 0x0c);
+    size_t offset = 0x20;
+    for (uint32_t i = 0; i < sectionCount; ++i) {
+        if (offset > std::numeric_limits<size_t>::max() - 8) {
+            return false;
+        }
+        const size_t sectionSize = read_bits<uint32_t>(bmg + offset + 4);
+        if (sectionSize < 8 || offset > std::numeric_limits<size_t>::max() - sectionSize) {
+            return false;
+        }
+        if (read_bits<uint32_t>(bmg + offset) == tag) {
+            outSection = bmg + offset;
+            outSize = sectionSize;
+            return true;
+        }
+        offset += sectionSize;
+    }
+    return false;
+}
+}  // namespace detail
+
+}  // namespace dusk::flow
diff --git a/src/dusk/mods/svc/game_mode.cpp b/src/dusk/mods/svc/game_mode.cpp
new file mode 100644
index 0000000000..a84afad78f
--- /dev/null
+++ b/src/dusk/mods/svc/game_mode.cpp
@@ -0,0 +1,199 @@
+#include "mods/svc/game_mode.h"
+
+#include "internal.hpp"
+#include "registry.hpp"
+
+#include "dusk/game_mode.hpp"
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/loader/loader.hpp"
+
+#include <aurora/lib/logging.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <cctype>
+#include <exception>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace dusk::mods::svc::game_mode_impl {
+namespace {
+
+aurora::Module Log("dusk::mods::game_mode");
+
+// Track ownership of mod ID to game modes
+std::unordered_map<std::string, std::vector<std::string>> s_gameModesByMod;
+
+template <typename Fn>
+bool invoke_mod_callback(LoadedMod& mod, const char* what, Fn&& fn) {
+    if (!mod.active) {
+        return false;
+    }
+
+    ModError error = MOD_ERROR_INIT;
+    ModResult result = MOD_OK;
+    try {
+        result = fn(&error);
+    } catch (const std::exception& exception) {
+        fail_mod(mod, MOD_ERROR, fmt::format("exception in {}: {}", what, exception.what()));
+        return false;
+    } catch (...) {
+        fail_mod(mod, MOD_ERROR, fmt::format("unknown exception in {}", what));
+        return false;
+    }
+
+    if (result != MOD_OK && mod.active) {
+        fail_mod(mod, result,
+            error.message[0] != '\0' ?
+                error.message :
+                fmt::format("{} failed with result {}", what, static_cast<int>(result)));
+    }
+    return result == MOD_OK && mod.active;
+}
+
+gamemode::GameMode::Callback wrap_callback(
+    LoadedMod& mod, GameModeCallback callback, void* userData, const char* what) {
+    return [&mod, callback, userData, what] {
+        return invoke_mod_callback(
+            mod, what, [callback, userData](ModError* error) { return callback(userData, error); });
+    };
+}
+
+gamemode::GameMode::NewSaveSelectCallback wrap_new_save_select_callback(
+    LoadedMod& mod, GameModeNewSaveSelectCallback callback, void* userData, const char* what) {
+    return [&mod, callback, userData, what](GameModeNewSaveState* state) {
+        return invoke_mod_callback(
+            mod, what, [=](ModError* error) { return callback(userData, state, error); });
+    };
+}
+
+std::string get_mod_game_mode_id(ModContext* ctx, const std::string& id) {
+    // Include the mod ID to prevent clashes and normalize to lowercase
+    std::string fullId = id + "_" + ctx->mod->metadata.id;
+    std::transform(fullId.begin(), fullId.end(), fullId.begin(),
+        [](unsigned char c) { return std::tolower(c); });
+    return fullId;
+}
+
+void game_mode_remove_mod(LoadedMod& mod) {
+    const auto it = s_gameModesByMod.find(mod.metadata.id);
+    if (it != s_gameModesByMod.end()) {
+        for (const auto& id : it->second) {
+            gamemode::getGameModeManager().unregisterGameMode(id);
+        }
+        s_gameModesByMod.erase(it);
+    }
+}
+}  // namespace
+
+ModResult register_game_mode(ModContext* ctx, const GameModeDesc* desc) {
+    auto* owner = mod_from_context(ctx);
+    if (owner == nullptr || desc == nullptr || desc->struct_size < sizeof(GameModeDesc)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    std::string id;
+    if (!desc->game_mode_id) {
+        Log.error("Attempted to register a game mode with a null ID");
+        return MOD_ERROR;
+    }
+    id = desc->game_mode_id;
+    if (id.empty()) {
+        Log.error("Attempted to register a game mode with an empty ID");
+        return MOD_ERROR;
+    }
+    id = get_mod_game_mode_id(ctx, id);
+
+    std::string fullName;
+    if (!desc->full_name) {
+        Log.warn("Game mode {} has no display name; using its ID", id);
+        fullName = id;
+    } else {
+        fullName = desc->full_name;
+        if (fullName.empty()) {
+            Log.warn("Game mode {} has an empty display name; using its ID", id);
+            fullName = id;
+        }
+    }
+
+    gamemode::GameMode mode{id, fullName, desc->save_name};
+    if (desc->on_activated) {
+        mode.mOnActivatedFunction = wrap_callback(
+            *owner, desc->on_activated, desc->user_data, "game mode activation callback");
+    }
+    if (desc->on_deactivated) {
+        mode.mOnDeactivatedFunction = wrap_callback(
+            *owner, desc->on_deactivated, desc->user_data, "game mode deactivation callback");
+    }
+    if (desc->on_play) {
+        mode.mOnPlayFunction =
+            wrap_callback(*owner, desc->on_play, desc->user_data, "game mode play callback");
+    }
+    if (desc->on_save_loaded) {
+        mode.mOnSaveLoadedFunction = wrap_callback(
+            *owner, desc->on_save_loaded, desc->user_data, "game mode save-loaded callback");
+    }
+    if (desc->on_new_save) {
+        mode.mOnNewSaveFunction = wrap_callback(
+            *owner, desc->on_new_save, desc->user_data, "game mode new-save callback");
+    }
+    if (desc->on_new_save_select) {
+        mode.mOnNewSaveSelectFunction = wrap_new_save_select_callback(*owner,
+            desc->on_new_save_select, desc->user_data, "game mode new-save selection callback");
+    }
+    if (desc->on_game_reset) {
+        mode.mOnGameResetFunction =
+            wrap_callback(*owner, desc->on_game_reset, desc->user_data, "game mode reset callback");
+    }
+    if (desc->on_tick) {
+        mode.mOnTickFunction =
+            wrap_callback(*owner, desc->on_tick, desc->user_data, "game mode tick callback");
+    }
+
+    gamemode::getGameModeManager().registerGameMode(mode);
+    s_gameModesByMod[ctx->mod->metadata.id].push_back(id);
+    return MOD_OK;
+}
+
+ModResult unregister_game_mode(ModContext* ctx, const char* id) {
+    std::string fullId = get_mod_game_mode_id(ctx, id);
+    gamemode::getGameModeManager().unregisterGameMode(fullId);
+
+    // Remove the game mode from the ownership map
+    auto it = s_gameModesByMod.find(ctx->mod->metadata.id);
+    if (it != s_gameModesByMod.end()) {
+        std::erase(it->second, fullId);
+    }
+    return MOD_OK;
+}
+
+ModResult is_active(ModContext* ctx, const char* gameModeId, bool* out_active) {
+    *out_active =
+        gamemode::getGameModeManager().isCurrentGameMode(get_mod_game_mode_id(ctx, gameModeId));
+    return MOD_OK;
+}
+
+}  // namespace dusk::mods::svc::game_mode_impl
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr GameModeService s_gamemodeService{
+    .header = SERVICE_HEADER(GameModeService, GAME_MODE_SERVICE_MAJOR, GAME_MODE_SERVICE_MINOR),
+    .register_game_mode = game_mode_impl::register_game_mode,
+    .unregister_game_mode = game_mode_impl::unregister_game_mode,
+    .is_active = game_mode_impl::is_active,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_gamemodeModule{
+    .id = GAME_MODE_SERVICE_ID,
+    .majorVersion = GAME_MODE_SERVICE_MAJOR,
+    .minorVersion = GAME_MODE_SERVICE_MINOR,
+    .service = &s_gamemodeService,
+    .modDeactivating = game_mode_impl::game_mode_remove_mod,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/gfx.cpp b/src/dusk/mods/svc/gfx.cpp
new file mode 100644
index 0000000000..9ec8f2415a
--- /dev/null
+++ b/src/dusk/mods/svc/gfx.cpp
@@ -0,0 +1,1409 @@
+#include "internal.hpp"
+#include "registry.hpp"
+#include "window.hpp"
+
+#include <borealis/log.hpp>
+#include "dusk/gfx.hpp"
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/gfx.h"
+
+#include <aurora/gfx.hpp>
+#include <aurora/webgpu.hpp>
+#include <dolphin/gx/GXAurora.h>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace dusk::mods {
+namespace {
+
+constexpr borealis::Log Log{"dusk::mods::gfx"};
+
+enum class GfxSlotKind : uint8_t {
+    DrawType,
+    StageHook,
+    ComputeType,
+    PresentTarget,
+};
+
+enum class GfxStreamBuffer : uint8_t {
+    Verts,
+    Indices,
+    Uniform,
+    Storage,
+};
+
+enum class PresentTargetStatus : uint8_t {
+    Pending,
+    Ready,
+    TransientUnavailable,
+    Lost,
+    Error,
+};
+
+struct PresentTargetState {
+    wgpu::Surface surface;
+    wgpu::SurfaceConfiguration configuration;
+    wgpu::Texture currentTexture;
+    wgpu::TextureView currentView;
+    std::atomic<PresentTargetStatus> status = PresentTargetStatus::Pending;
+    bool configured = false;
+    bool presentPending = false;
+    bool vsync = true;
+};
+
+bool present_target_failed(const std::shared_ptr<PresentTargetState>& state) {
+    if (state == nullptr) {
+        return true;
+    }
+    const auto status = state->status.load(std::memory_order_acquire);
+    return status == PresentTargetStatus::Lost || status == PresentTargetStatus::Error;
+}
+
+struct GfxSlot {
+    GfxSlotKind kind = GfxSlotKind::DrawType;
+    ModContext* ownerContext = nullptr;
+    std::string ownerId;
+    void* userData = nullptr;
+
+    GfxDrawFn drawFn = nullptr;
+    aurora::gfx::DrawTypeId auroraDrawId = aurora::gfx::InvalidDrawType;
+
+    GfxStageFn stageFn = nullptr;
+    GfxStage stage = GFX_STAGE_SCENE_AFTER_TERRAIN;
+
+    GfxComputeFn computeFn = nullptr;
+    aurora::gfx::EncoderTaskId auroraTaskId = aurora::gfx::InvalidEncoderTask;
+
+    GfxPresentFn presentFn = nullptr;
+    std::shared_ptr<PresentTargetState> presentState;
+    WindowHandle window = 0;
+    uint32_t targetWidth = 0;
+    uint32_t targetHeight = 0;
+    WGPUTextureUsage targetUsage = WGPUTextureUsage_RenderAttachment;
+    WGPUTextureFormat preferredFormat = WGPUTextureFormat_Undefined;
+    WGPUCompositeAlphaMode preferredAlphaMode = WGPUCompositeAlphaMode_Auto;
+    uint32_t lastPresentFrame = UINT32_MAX;
+};
+
+struct WorkerFailure {
+    std::string modId;
+    std::string message;
+};
+
+std::mutex s_mutex;
+using GfxSlotMap = svc::SlotMap<GfxSlot>;
+GfxSlotMap s_slots;
+std::vector<WorkerFailure> s_workerFailures;
+bool s_modOffscreenOpen = false;
+
+GfxSlotMap::Entry* resolve_entry_locked(uint64_t handle, GfxSlotKind kind) {
+    auto* entry = s_slots.find(handle);
+    if (entry == nullptr || entry->value.kind != kind) {
+        return nullptr;
+    }
+    return entry;
+}
+
+GfxSlot* resolve_slot_locked(uint64_t handle, GfxSlotKind kind) {
+    auto* entry = resolve_entry_locked(handle, kind);
+    return entry != nullptr ? &entry->value : nullptr;
+}
+
+GfxSlot* resolve_owned_slot_locked(LoadedMod& mod, uint64_t handle, GfxSlotKind kind) {
+    auto* entry = s_slots.find_owned(handle, mod);
+    if (entry == nullptr || entry->value.kind != kind) {
+        return nullptr;
+    }
+    return &entry->value;
+}
+
+void take_mod_types_locked(LoadedMod& owner, std::vector<aurora::gfx::DrawTypeId>& drawIds,
+    std::vector<aurora::gfx::EncoderTaskId>& taskIds) {
+    std::vector<uint64_t> drawHandles;
+    std::vector<uint64_t> taskHandles;
+    s_slots.for_each([&](uint64_t handle, const auto& entry) {
+        if (entry.owner != &owner) {
+            return;
+        }
+        const auto& slot = entry.value;
+        if (slot.kind == GfxSlotKind::DrawType && slot.auroraDrawId != aurora::gfx::InvalidDrawType)
+        {
+            drawHandles.push_back(handle);
+        } else if ((slot.kind == GfxSlotKind::ComputeType ||
+                       slot.kind == GfxSlotKind::PresentTarget) &&
+                   slot.auroraTaskId != aurora::gfx::InvalidEncoderTask)
+        {
+            taskHandles.push_back(handle);
+        }
+    });
+    for (const auto handle : drawHandles) {
+        auto* entry = s_slots.find(handle);
+        drawIds.push_back(std::exchange(entry->value.auroraDrawId, aurora::gfx::InvalidDrawType));
+    }
+    for (const auto handle : taskHandles) {
+        auto* entry = s_slots.find(handle);
+        taskIds.push_back(
+            std::exchange(entry->value.auroraTaskId, aurora::gfx::InvalidEncoderTask));
+    }
+}
+
+void unregister_aurora_types(const std::vector<aurora::gfx::DrawTypeId>& drawIds,
+    const std::vector<aurora::gfx::EncoderTaskId>& taskIds) {
+    for (const auto id : drawIds) {
+        aurora::gfx::unregister_draw_type(id);
+    }
+    for (const auto id : taskIds) {
+        aurora::gfx::unregister_encoder_task_type(id);
+    }
+}
+
+void gfx_mod_deactivating(LoadedMod& mod) {
+    std::vector<aurora::gfx::DrawTypeId> drawIds;
+    std::vector<aurora::gfx::EncoderTaskId> taskIds;
+    {
+        std::lock_guard lock{s_mutex};
+        take_mod_types_locked(mod, drawIds, taskIds);
+    }
+    unregister_aurora_types(drawIds, taskIds);
+    if (!drawIds.empty() || !taskIds.empty()) {
+        aurora::gfx::synchronize();
+    }
+}
+
+GfxAttachmentSemantic gfx_attachment_semantic(aurora::gfx::ColorAttachmentSemantic semantic) {
+    switch (semantic) {
+    case aurora::gfx::ColorAttachmentSemantic::SceneColor:
+        return GFX_ATTACHMENT_SCENE_COLOR;
+    case aurora::gfx::ColorAttachmentSemantic::Normal:
+        return GFX_ATTACHMENT_NORMAL;
+    case aurora::gfx::ColorAttachmentSemantic::Auxiliary:
+        return GFX_ATTACHMENT_AUXILIARY;
+    }
+    return GFX_ATTACHMENT_AUXILIARY;
+}
+
+GfxRenderTargetLayout gfx_render_target_layout(const aurora::gfx::RenderTargetLayout& layout) {
+    GfxRenderTargetLayout result = GFX_RENDER_TARGET_LAYOUT_INIT;
+    result.key = layout.key;
+    result.color_attachment_count =
+        std::min<uint32_t>(layout.colorAttachmentCount, GFX_MAX_COLOR_ATTACHMENTS);
+    for (uint32_t i = 0; i < result.color_attachment_count; ++i) {
+        result.color_attachments[i] = {
+            .semantic = gfx_attachment_semantic(layout.colorAttachments[i].semantic),
+            .format = static_cast<WGPUTextureFormat>(layout.colorAttachments[i].format),
+            .width = layout.colorAttachments[i].width,
+            .height = layout.colorAttachments[i].height,
+        };
+    }
+    result.depth_stencil_format = static_cast<WGPUTextureFormat>(layout.depthStencilFormat);
+    result.sample_count = layout.sampleCount;
+    return result;
+}
+
+void draw_trampoline(const aurora::gfx::DrawContext& ctx, const wgpu::RenderPassEncoder& pass,
+    const void* payload, size_t payloadSize, void* userdata) {
+    const auto handle = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(userdata));
+    GfxDrawFn fn = nullptr;
+    void* userData = nullptr;
+    ModContext* modContext = nullptr;
+    std::string ownerId;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* entry = resolve_entry_locked(handle, GfxSlotKind::DrawType);
+        if (entry == nullptr) {
+            return;
+        }
+        const auto& slot = entry->value;
+        fn = slot.drawFn;
+        userData = slot.userData;
+        modContext = slot.ownerContext;
+        ownerId = slot.ownerId;
+    }
+
+    GfxDrawContext drawContext{
+        .struct_size = sizeof(GfxDrawContext),
+        .device = ctx.device.Get(),
+        .queue = ctx.queue.Get(),
+        .pass = pass.Get(),
+        .vertex_buffer = ctx.vertexBuffer.Get(),
+        .index_buffer = ctx.indexBuffer.Get(),
+        .uniform_buffer = ctx.uniformBuffer.Get(),
+        .storage_buffer = ctx.storageBuffer.Get(),
+        .color_format = static_cast<WGPUTextureFormat>(
+            ctx.layout.colorAttachments[GFX_SCENE_COLOR_ATTACHMENT_INDEX].format),
+        .depth_format = static_cast<WGPUTextureFormat>(ctx.layout.depthStencilFormat),
+        .sample_count = ctx.layout.sampleCount,
+        .uses_reversed_z = aurora::gfx::uses_reversed_z(),
+        .layout = gfx_render_target_layout(ctx.layout),
+    };
+
+    std::string failure;
+    try {
+        fn(modContext, &drawContext, payload, payloadSize, userData);
+        return;
+    } catch (const std::exception& e) {
+        failure = fmt::format("exception in gfx draw callback: {}", e.what());
+    } catch (...) {
+        failure = "unknown exception in gfx draw callback";
+    }
+
+    std::lock_guard lock{s_mutex};
+    WorkerFailure record{
+        .modId = std::move(ownerId),
+        .message = std::move(failure),
+    };
+    s_workerFailures.push_back(std::move(record));
+}
+
+void compute_trampoline(const aurora::gfx::EncoderTaskContext& ctx, const wgpu::CommandEncoder& cmd,
+    const void* payload, size_t payloadSize, void* userdata) {
+    const auto handle = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(userdata));
+    GfxComputeFn fn = nullptr;
+    void* userData = nullptr;
+    ModContext* modContext = nullptr;
+    std::string ownerId;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* entry = resolve_entry_locked(handle, GfxSlotKind::ComputeType);
+        if (entry == nullptr) {
+            return;
+        }
+        const auto& slot = entry->value;
+        fn = slot.computeFn;
+        userData = slot.userData;
+        modContext = slot.ownerContext;
+        ownerId = slot.ownerId;
+    }
+
+    GfxComputeContext computeContext{
+        .struct_size = sizeof(GfxComputeContext),
+        .device = ctx.device.Get(),
+        .queue = ctx.queue.Get(),
+        .encoder = cmd.Get(),
+        .vertex_buffer = ctx.vertexBuffer.Get(),
+        .index_buffer = ctx.indexBuffer.Get(),
+        .uniform_buffer = ctx.uniformBuffer.Get(),
+        .storage_buffer = ctx.storageBuffer.Get(),
+    };
+
+    std::string failure;
+    try {
+        fn(modContext, &computeContext, payload, payloadSize, userData);
+        return;
+    } catch (const std::exception& e) {
+        failure = fmt::format("exception in gfx compute callback: {}", e.what());
+    } catch (...) {
+        failure = "unknown exception in gfx compute callback";
+    }
+
+    std::lock_guard lock{s_mutex};
+    WorkerFailure record{
+        .modId = std::move(ownerId),
+        .message = std::move(failure),
+    };
+    s_workerFailures.push_back(std::move(record));
+}
+
+template <typename T>
+bool contains(const T* values, size_t count, T value) {
+    for (size_t i = 0; i < count; ++i) {
+        if (values[i] == value) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool configure_present_target(const std::shared_ptr<PresentTargetState>& state,
+    const aurora::gfx::EncoderTaskContext& ctx, uint32_t width, uint32_t height,
+    WGPUTextureUsage requestedUsage, WGPUTextureFormat preferredFormat,
+    WGPUCompositeAlphaMode preferredAlphaMode, bool vsync) {
+    if (width == 0 || height == 0) {
+        state->status.store(PresentTargetStatus::TransientUnavailable, std::memory_order_release);
+        return false;
+    }
+    if (!state->surface) {
+        state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+        return false;
+    }
+
+    const auto adapter = ctx.device.GetAdapter();
+    wgpu::SurfaceCapabilities capabilities;
+    if (!adapter ||
+        state->surface.GetCapabilities(adapter, &capabilities) != wgpu::Status::Success ||
+        capabilities.formatCount == 0 || capabilities.presentModeCount == 0 ||
+        capabilities.alphaModeCount == 0)
+    {
+        state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+        return false;
+    }
+
+    auto format = static_cast<wgpu::TextureFormat>(preferredFormat);
+    if (format == wgpu::TextureFormat::Undefined ||
+        !contains(capabilities.formats, capabilities.formatCount, format))
+    {
+        format = aurora::gfx::color_format();
+    }
+    if (format == wgpu::TextureFormat::Undefined ||
+        !contains(capabilities.formats, capabilities.formatCount, format))
+    {
+        format = capabilities.formats[0];
+    }
+
+    const auto presentMode = aurora::webgpu::select_present_mode(capabilities);
+
+    auto alphaMode = static_cast<wgpu::CompositeAlphaMode>(preferredAlphaMode);
+    if (alphaMode != wgpu::CompositeAlphaMode::Auto &&
+        !contains(capabilities.alphaModes, capabilities.alphaModeCount, alphaMode))
+    {
+        alphaMode = capabilities.alphaModes[0];
+    }
+
+    auto usage = static_cast<wgpu::TextureUsage>(requestedUsage);
+    if (usage == wgpu::TextureUsage::None) {
+        usage = wgpu::TextureUsage::RenderAttachment;
+    }
+    if ((usage & wgpu::TextureUsage::RenderAttachment) == wgpu::TextureUsage::None ||
+        (usage & ~capabilities.usages) != wgpu::TextureUsage::None)
+    {
+        state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+        return false;
+    }
+
+    state->configuration = wgpu::SurfaceConfiguration{
+        .device = ctx.device,
+        .format = format,
+        .usage = usage,
+        .width = width,
+        .height = height,
+        .alphaMode = alphaMode,
+        .presentMode = presentMode,
+    };
+    state->surface.Configure(&state->configuration);
+    state->configured = true;
+    state->vsync = vsync;
+    state->status.store(PresentTargetStatus::Pending, std::memory_order_release);
+    return true;
+}
+
+void present_trampoline(const aurora::gfx::EncoderTaskContext& ctx, const wgpu::CommandEncoder& cmd,
+    const void* payload, size_t payloadSize, void* userdata) {
+    const auto handle = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(userdata));
+    GfxPresentFn fn = nullptr;
+    void* userData = nullptr;
+    ModContext* modContext = nullptr;
+    std::string ownerId;
+    std::shared_ptr<PresentTargetState> state;
+    uint32_t width = 0;
+    uint32_t height = 0;
+    WGPUTextureUsage usage = WGPUTextureUsage_RenderAttachment;
+    WGPUTextureFormat preferredFormat = WGPUTextureFormat_Undefined;
+    WGPUCompositeAlphaMode preferredAlphaMode = WGPUCompositeAlphaMode_Auto;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* entry = resolve_entry_locked(handle, GfxSlotKind::PresentTarget);
+        if (entry == nullptr) {
+            return;
+        }
+        const auto& slot = entry->value;
+        fn = slot.presentFn;
+        userData = slot.userData;
+        modContext = slot.ownerContext;
+        ownerId = slot.ownerId;
+        state = slot.presentState;
+        width = slot.targetWidth;
+        height = slot.targetHeight;
+        usage = slot.targetUsage;
+        preferredFormat = slot.preferredFormat;
+        preferredAlphaMode = slot.preferredAlphaMode;
+    }
+    if (fn == nullptr || state == nullptr || present_target_failed(state)) {
+        return;
+    }
+
+    state->presentPending = false;
+    state->currentView = {};
+    state->currentTexture = {};
+    const bool vsync = aurora::webgpu::vsync_enabled();
+    if (!state->configured || state->configuration.width != width ||
+        state->configuration.height != height || state->vsync != vsync)
+    {
+        if (!configure_present_target(
+                state, ctx, width, height, usage, preferredFormat, preferredAlphaMode, vsync))
+        {
+            return;
+        }
+    }
+
+    wgpu::SurfaceTexture surfaceTexture;
+    state->surface.GetCurrentTexture(&surfaceTexture);
+    if (surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessOptimal &&
+        surfaceTexture.status != wgpu::SurfaceGetCurrentTextureStatus::SuccessSuboptimal)
+    {
+        if (surfaceTexture.status == wgpu::SurfaceGetCurrentTextureStatus::Lost) {
+            state->status.store(PresentTargetStatus::Lost, std::memory_order_release);
+            state->configured = false;
+        } else if (surfaceTexture.status == wgpu::SurfaceGetCurrentTextureStatus::Outdated) {
+            state->status.store(
+                PresentTargetStatus::TransientUnavailable, std::memory_order_release);
+            state->configured = false;
+        } else if (surfaceTexture.status == wgpu::SurfaceGetCurrentTextureStatus::Error) {
+            state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+            state->configured = false;
+        } else {
+            state->status.store(
+                PresentTargetStatus::TransientUnavailable, std::memory_order_release);
+        }
+        return;
+    }
+
+    state->currentTexture = std::move(surfaceTexture.texture);
+    state->currentView = state->currentTexture.CreateView();
+    if (!state->currentTexture || !state->currentView) {
+        state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+        return;
+    }
+
+    const GfxPresentContext presentContext{
+        .struct_size = sizeof(GfxPresentContext),
+        .device = ctx.device.Get(),
+        .queue = ctx.queue.Get(),
+        .encoder = cmd.Get(),
+        .target_texture = state->currentTexture.Get(),
+        .target_view = state->currentView.Get(),
+        .target_format = static_cast<WGPUTextureFormat>(state->configuration.format),
+        .target_width = width,
+        .target_height = height,
+        .vertex_buffer = ctx.vertexBuffer.Get(),
+        .index_buffer = ctx.indexBuffer.Get(),
+        .uniform_buffer = ctx.uniformBuffer.Get(),
+        .storage_buffer = ctx.storageBuffer.Get(),
+    };
+
+    std::string failure;
+    try {
+        fn(modContext, &presentContext, payload, payloadSize, userData);
+        state->presentPending = true;
+        state->status.store(PresentTargetStatus::Ready, std::memory_order_release);
+        if (surfaceTexture.status == wgpu::SurfaceGetCurrentTextureStatus::SuccessSuboptimal) {
+            state->configured = false;
+        }
+        return;
+    } catch (const std::exception& e) {
+        failure = fmt::format("exception in gfx present callback: {}", e.what());
+    } catch (...) {
+        failure = "unknown exception in gfx present callback";
+    }
+
+    state->presentPending = false;
+    state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+    std::lock_guard lock{s_mutex};
+    s_workerFailures.push_back(WorkerFailure{
+        .modId = std::move(ownerId),
+        .message = std::move(failure),
+    });
+}
+
+void present_after_submit_trampoline(
+    const aurora::gfx::EncoderTaskCompletionContext&, const void*, size_t, void* userdata) {
+    const auto handle = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(userdata));
+    std::shared_ptr<PresentTargetState> state;
+    {
+        std::lock_guard lock{s_mutex};
+        const auto* entry = resolve_entry_locked(handle, GfxSlotKind::PresentTarget);
+        if (entry == nullptr) {
+            return;
+        }
+        state = entry->value.presentState;
+    }
+    if (state == nullptr || !state->presentPending) {
+        return;
+    }
+
+    const bool presented = state->surface.Present();
+    state->presentPending = false;
+    state->currentView = {};
+    state->currentTexture = {};
+    if (!presented) {
+        state->configured = false;
+        state->status.store(PresentTargetStatus::Error, std::memory_order_release);
+    }
+}
+
+}  // namespace
+
+ModResult gfx_register_draw_type(
+    LoadedMod& mod, const char* label, GfxDrawFn draw, void* userData, uint64_t& outHandle) {
+    outHandle = 0;
+
+    uint64_t handle = 0;
+    {
+        std::lock_guard lock{s_mutex};
+        handle = s_slots.emplace(mod, GfxSlot{
+                                          .kind = GfxSlotKind::DrawType,
+                                          .ownerContext = mod.context.get(),
+                                          .ownerId = mod.metadata.id,
+                                          .userData = userData,
+                                          .drawFn = draw,
+                                      });
+    }
+
+    const auto auroraId = aurora::gfx::register_draw_type(aurora::gfx::DrawTypeDescriptor{
+        .label = label,
+        .draw = draw_trampoline,
+        .userdata = reinterpret_cast<void*>(static_cast<uintptr_t>(handle)),
+    });
+    if (auroraId == aurora::gfx::InvalidDrawType) {
+        std::lock_guard lock{s_mutex};
+        s_slots.erase_owned(handle, mod);
+        return MOD_ERROR;
+    }
+
+    {
+        std::lock_guard lock{s_mutex};
+        if (auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::DrawType)) {
+            slot->auroraDrawId = auroraId;
+        }
+    }
+    outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_draw_type(LoadedMod& mod, uint64_t handle) {
+    aurora::gfx::DrawTypeId auroraId = aurora::gfx::InvalidDrawType;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::DrawType);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        auroraId = slot->auroraDrawId;
+        s_slots.erase_owned(handle, mod);
+    }
+    aurora::gfx::unregister_draw_type(auroraId);
+    return MOD_OK;
+}
+
+ModResult gfx_push_draw(LoadedMod& mod, uint64_t handle, const void* payload, size_t payloadSize) {
+    aurora::gfx::DrawTypeId auroraId = aurora::gfx::InvalidDrawType;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::DrawType);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        auroraId = slot->auroraDrawId;
+    }
+    if (!aurora::gfx::push_custom_draw(auroraId, payload, payloadSize)) {
+        return MOD_UNAVAILABLE;
+    }
+    return MOD_OK;
+}
+
+ModResult gfx_push_stream(
+    GfxStreamBuffer buffer, const void* data, size_t size, size_t alignment, GfxRange& outRange) {
+    aurora::gfx::Range range;
+    const auto* bytes = static_cast<const uint8_t*>(data);
+    switch (buffer) {
+    case GfxStreamBuffer::Verts:
+        range = aurora::gfx::push_verts(bytes, size, alignment);
+        break;
+    case GfxStreamBuffer::Indices:
+        range = aurora::gfx::push_indices(bytes, size, alignment);
+        break;
+    case GfxStreamBuffer::Uniform:
+        range = aurora::gfx::push_uniform(bytes, size);
+        break;
+    case GfxStreamBuffer::Storage:
+        range = aurora::gfx::push_storage(bytes, size);
+        break;
+    }
+    if (range.size == 0) {
+        return MOD_UNAVAILABLE;
+    }
+    outRange = GfxRange{.offset = range.offset, .size = range.size};
+    return MOD_OK;
+}
+
+ModResult gfx_register_stage_hook(
+    LoadedMod& mod, GfxStage stage, GfxStageFn callback, void* userData, uint64_t& outHandle) {
+    outHandle = 0;
+    std::lock_guard lock{s_mutex};
+    outHandle = s_slots.emplace(mod, GfxSlot{
+                                         .kind = GfxSlotKind::StageHook,
+                                         .ownerContext = mod.context.get(),
+                                         .ownerId = mod.metadata.id,
+                                         .userData = userData,
+                                         .stageFn = callback,
+                                         .stage = stage,
+                                     });
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_stage_hook(LoadedMod& mod, uint64_t handle) {
+    std::lock_guard lock{s_mutex};
+    auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::StageHook);
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    s_slots.erase_owned(handle, mod);
+    return MOD_OK;
+}
+
+ModResult gfx_resolve_pass(LoadedMod& mod, const GfxResolveDesc& desc, GfxResolvedTargets& out) {
+    out = GfxResolvedTargets{.struct_size = sizeof(GfxResolvedTargets)};
+    if (aurora::gfx::is_offscreen() && !s_modOffscreenOpen) {
+        Log.error(
+            "[{}] resolve_pass: the active offscreen pass belongs to the game", mod.metadata.id);
+        return MOD_UNAVAILABLE;
+    }
+    const bool closesModOffscreen = s_modOffscreenOpen;
+
+    aurora::gfx::ResolvedTargets resolved;
+    if (!aurora::gfx::resolve_pass(
+            aurora::gfx::ResolveDesc{.color = desc.color, .depth = desc.depth}, resolved))
+    {
+        return MOD_UNAVAILABLE;
+    }
+    if (closesModOffscreen) {
+        s_modOffscreenOpen = false;
+    }
+
+    out.color = resolved.color.Get();
+    out.depth = resolved.depth.Get();
+    out.color_format = static_cast<WGPUTextureFormat>(resolved.colorFormat);
+    out.width = resolved.width;
+    out.height = resolved.height;
+    return MOD_OK;
+}
+
+ModResult gfx_create_pass(LoadedMod& mod, uint32_t width, uint32_t height) {
+    if (aurora::gfx::is_offscreen()) {
+        Log.error("[{}] create_pass: an offscreen pass is already active", mod.metadata.id);
+        return MOD_UNAVAILABLE;
+    }
+    if (!aurora::gfx::create_pass(width, height)) {
+        return MOD_UNAVAILABLE;
+    }
+    s_modOffscreenOpen = true;
+    return MOD_OK;
+}
+
+ModResult gfx_register_compute_type(
+    LoadedMod& mod, const char* label, GfxComputeFn callback, void* userData, uint64_t& outHandle) {
+    outHandle = 0;
+
+    uint64_t handle = 0;
+    {
+        std::lock_guard lock{s_mutex};
+        handle = s_slots.emplace(mod, GfxSlot{
+                                          .kind = GfxSlotKind::ComputeType,
+                                          .ownerContext = mod.context.get(),
+                                          .ownerId = mod.metadata.id,
+                                          .userData = userData,
+                                          .computeFn = callback,
+                                      });
+    }
+
+    const auto auroraId =
+        aurora::gfx::register_encoder_task_type(aurora::gfx::EncoderTaskDescriptor{
+            .label = label,
+            .callback = compute_trampoline,
+            .userdata = reinterpret_cast<void*>(static_cast<uintptr_t>(handle)),
+        });
+    if (auroraId == aurora::gfx::InvalidEncoderTask) {
+        std::lock_guard lock{s_mutex};
+        s_slots.erase_owned(handle, mod);
+        return MOD_ERROR;
+    }
+
+    {
+        std::lock_guard lock{s_mutex};
+        if (auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::ComputeType)) {
+            slot->auroraTaskId = auroraId;
+        }
+    }
+    outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_compute_type(LoadedMod& mod, uint64_t handle) {
+    aurora::gfx::EncoderTaskId auroraId = aurora::gfx::InvalidEncoderTask;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::ComputeType);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        auroraId = slot->auroraTaskId;
+        s_slots.erase_owned(handle, mod);
+    }
+    aurora::gfx::unregister_encoder_task_type(auroraId);
+    return MOD_OK;
+}
+
+ModResult gfx_push_compute(
+    LoadedMod& mod, uint64_t handle, const void* payload, size_t payloadSize) {
+    aurora::gfx::EncoderTaskId auroraId = aurora::gfx::InvalidEncoderTask;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::ComputeType);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        auroraId = slot->auroraTaskId;
+    }
+    if (!aurora::gfx::push_encoder_task(auroraId, payload, payloadSize)) {
+        return MOD_UNAVAILABLE;
+    }
+    return MOD_OK;
+}
+
+ModResult gfx_register_present_target(LoadedMod& mod, wgpu::Surface surface, WindowHandle window,
+    const GfxPresentTargetDesc& desc, uint64_t& outHandle) {
+    outHandle = 0;
+    auto state = std::make_shared<PresentTargetState>();
+    state->surface = std::move(surface);
+
+    uint64_t handle = 0;
+    {
+        std::lock_guard lock{s_mutex};
+        handle = s_slots.emplace(mod, GfxSlot{
+                                          .kind = GfxSlotKind::PresentTarget,
+                                          .ownerContext = mod.context.get(),
+                                          .ownerId = mod.metadata.id,
+                                          .userData = desc.user_data,
+                                          .presentFn = desc.render,
+                                          .presentState = state,
+                                          .window = window,
+                                          .targetWidth = desc.width,
+                                          .targetHeight = desc.height,
+                                          .targetUsage = desc.usage == WGPUTextureUsage_None ?
+                                                             WGPUTextureUsage_RenderAttachment :
+                                                             desc.usage,
+                                          .preferredFormat = desc.preferred_format,
+                                          .preferredAlphaMode = desc.preferred_alpha_mode,
+                                      });
+    }
+
+    const auto auroraId =
+        aurora::gfx::register_encoder_task_type(aurora::gfx::EncoderTaskDescriptor{
+            .label = desc.label,
+            .callback = present_trampoline,
+            .userdata = reinterpret_cast<void*>(static_cast<uintptr_t>(handle)),
+            .afterSubmit = present_after_submit_trampoline,
+        });
+    if (auroraId == aurora::gfx::InvalidEncoderTask) {
+        std::lock_guard lock{s_mutex};
+        s_slots.erase_owned(handle, mod);
+        return MOD_ERROR;
+    }
+
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::PresentTarget);
+        if (slot == nullptr) {
+            aurora::gfx::unregister_encoder_task_type(auroraId);
+            return MOD_ERROR;
+        }
+        slot->auroraTaskId = auroraId;
+    }
+    outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_present_target(LoadedMod& mod, uint64_t handle) {
+    aurora::gfx::EncoderTaskId auroraId = aurora::gfx::InvalidEncoderTask;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::PresentTarget);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        auroraId = slot->auroraTaskId;
+    }
+
+    if (auroraId != aurora::gfx::InvalidEncoderTask) {
+        aurora::gfx::unregister_encoder_task_type(auroraId);
+        aurora::gfx::synchronize();
+    }
+
+    std::optional<GfxSlotMap::Entry> removed;
+    {
+        std::lock_guard lock{s_mutex};
+        removed = s_slots.take_owned(handle, mod);
+    }
+    if (!removed.has_value()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (removed->value.presentState != nullptr && removed->value.presentState->configured) {
+        removed->value.presentState->surface.Unconfigure();
+    }
+    if (removed->value.window != 0) {
+        svc::window_release_for_graphics(mod, removed->value.window);
+    }
+    return MOD_OK;
+}
+
+ModResult gfx_resize_present_target(
+    LoadedMod& mod, uint64_t handle, uint32_t width, uint32_t height) {
+    std::lock_guard lock{s_mutex};
+    auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::PresentTarget);
+    if (slot == nullptr || width == 0 || height == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (slot->window != 0) {
+        return MOD_UNSUPPORTED;
+    }
+    slot->targetWidth = width;
+    slot->targetHeight = height;
+    return MOD_OK;
+}
+
+ModResult gfx_push_present(
+    LoadedMod& mod, uint64_t handle, const void* payload, size_t payloadSize) {
+    WindowHandle window = 0;
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::PresentTarget);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        if (present_target_failed(slot->presentState)) {
+            return MOD_ERROR;
+        }
+        window = slot->window;
+    }
+
+    uint32_t width = 0;
+    uint32_t height = 0;
+    if (window != 0 && !svc::window_get_pixel_size(mod, window, width, height)) {
+        return MOD_UNAVAILABLE;
+    }
+
+    aurora::gfx::EncoderTaskId auroraId = aurora::gfx::InvalidEncoderTask;
+    const uint32_t frame = aurora::gfx::current_frame();
+    {
+        std::lock_guard lock{s_mutex};
+        auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::PresentTarget);
+        if (slot == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        if (present_target_failed(slot->presentState)) {
+            return MOD_ERROR;
+        }
+        if (slot->lastPresentFrame == frame) {
+            return MOD_CONFLICT;
+        }
+        if (window != 0) {
+            slot->targetWidth = width;
+            slot->targetHeight = height;
+        }
+        auroraId = slot->auroraTaskId;
+    }
+    if (!aurora::gfx::push_encoder_task(auroraId, payload, payloadSize)) {
+        return MOD_UNAVAILABLE;
+    }
+    {
+        std::lock_guard lock{s_mutex};
+        if (auto* slot = resolve_owned_slot_locked(mod, handle, GfxSlotKind::PresentTarget)) {
+            slot->lastPresentFrame = frame;
+        }
+    }
+    return MOD_OK;
+}
+
+void gfx_run_stage(
+    GfxStage stage, const view_class* gameView, const view_port_class* gameViewport) {
+    struct StageEntry {
+        uint64_t handle;
+        GfxStageFn fn;
+        void* userData;
+        ModContext* context;
+        LoadedMod* owner;
+    };
+
+    std::vector<StageEntry> entries;
+    {
+        std::lock_guard lock{s_mutex};
+        s_slots.for_each([&](uint64_t handle, const auto& slotEntry) {
+            const auto& slot = slotEntry.value;
+            if (slot.kind == GfxSlotKind::StageHook && slot.stage == stage) {
+                entries.push_back(StageEntry{
+                    .handle = handle,
+                    .fn = slot.stageFn,
+                    .userData = slot.userData,
+                    .context = slot.ownerContext,
+                    .owner = slotEntry.owner,
+                });
+            }
+        });
+    }
+    if (entries.empty()) {
+        return;
+    }
+
+    const GfxStageContext stageContext{
+        .struct_size = sizeof(GfxStageContext),
+        .stage = stage,
+        .game_view = gameView,
+        .game_viewport = gameViewport,
+    };
+
+    AuroraGXSync();
+    for (const auto& entry : entries) {
+        {
+            std::lock_guard lock{s_mutex};
+            if (resolve_slot_locked(entry.handle, GfxSlotKind::StageHook) == nullptr) {
+                continue;
+            }
+        }
+        if (!entry.owner->active) {
+            continue;
+        }
+
+        const bool wasOffscreen = aurora::gfx::is_offscreen();
+        try {
+            entry.fn(entry.context, &stageContext, entry.userData);
+        } catch (const std::exception& e) {
+            fail_mod(*entry.owner, MOD_ERROR,
+                fmt::format("exception in gfx stage callback: {}", e.what()));
+        } catch (...) {
+            fail_mod(*entry.owner, MOD_ERROR, "unknown exception in gfx stage callback");
+        }
+
+        AuroraGXSync();
+        if (aurora::gfx::is_offscreen() != wasOffscreen) {
+            aurora::gfx::ResolvedTargets discarded;
+            aurora::gfx::resolve_pass(
+                aurora::gfx::ResolveDesc{.color = false, .depth = false}, discarded);
+            s_modOffscreenOpen = false;
+            fail_mod(*entry.owner, MOD_ERROR,
+                "gfx stage callback returned with its offscreen pass still open");
+        }
+    }
+}
+
+void gfx_mod_detached(LoadedMod& mod) {
+    gfx_mod_deactivating(mod);
+
+    std::vector<GfxSlotMap::Entry> entries;
+    {
+        std::lock_guard lock{s_mutex};
+        entries = s_slots.take_all(mod);
+    }
+    for (auto& entry : entries) {
+        auto& slot = entry.value;
+        if (slot.kind != GfxSlotKind::PresentTarget) {
+            continue;
+        }
+        if (slot.presentState != nullptr && slot.presentState->configured) {
+            slot.presentState->surface.Unconfigure();
+        }
+        if (slot.window != 0) {
+            svc::window_release_for_graphics(mod, slot.window);
+        }
+    }
+}
+
+void gfx_frame_begin() {
+    std::vector<WorkerFailure> failures;
+    {
+        std::lock_guard lock{s_mutex};
+        failures.swap(s_workerFailures);
+    }
+    if (failures.empty()) {
+        return;
+    }
+
+    for (const auto& failure : failures) {
+        for (auto& mod : ModLoader::instance().mods()) {
+            if (mod.metadata.id == failure.modId && mod.active) {
+                gfx_mod_detached(mod);
+                fail_mod(mod, MOD_ERROR, failure.message);
+                break;
+            }
+        }
+    }
+}
+
+}  // namespace dusk::mods
+
+namespace dusk::mods::svc {
+namespace {
+
+ModResult gfx_get_device_info(ModContext* context, GfxDeviceInfo* outInfo) {
+    constexpr uint32_t v0Size = offsetof(GfxDeviceInfo, instance);
+    if (outInfo == nullptr || outInfo->struct_size < v0Size) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const uint32_t structSize = outInfo->struct_size;
+    outInfo->device = nullptr;
+    outInfo->queue = nullptr;
+    outInfo->color_format = WGPUTextureFormat_Undefined;
+    outInfo->depth_format = WGPUTextureFormat_Undefined;
+    outInfo->sample_count = 1;
+    outInfo->uses_reversed_z = false;
+    if (structSize >= sizeof(GfxDeviceInfo)) {
+        outInfo->instance = nullptr;
+        outInfo->adapter = nullptr;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    const auto device = aurora::gfx::device();
+    outInfo->device = device.Get();
+    outInfo->queue = aurora::gfx::queue().Get();
+    outInfo->color_format = static_cast<WGPUTextureFormat>(aurora::gfx::color_format());
+    outInfo->depth_format = static_cast<WGPUTextureFormat>(aurora::gfx::depth_format());
+    outInfo->sample_count = aurora::gfx::sample_count();
+    outInfo->uses_reversed_z = aurora::gfx::uses_reversed_z();
+    if (structSize >= sizeof(GfxDeviceInfo)) {
+        const auto adapter = device.GetAdapter();
+        const auto instance = adapter ? adapter.GetInstance() : wgpu::Instance{};
+        outInfo->instance = instance.Get();
+        outInfo->adapter = adapter.Get();
+    }
+    return MOD_OK;
+}
+
+ModResult gfx_get_scene_target_layout(ModContext* context, GfxRenderTargetLayout* outLayout) {
+    if (outLayout == nullptr || outLayout->struct_size < sizeof(GfxRenderTargetLayout) ||
+        mod_from_context(context) == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    const uint32_t structSize = outLayout->struct_size;
+    *outLayout = gfx_render_target_layout(aurora::gfx::scene_render_target_layout());
+    outLayout->struct_size = structSize;
+    return MOD_OK;
+}
+
+void* gfx_get_proc_address(ModContext* context, const char* name) {
+    if (mod_from_context(context) == nullptr || name == nullptr) {
+        return nullptr;
+    }
+    return reinterpret_cast<void*>(wgpuGetProcAddress(WGPUStringView{name, WGPU_STRLEN}));
+}
+
+bool valid_present_desc(const GfxPresentTargetDesc* desc) {
+    return desc != nullptr && desc->struct_size >= sizeof(GfxPresentTargetDesc) &&
+           desc->render != nullptr;
+}
+
+ModResult gfx_register_present_target_impl(ModContext* context, WGPUSurface surface,
+    const GfxPresentTargetDesc* desc, GfxPresentTargetHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || surface == nullptr || !valid_present_desc(desc) || outHandle == nullptr ||
+        desc->width == 0 || desc->height == 0)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint64_t handle = 0;
+    const auto result = gfx_register_present_target(*mod, wgpu::Surface{surface}, 0, *desc, handle);
+    if (result == MOD_OK) {
+        *outHandle = handle;
+    }
+    return result;
+}
+
+ModResult gfx_register_window_present_target_impl(ModContext* context, WindowHandle window,
+    const GfxPresentTargetDesc* desc, GfxPresentTargetHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || window == 0 || !valid_present_desc(desc) || outHandle == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    SDL_Window* sdlWindow = nullptr;
+    const auto acquireResult = window_acquire_for_graphics(*mod, window, sdlWindow);
+    if (acquireResult != MOD_OK) {
+        return acquireResult;
+    }
+    uint32_t width = 0;
+    uint32_t height = 0;
+    if (!window_get_pixel_size(*mod, window, width, height)) {
+        window_release_for_graphics(*mod, window);
+        return MOD_UNAVAILABLE;
+    }
+
+    const auto device = aurora::gfx::device();
+    const auto adapter = device.GetAdapter();
+    const auto instance = adapter ? adapter.GetInstance() : wgpu::Instance{};
+    auto surface = aurora::webgpu::create_window_surface(instance, sdlWindow, desc->label);
+    if (!surface) {
+        window_release_for_graphics(*mod, window);
+        return MOD_UNAVAILABLE;
+    }
+
+    auto windowDesc = *desc;
+    windowDesc.width = width;
+    windowDesc.height = height;
+    uint64_t handle = 0;
+    const auto result =
+        gfx_register_present_target(*mod, std::move(surface), window, windowDesc, handle);
+    if (result != MOD_OK) {
+        window_release_for_graphics(*mod, window);
+        return result;
+    }
+    *outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_resize_present_target_impl(
+    ModContext* context, GfxPresentTargetHandle handle, uint32_t width, uint32_t height) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0 || width == 0 || height == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_resize_present_target(*mod, handle, width, height);
+}
+
+ModResult gfx_unregister_present_target_impl(ModContext* context, GfxPresentTargetHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_unregister_present_target(*mod, handle);
+}
+
+ModResult gfx_push_present_impl(
+    ModContext* context, GfxPresentTargetHandle handle, const void* payload, size_t payloadSize) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0 || payloadSize > GFX_INLINE_DRAW_PAYLOAD_SIZE ||
+        (payloadSize > 0 && payload == nullptr))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_push_present(*mod, handle, payload, payloadSize);
+}
+
+ModResult gfx_register_draw_type_impl(
+    ModContext* context, const GfxDrawTypeDesc* desc, GfxDrawTypeHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(GfxDrawTypeDesc) ||
+        desc->draw == nullptr || outHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint64_t handle = 0;
+    const auto result =
+        gfx_register_draw_type(*mod, desc->label, desc->draw, desc->user_data, handle);
+    if (result != MOD_OK) {
+        return result;
+    }
+    *outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_draw_type_impl(ModContext* context, GfxDrawTypeHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_unregister_draw_type(*mod, handle);
+}
+
+ModResult gfx_push_draw_impl(
+    ModContext* context, GfxDrawTypeHandle handle, const void* payload, size_t payloadSize) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0 || payloadSize > GFX_INLINE_DRAW_PAYLOAD_SIZE ||
+        (payloadSize > 0 && payload == nullptr))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_push_draw(*mod, handle, payload, payloadSize);
+}
+
+ModResult gfx_push_stream_impl(ModContext* context, GfxStreamBuffer buffer, const void* data,
+    size_t size, size_t alignment, GfxRange* outRange) {
+    if (outRange != nullptr) {
+        *outRange = GfxRange{0, 0};
+    }
+    if (mod_from_context(context) == nullptr || data == nullptr || size == 0 || outRange == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_push_stream(buffer, data, size, alignment, *outRange);
+}
+
+ModResult gfx_push_verts_impl(
+    ModContext* context, const void* data, size_t size, size_t alignment, GfxRange* outRange) {
+    return gfx_push_stream_impl(context, GfxStreamBuffer::Verts, data, size, alignment, outRange);
+}
+
+ModResult gfx_push_indices_impl(
+    ModContext* context, const void* data, size_t size, size_t alignment, GfxRange* outRange) {
+    return gfx_push_stream_impl(context, GfxStreamBuffer::Indices, data, size, alignment, outRange);
+}
+
+ModResult gfx_push_uniform_impl(
+    ModContext* context, const void* data, size_t size, GfxRange* outRange) {
+    return gfx_push_stream_impl(context, GfxStreamBuffer::Uniform, data, size, 0, outRange);
+}
+
+ModResult gfx_push_storage_impl(
+    ModContext* context, const void* data, size_t size, GfxRange* outRange) {
+    return gfx_push_stream_impl(context, GfxStreamBuffer::Storage, data, size, 0, outRange);
+}
+
+bool valid_stage(GfxStage stage) {
+    return stage == GFX_STAGE_SCENE_AFTER_TERRAIN || stage == GFX_STAGE_FRAME_BEFORE_HUD ||
+           stage == GFX_STAGE_FRAME_AFTER_HUD || stage == GFX_STAGE_SCENE_BEGIN ||
+           stage == GFX_STAGE_SCENE_AFTER_OPAQUE;
+}
+
+ModResult gfx_register_stage_hook_impl(ModContext* context, GfxStage stage,
+    const GfxStageHookDesc* desc, GfxStageHookHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(GfxStageHookDesc) ||
+        desc->callback == nullptr || outHandle == nullptr || !valid_stage(stage))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint64_t handle = 0;
+    const auto result =
+        gfx_register_stage_hook(*mod, stage, desc->callback, desc->user_data, handle);
+    if (result != MOD_OK) {
+        return result;
+    }
+    *outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_stage_hook_impl(ModContext* context, GfxStageHookHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_unregister_stage_hook(*mod, handle);
+}
+
+ModResult gfx_resolve_pass_impl(
+    ModContext* context, const GfxResolveDesc* desc, GfxResolvedTargets* outTargets) {
+    if (outTargets != nullptr && outTargets->struct_size >= sizeof(GfxResolvedTargets)) {
+        *outTargets = GfxResolvedTargets{.struct_size = sizeof(GfxResolvedTargets)};
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(GfxResolveDesc) ||
+        outTargets == nullptr || outTargets->struct_size < sizeof(GfxResolvedTargets) ||
+        (!desc->color && !desc->depth))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_resolve_pass(*mod, *desc, *outTargets);
+}
+
+ModResult gfx_create_pass_impl(ModContext* context, uint32_t width, uint32_t height) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || width == 0 || height == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_create_pass(*mod, width, height);
+}
+
+ModResult gfx_register_compute_type_impl(
+    ModContext* context, const GfxComputeTypeDesc* desc, GfxComputeTypeHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(GfxComputeTypeDesc) ||
+        desc->callback == nullptr || outHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint64_t handle = 0;
+    const auto result =
+        gfx_register_compute_type(*mod, desc->label, desc->callback, desc->user_data, handle);
+    if (result != MOD_OK) {
+        return result;
+    }
+    *outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult gfx_unregister_compute_type_impl(ModContext* context, GfxComputeTypeHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_unregister_compute_type(*mod, handle);
+}
+
+ModResult gfx_push_compute_impl(
+    ModContext* context, GfxComputeTypeHandle handle, const void* payload, size_t payloadSize) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0 || payloadSize > GFX_INLINE_DRAW_PAYLOAD_SIZE ||
+        (payloadSize > 0 && payload == nullptr))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return gfx_push_compute(*mod, handle, payload, payloadSize);
+}
+
+constexpr GfxService s_gfxService{
+    .header = SERVICE_HEADER(GfxService, GFX_SERVICE_MAJOR, GFX_SERVICE_MINOR),
+    .get_device_info = gfx_get_device_info,
+    .get_proc_address = gfx_get_proc_address,
+    .register_draw_type = gfx_register_draw_type_impl,
+    .unregister_draw_type = gfx_unregister_draw_type_impl,
+    .push_draw = gfx_push_draw_impl,
+    .register_compute_type = gfx_register_compute_type_impl,
+    .unregister_compute_type = gfx_unregister_compute_type_impl,
+    .push_compute = gfx_push_compute_impl,
+    .push_verts = gfx_push_verts_impl,
+    .push_indices = gfx_push_indices_impl,
+    .push_uniform = gfx_push_uniform_impl,
+    .push_storage = gfx_push_storage_impl,
+    .register_stage_hook = gfx_register_stage_hook_impl,
+    .unregister_stage_hook = gfx_unregister_stage_hook_impl,
+    .resolve_pass = gfx_resolve_pass_impl,
+    .create_pass = gfx_create_pass_impl,
+    .register_present_target = gfx_register_present_target_impl,
+    .register_window_present_target = gfx_register_window_present_target_impl,
+    .resize_present_target = gfx_resize_present_target_impl,
+    .unregister_present_target = gfx_unregister_present_target_impl,
+    .push_present = gfx_push_present_impl,
+    .get_scene_target_layout = gfx_get_scene_target_layout,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_gfxModule{
+    .id = GFX_SERVICE_ID,
+    .majorVersion = GFX_SERVICE_MAJOR,
+    .minorVersion = GFX_SERVICE_MINOR,
+    .service = &s_gfxService,
+    .modDeactivating = gfx_mod_deactivating,
+    .modDetached = gfx_mod_detached,
+    .frameBegin = gfx_frame_begin,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/hook.cpp b/src/dusk/mods/svc/hook.cpp
index 41399bf97d..725e83ab47 100644
--- a/src/dusk/mods/svc/hook.cpp
+++ b/src/dusk/mods/svc/hook.cpp
@@ -1,18 +1,26 @@
 #include "registry.hpp"
 
 #include "dusk/mods/loader/loader.hpp"
+#if DUSK_HAS_PREPATCH
+#include "dusk/mods/loader/prepatch.hpp"
+#endif
 #include "dusk/mods/manifest.hpp"
 #include "mods/svc/hook.h"
 
 #if DUSK_CODE_MODS
 #include "dusk/logging.h"
+#include "dusk/mods/log_buffer.hpp"
 
 #include <algorithm>
+#include <cstddef>
 #include <cstdint>
 #include <cstring>
 #include <exception>
 #include <fmt/format.h>
+#if DUSK_HAS_FUNCHOOK
 #include <funchook.h>
+#endif
+#include <string>
 #include <unordered_map>
 #include <vector>
 #endif
@@ -46,8 +54,7 @@ struct HookSlot {
 // One per mod that requested a hook on a target: its template-generated trampoline and the
 // address of its Hook::g_orig, both living in the mod's dylib. Any candidate's trampoline
 // is interchangeable (dispatch walks the shared HookSlot), so when the active installer's mod
-// unloads, the funchook detour is handed off to a surviving candidate and every candidate's
-// *orig_store is rewritten to the new original pointer.
+// unloads, the backend is handed off to a surviving candidate.
 struct HookCandidate {
     ModContext* context = nullptr;
     void* trampoline = nullptr;
@@ -55,17 +62,59 @@ struct HookCandidate {
     uint64_t order = 0;
 };
 
-struct InstalledHook {
+enum class BackendKind {
+    None,
+#if DUSK_HAS_FUNCHOOK
+    Funchook,
+#endif
+#if DUSK_HAS_PREPATCH
+    Prepatch,
+#endif
+};
+
+struct InstalledBackend {
+    BackendKind kind = BackendKind::None;
+#if DUSK_HAS_FUNCHOOK
     funchook_t* handle = nullptr;
+#endif
+#if DUSK_HAS_PREPATCH
+    prepatch::Site prepatchSite{};
+#endif
+};
+
+struct InstalledHook {
+    InstalledBackend backend{};
     void* original = nullptr;
     ModContext* active = nullptr;
+    void** activeStore = nullptr;
     std::vector<HookCandidate> candidates;
 };
 
 std::unordered_map<uintptr_t, HookSlot> s_registry;
 std::unordered_map<uintptr_t, InstalledHook> s_installed;
+std::unordered_map<const ModContext*, std::vector<uintptr_t>> s_declaredTargets;
 uint64_t s_nextOrder = 0;
 
+bool declared_target(const ModContext* context, void* fnAddr) {
+    if (context == nullptr) {
+        return false;
+    }
+    const auto it = s_declaredTargets.find(context);
+    if (it == s_declaredTargets.end()) {
+        return false;
+    }
+    const auto addr = reinterpret_cast<uintptr_t>(fnAddr);
+    return std::ranges::find(it->second, addr) != it->second.end();
+}
+
+ModResult reject_undeclared(ModContext* context, void* fnAddr) {
+    log::write(mod_id_from_context(context), LOG_LEVEL_ERROR,
+        "tried to hook undeclared target {:p}; hook targets must be declared with "
+        "DEFINE_HOOK/DEFINE_HOOK_SYMBOL",
+        fnAddr);
+    return MOD_INVALID_ARGUMENT;
+}
+
 HookOptions normalize_options(const HookOptions* options) {
     if (options == nullptr || options->struct_size < sizeof(HookOptions)) {
         return HOOK_OPTIONS_INIT;
@@ -95,10 +144,28 @@ void sort_hooks(std::vector<T>& hooks) {
     });
 }
 
+bool erase_callbacks(HookSlot& slot, ModContext* context) {
+    std::erase_if(slot.pre, [&](const PreHookFn& hook) { return hook.context == context; });
+    std::erase_if(slot.post, [&](const VoidHookFn& hook) { return hook.context == context; });
+    if (slot.replace.context == context) {
+        slot.replace = {};
+    }
+    return slot.pre.empty() && slot.post.empty() && slot.replace.replaceCallback == nullptr;
+}
+
+// Once a hook is installed, funchook has patched the target's entry: its bytes lead to the
+// detour, not the function, so canonicalization must stop there.
+[[maybe_unused]] bool installed_target(void* addr) {
+    return s_installed.contains(reinterpret_cast<uintptr_t>(addr));
+}
+
 // Follow E9/FF25 chains to skip MSVC incremental-link and import stubs.
 void* resolve_import_thunk(void* addr) {
 #if defined(_WIN32) && (defined(_M_X64) || defined(__x86_64__))
     for (int i = 0; i < 8; ++i) {
+        if (installed_target(addr)) {
+            break;
+        }
         const auto* p = static_cast<const uint8_t*>(addr);
         if (p[0] == 0x48 && p[1] == 0xFF && p[2] == 0x25) {  // lld emits a REX.W prefix
             ++p;
@@ -122,6 +189,9 @@ void* resolve_import_thunk(void* addr) {
     // incremental-link stubs are a plain `b`, or `adrp x16; add x16, x16, #off; br x16`
     // range-extension thunks when the target is out of B range.
     for (int i = 0; i < 8; ++i) {
+        if (installed_target(addr)) {
+            break;
+        }
         const auto* p = static_cast<const uint8_t*>(addr);
         uint32_t insn0, insn1, insn2;
         std::memcpy(&insn0, p, 4);
@@ -158,7 +228,20 @@ void* resolve_import_thunk(void* addr) {
     return addr;
 }
 
-funchook_t* install_trampoline(void* fnAddr, void* trampoline, void** outOriginal) {
+// Resolve thunks recursively (max of 8 steps) until we find our target.
+void* resolve_target(void* addr) {
+    for (int i = 0; i < 8; ++i) {
+        void* next = resolve_import_thunk(addr);
+        if (next == addr) {
+            break;
+        }
+        addr = next;
+    }
+    return addr;
+}
+
+#if DUSK_HAS_FUNCHOOK
+funchook_t* install_funchook(void* fnAddr, void* trampoline, void** outOriginal) {
     funchook_t* fh = funchook_create();
     if (fh == nullptr) {
         DuskLog.warn("HookSystem: funchook_create failed for {:p}", fnAddr);
@@ -167,18 +250,146 @@ funchook_t* install_trampoline(void* fnAddr, void* trampoline, void** outOrigina
 
     void* fn = fnAddr;
     const int prep = funchook_prepare(fh, &fn, trampoline);
+    if (prep == 0) {
+        *outOriginal = fn;
+    }
     const int inst = prep == 0 ? funchook_install(fh, 0) : -1;
     if (prep != 0 || inst != 0) {
         const char* message = funchook_error_message(fh);
         DuskLog.warn("HookSystem: funchook failed for {:p} (prepare={} install={}): {}", fnAddr,
             prep, inst, message != nullptr && message[0] != '\0' ? message : "no details");
         funchook_destroy(fh);
+        *outOriginal = nullptr;
         return nullptr;
     }
-
-    *outOriginal = fn;
     return fh;
 }
+#endif
+
+bool install_backend(
+    void* fnAddr, void* trampoline, InstalledBackend& outBackend, void** originalStore) {
+#if DUSK_HAS_PREPATCH
+    if (const auto site = prepatch::lookup(fnAddr)) {
+        *originalStore = site->original;
+        prepatch::publish(*site, trampoline);
+        outBackend.kind = BackendKind::Prepatch;
+        outBackend.prepatchSite = *site;
+        return true;
+    }
+#endif
+
+#if DUSK_HAS_FUNCHOOK
+    funchook_t* handle = install_funchook(fnAddr, trampoline, originalStore);
+    if (handle == nullptr) {
+        return false;
+    }
+    outBackend.kind = BackendKind::Funchook;
+    outBackend.handle = handle;
+    return true;
+#else
+#if DUSK_HAS_PREPATCH
+    DuskLog.warn("HookSystem: prepatch backend cannot install target {:p}: {}", fnAddr,
+        prepatch::available() ? "target has no valid gateway" : prepatch::unavailable_reason());
+#else
+    DuskLog.warn("HookSystem: no hook backend can install target {:p}", fnAddr);
+#endif
+    return false;
+#endif
+}
+
+bool deactivate_backend(void* target, InstalledBackend& backend) {
+#if DUSK_HAS_PREPATCH
+    if (backend.kind == BackendKind::Prepatch) {
+        prepatch::publish(backend.prepatchSite, nullptr);
+        backend = {};
+        return true;
+    }
+#endif
+#if DUSK_HAS_FUNCHOOK
+    if (backend.kind == BackendKind::Funchook) {
+        const int uninst = funchook_uninstall(backend.handle, 0);
+        if (uninst != 0) {
+            DuskLog.warn("HookSystem: funchook uninstall for {:p} failed: {}", target,
+                funchook_error_message(backend.handle));
+            return false;
+        }
+        const int destr = funchook_destroy(backend.handle);
+        if (destr != 0) {
+            DuskLog.warn("HookSystem: funchook destroy for {:p} returned {}", target, destr);
+        }
+    }
+#else
+    (void)target;
+#endif
+    backend = {};
+    return true;
+}
+
+bool handoff_backend(
+    void* target, InstalledHook& entry, const HookCandidate& candidate, void** outOriginal) {
+#if DUSK_HAS_PREPATCH
+    if (entry.backend.kind == BackendKind::Prepatch) {
+        *candidate.origStore = entry.original;
+        prepatch::publish(entry.backend.prepatchSite, candidate.trampoline);
+        *outOriginal = entry.original;
+        return true;
+    }
+#endif
+#if DUSK_HAS_FUNCHOOK
+    InstalledBackend backend;
+    if (!install_backend(target, candidate.trampoline, backend, candidate.origStore)) {
+        return false;
+    }
+    entry.backend = backend;
+    *outOriginal = *candidate.origStore;
+    return true;
+#else
+    (void)target;
+    (void)candidate;
+    (void)outOriginal;
+    return false;
+#endif
+}
+
+bool handoff_hook(void* target, InstalledHook& entry) {
+#if DUSK_HAS_PREPATCH
+    const bool prepatched = entry.backend.kind == BackendKind::Prepatch;
+#else
+    constexpr bool prepatched = false;
+#endif
+    if (!prepatched && !deactivate_backend(target, entry.backend)) {
+        DuskLog.fatal("HookSystem: cannot hand off a hook that remains installed at {:p}", target);
+    }
+
+    entry.active = nullptr;
+    entry.activeStore = nullptr;
+    for (auto& candidate : entry.candidates) {
+        void* original = nullptr;
+        if (!handoff_backend(target, entry, candidate, &original)) {
+            continue;
+        }
+        entry.original = original;
+        entry.active = candidate.context;
+        entry.activeStore = candidate.origStore;
+        break;
+    }
+
+    if (entry.active == nullptr) {
+        DuskLog.warn("HookSystem: no reinstallable trampoline for {:p}; hooks there are "
+                     "disabled until a mod reinstalls one",
+            target);
+        for (auto& candidate : entry.candidates) {
+            *candidate.origStore = target;
+        }
+        deactivate_backend(target, entry.backend);
+        return false;
+    }
+
+    for (auto& candidate : entry.candidates) {
+        *candidate.origStore = entry.original;
+    }
+    return true;
+}
 
 ModResult hook_install(ModContext* context, void* fnAddr, void* trampolineFn, void** outOriginal) {
     if (fnAddr == nullptr || trampolineFn == nullptr || outOriginal == nullptr) {
@@ -199,7 +410,10 @@ ModResult hook_install(ModContext* context, void* fnAddr, void* trampolineFn, vo
         return MOD_INVALID_ARGUMENT;
     }
 
-    fnAddr = resolve_import_thunk(fnAddr);
+    fnAddr = resolve_target(fnAddr);
+    if (!declared_target(context, fnAddr)) {
+        return reject_undeclared(context, fnAddr);
+    }
     const auto key = reinterpret_cast<uintptr_t>(fnAddr);
     if (const auto it = s_installed.find(key); it != s_installed.end()) {
         auto& entry = it->second;
@@ -222,18 +436,17 @@ ModResult hook_install(ModContext* context, void* fnAddr, void* trampolineFn, vo
             name != nullptr ? name : "?", fnAddr, mod_id_from_context(context));
     }
 
-    void* original = nullptr;
-    funchook_t* fh = install_trampoline(fnAddr, trampolineFn, &original);
-    if (fh == nullptr) {
+    InstalledBackend backend;
+    if (!install_backend(fnAddr, trampolineFn, backend, outOriginal)) {
         return MOD_ERROR;
     }
 
     auto& entry = s_installed[key];
-    entry.handle = fh;
-    entry.original = original;
+    entry.backend = backend;
+    entry.original = *outOriginal;
     entry.active = context;
+    entry.activeStore = outOriginal;
     entry.candidates.push_back({context, trampolineFn, outOriginal, s_nextOrder++});
-    *outOriginal = original;
     return MOD_OK;
 }
 
@@ -242,7 +455,10 @@ ModResult hook_add_pre(
     if (fnAddr == nullptr || context == nullptr || callback == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    fnAddr = resolve_import_thunk(fnAddr);
+    fnAddr = resolve_target(fnAddr);
+    if (!declared_target(context, fnAddr)) {
+        return reject_undeclared(context, fnAddr);
+    }
     auto& hooks = s_registry[reinterpret_cast<uintptr_t>(fnAddr)].pre;
     hooks.push_back({context, callback, normalize_options(options), s_nextOrder++});
     sort_hooks(hooks);
@@ -254,7 +470,10 @@ ModResult hook_add_post(
     if (fnAddr == nullptr || context == nullptr || callback == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    fnAddr = resolve_import_thunk(fnAddr);
+    fnAddr = resolve_target(fnAddr);
+    if (!declared_target(context, fnAddr)) {
+        return reject_undeclared(context, fnAddr);
+    }
     auto& hooks = s_registry[reinterpret_cast<uintptr_t>(fnAddr)].post;
     hooks.push_back({context, nullptr, callback, normalize_options(options), s_nextOrder++});
     sort_hooks(hooks);
@@ -268,7 +487,10 @@ ModResult hook_replace(
     }
 
     const HookOptions normalized = normalize_options(options);
-    fnAddr = resolve_import_thunk(fnAddr);
+    fnAddr = resolve_target(fnAddr);
+    if (!declared_target(context, fnAddr)) {
+        return reject_undeclared(context, fnAddr);
+    }
     auto& slot = s_registry[reinterpret_cast<uintptr_t>(fnAddr)];
     if (slot.replace.replaceCallback == nullptr) {
         slot.replace = {context, callback, nullptr, normalized, s_nextOrder++};
@@ -293,6 +515,64 @@ ModResult hook_replace(
     return MOD_INVALID_ARGUMENT;
 }
 
+ModResult hook_uninstall(ModContext* context, void* fnAddr, void** originalFnSlot) {
+    if (context == nullptr || fnAddr == nullptr || originalFnSlot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    fnAddr = resolve_target(fnAddr);
+    if (!declared_target(context, fnAddr)) {
+        return reject_undeclared(context, fnAddr);
+    }
+
+    const auto key = reinterpret_cast<uintptr_t>(fnAddr);
+    const auto installedIt = s_installed.find(key);
+    if (installedIt == s_installed.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    auto& entry = installedIt->second;
+    const auto candidateIt =
+        std::ranges::find_if(entry.candidates, [&](const HookCandidate& candidate) {
+            return candidate.context == context && candidate.origStore == originalFnSlot;
+        });
+    if (candidateIt == entry.candidates.end()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    const bool removedActive = entry.activeStore == originalFnSlot;
+#if DUSK_HAS_FUNCHOOK
+    if (removedActive && entry.backend.kind == BackendKind::Funchook &&
+        !deactivate_backend(fnAddr, entry.backend)) {
+        return MOD_ERROR;
+    }
+#endif
+
+    if (const auto registryIt = s_registry.find(key);
+        registryIt != s_registry.end() && erase_callbacks(registryIt->second, context))
+    {
+        s_registry.erase(registryIt);
+    }
+
+    entry.candidates.erase(candidateIt);
+    *originalFnSlot = nullptr;
+    if (!removedActive) {
+        return MOD_OK;
+    }
+
+    auto* target = reinterpret_cast<void*>(key);
+    if (entry.candidates.empty()) {
+        deactivate_backend(target, entry.backend);
+        s_installed.erase(installedIt);
+        return MOD_OK;
+    }
+    if (!handoff_hook(target, entry)) {
+        s_installed.erase(installedIt);
+        return MOD_ERROR;
+    }
+    return MOD_OK;
+}
+
 ModResult hook_dispatch_pre(
     ModContext*, void* fnAddr, void* args, void* retval, int* outSkipOriginal) {
     if (outSkipOriginal != nullptr) {
@@ -302,7 +582,7 @@ ModResult hook_dispatch_pre(
         return MOD_INVALID_ARGUMENT;
     }
 
-    fnAddr = resolve_import_thunk(fnAddr);
+    fnAddr = resolve_target(fnAddr);
     const auto it = s_registry.find(reinterpret_cast<uintptr_t>(fnAddr));
     if (it == s_registry.end()) {
         return MOD_OK;
@@ -352,7 +632,7 @@ ModResult hook_dispatch_post(ModContext*, void* fnAddr, void* args, void* retval
         return MOD_INVALID_ARGUMENT;
     }
 
-    fnAddr = resolve_import_thunk(fnAddr);
+    fnAddr = resolve_target(fnAddr);
     const auto it = s_registry.find(reinterpret_cast<uintptr_t>(fnAddr));
     if (it == s_registry.end()) {
         return MOD_OK;
@@ -371,17 +651,245 @@ ModResult hook_dispatch_post(ModContext*, void* fnAddr, void* args, void* retval
     return MOD_OK;
 }
 
+#if defined(_WIN32)
+/* Follow jump stubs, then match the MSVC vcall thunk a virtual mfp points at.
+ * Returns the vtable slot's byte offset, or npos when fn is not a vcall thunk. */
+size_t vcall_slot_offset(const void*& fn) noexcept {
+    constexpr size_t npos = static_cast<size_t>(-1);
+#if defined(_M_X64) || defined(__x86_64__)
+    const auto* p = static_cast<const uint8_t*>(fn);
+    for (int i = 0; i < 8 && p[0] == 0xE9; ++i) {  // incremental-link stubs
+        int32_t rel;
+        std::memcpy(&rel, p + 1, 4);
+        p += 5 + rel;
+    }
+    fn = p;
+    // The vptr load. Unoptimized clang-cl thunks spill/reload rcx first
+    // (push rax; mov [rsp], rcx; mov rcx, [rsp]), so scan a short window.
+    const uint8_t* q = nullptr;
+    for (int i = 0; i <= 12; ++i) {
+        if (p[i] == 0x48 && p[i + 1] == 0x8B && p[i + 2] == 0x01) {  // mov rax, [rcx]
+            q = p + i + 3;
+            break;
+        }
+    }
+    if (q == nullptr) {
+        return npos;
+    }
+    if (q[0] == 0xFF && q[1] == 0x20) {  // jmp [rax]  (MSVC)
+        return 0;
+    }
+    if (q[0] == 0xFF && q[1] == 0x60) {  // jmp [rax + imm8]
+        return static_cast<int8_t>(q[2]);
+    }
+    if (q[0] == 0xFF && q[1] == 0xA0) {  // jmp [rax + imm32]
+        int32_t off;
+        std::memcpy(&off, q + 2, 4);
+        return off;
+    }
+    // clang-cl: mov rax, [rax + off]; (pop r10;) jmp rax. Requiring the jmp rax
+    // distinguishes the thunk from an ordinary getter that begins the same way.
+    if (q[0] == 0x48 && q[1] == 0x8B && (q[2] == 0x00 || q[2] == 0x40 || q[2] == 0x80)) {
+        size_t off = 0;
+        const uint8_t* r = q + 3;
+        if (q[2] == 0x40) {
+            off = static_cast<int8_t>(q[3]);
+            r = q + 4;
+        } else if (q[2] == 0x80) {
+            int32_t off32;
+            std::memcpy(&off32, q + 3, 4);
+            off = off32;
+            r = q + 7;
+        }
+        for (int i = 0; i <= 8; ++i) {
+            if (r[i] == 0xFF && r[i + 1] == 0xE0) {  // jmp rax (48 REX optional)
+                return off;
+            }
+        }
+    }
+    return npos;
+#elif defined(_M_ARM64) || defined(__aarch64__)
+    const auto* p = static_cast<const uint8_t*>(fn);
+    uint32_t insn[3];
+    for (int i = 0; i < 8; ++i) {  // incremental-link `b` stubs
+        std::memcpy(insn, p, 4);
+        if ((insn[0] & 0xFC000000u) != 0x14000000u) {
+            break;
+        }
+        const auto imm26 = static_cast<int32_t>(insn[0] << 6) >> 6;
+        p += static_cast<intptr_t>(imm26) * 4;
+    }
+    fn = p;
+    std::memcpy(insn, p, 12);
+    // ldr Xt, [x0]; ldr Xs, [Xt, #imm12*8]; br Xs
+    if ((insn[0] & 0xFFFFFFE0u) != 0xF9400000u) {
+        return npos;
+    }
+    const uint32_t t = insn[0] & 0x1Fu;
+    if ((insn[1] & 0xFFC003E0u) != (0xF9400000u | (t << 5))) {
+        return npos;
+    }
+    const uint32_t s = insn[1] & 0x1Fu;
+    if (insn[2] != (0xD61F0000u | (s << 5))) {
+        return npos;
+    }
+    return ((insn[1] >> 10) & 0xFFFu) * 8;
+#else
+    (void)fn;
+    return npos;
+#endif
+}
+#endif  // _WIN32
+
+bool resolve_symbol_checked(const char* symbol, bool requireCode, void** out, std::string& why) {
+    HookSymbolFlags flags{};
+    switch (manifest::resolve(symbol, out, &flags)) {
+    case manifest::ResolveStatus::Ok:
+        if (requireCode && (flags & HOOK_SYMBOL_CODE) == 0) {
+            why = fmt::format("'{}' is not a code symbol", symbol);
+            return false;
+        }
+        return true;
+    case manifest::ResolveStatus::Unavailable:
+        why = "no symbol manifest for this build";
+        return false;
+    case manifest::ResolveStatus::NotFound:
+        why = fmt::format("symbol '{}' not found", symbol);
+        return false;
+    case manifest::ResolveStatus::Ambiguous:
+        why = fmt::format("'{}' maps to more than one address; use the mangled name", symbol);
+        return false;
+    }
+    why = "unexpected resolve failure";
+    return false;
+}
+
+/*
+ * Decodes a member hook record's pointer-to-member representation into the target code address.
+ * Virtual members prefer their named overrider, then fall back to reading the primary vtable slot.
+ */
+void* resolve_member_record(const unsigned char* pmf, size_t pmfSize, const char* vtableSymbol,
+    const char* displayName, std::string& why) {
+    if (pmfSize < sizeof(uintptr_t)) {
+        why = "truncated pointer-to-member representation";
+        return nullptr;
+    }
+    uintptr_t words[2]{};
+    std::memcpy(words, pmf, std::min(sizeof(words), pmfSize));
+
+#if defined(_WIN32)
+    const void* fn = reinterpret_cast<const void*>(words[0]);
+    if (fn == nullptr) {
+        why = "null pointer-to-member target";
+        return nullptr;
+    }
+    const size_t slot = vcall_slot_offset(fn);
+    if (slot == static_cast<size_t>(-1)) {  // not a vcall thunk: direct address
+        return const_cast<void*>(fn);
+    }
+
+    // A display name resolves the actual overrider rather than an ABI vcall thunk. Besides being
+    // more direct, this covers secondary vtables: the MSVC representation has `this` adjustment
+    // but does not have the base-path suffix used by the decorated vtable symbol.
+    std::string displayWhy;
+    void* displayTarget = nullptr;
+    if (displayName[0] != '\0' &&
+        resolve_symbol_checked(displayName, true, &displayTarget, displayWhy))
+    {
+        return displayTarget;
+    }
+
+    int32_t thisAdjustment = 0;
+    if (pmfSize >= sizeof(uintptr_t) + sizeof(thisAdjustment)) {
+        std::memcpy(&thisAdjustment, pmf + sizeof(uintptr_t), sizeof(thisAdjustment));
+    }
+    if (thisAdjustment != 0) {
+        why = fmt::format(
+            "virtual member requires a {}-byte this adjustment and its overrider did not "
+            "resolve by name ({})",
+            thisAdjustment, displayWhy);
+        return nullptr;
+    }
+    int32_t firstVirtualField = 0;
+    if (pmfSize > MOD_META_HOOK_MEM_CAPACITY && pmfSize >= sizeof(uintptr_t) + 2 * sizeof(int32_t))
+    {
+        std::memcpy(&firstVirtualField, pmf + sizeof(uintptr_t) + sizeof(int32_t), sizeof(int32_t));
+    }
+    int32_t secondVirtualField = 0;
+    if (pmfSize > MOD_META_HOOK_MEM_CAPACITY && pmfSize >= sizeof(uintptr_t) + 3 * sizeof(int32_t))
+    {
+        std::memcpy(
+            &secondVirtualField, pmf + sizeof(uintptr_t) + 2 * sizeof(int32_t), sizeof(int32_t));
+    }
+    if (firstVirtualField != 0 || secondVirtualField != 0) {
+        why = fmt::format("virtual-base member did not resolve by name ({})", displayWhy);
+        return nullptr;
+    }
+    if (vtableSymbol[0] == '\0') {
+        why = "class name is not representable as a vtable symbol";
+        return nullptr;
+    }
+    void* vtable = nullptr;
+    if (!resolve_symbol_checked(vtableSymbol, false, &vtable, why)) {
+        return nullptr;
+    }
+    // ??_7 points at the first slot.
+    return *reinterpret_cast<void**>(static_cast<char*>(vtable) + slot);
+#else
+#if defined(__aarch64__) || defined(__arm__)
+    // AAPCS C++ ABI: the virtual flag is bit 0 of the adjustment word (function
+    // addresses can't spare their low bit), and ptr holds the slot offset directly.
+    const bool isVirtual = (words[1] & 1) != 0;
+    const uintptr_t thisAdjust = words[1] >> 1;
+    const uintptr_t slotOffset = words[0];
+#else
+    // Itanium C++ ABI: virtual mfps set bit 0 of ptr; the slot offset is ptr - 1.
+    const bool isVirtual = (words[0] & 1) != 0;
+    const uintptr_t thisAdjust = words[1];
+    const uintptr_t slotOffset = words[0] - 1;
+#endif
+    if (!isVirtual) {  // non-virtual: the address itself
+        return reinterpret_cast<void*>(words[0]);
+    }
+
+    std::string displayWhy;
+    void* displayTarget = nullptr;
+    if (displayName[0] != '\0' &&
+        resolve_symbol_checked(displayName, true, &displayTarget, displayWhy))
+    {
+        return displayTarget;
+    }
+    if (thisAdjust != 0) {
+        // The slot is relative to a secondary vtable whose base path is not encoded in the mfp.
+        why = fmt::format(
+            "virtual member of a secondary base did not resolve by name ({})", displayWhy);
+        return nullptr;
+    }
+    if (vtableSymbol[0] == '\0') {
+        why = "class name is not representable as a vtable symbol";
+        return nullptr;
+    }
+    void* vtable = nullptr;
+    if (!resolve_symbol_checked(vtableSymbol, false, &vtable, why)) {
+        return nullptr;
+    }
+    // _ZTV points at the offset-to-top slot; the address point mfps index from is
+    // two pointers in (past offset-to-top and the typeinfo pointer).
+    void* target =
+        *reinterpret_cast<void**>(static_cast<char*>(vtable) + 2 * sizeof(void*) + slotOffset);
+    if (target == nullptr) {
+        why = "vtable slot is empty";
+    }
+    return target;
+#endif
+}
+
 void hook_remove_mod(LoadedMod& mod) {
     ModContext* context = mod.context.get();
+    s_declaredTargets.erase(context);
 
     for (auto it = s_registry.begin(); it != s_registry.end();) {
-        auto& slot = it->second;
-        std::erase_if(slot.pre, [&](const PreHookFn& hook) { return hook.context == context; });
-        std::erase_if(slot.post, [&](const VoidHookFn& hook) { return hook.context == context; });
-        if (slot.replace.context == context) {
-            slot.replace = {};
-        }
-        if (slot.pre.empty() && slot.post.empty() && slot.replace.replaceCallback == nullptr) {
+        if (erase_callbacks(it->second, context)) {
             it = s_registry.erase(it);
         } else {
             ++it;
@@ -400,52 +908,20 @@ void hook_remove_mod(LoadedMod& mod) {
         }
 
         auto* target = reinterpret_cast<void*>(it->first);
-        const int uninst = funchook_uninstall(entry.handle, 0);
-        const int destr = funchook_destroy(entry.handle);
-        if (uninst != 0 || destr != 0) {
-            DuskLog.warn("HookSystem: funchook uninstall/destroy for {:p} returned {}/{}", target,
-                uninst, destr);
-        }
-        entry.handle = nullptr;
-        entry.active = nullptr;
-
         if (entry.candidates.empty()) {
-            it = s_installed.erase(it);
-            continue;
-        }
-
-        // Hand the detour off to a surviving candidate (lowest registration order first; the
-        // vector is append-ordered). A candidate whose install fails stays in the list: its
-        // g_orig must still track the current original pointer.
-        for (auto& cand : entry.candidates) {
-            void* original = nullptr;
-            funchook_t* fh = install_trampoline(target, cand.trampoline, &original);
-            if (fh == nullptr) {
-                continue;
-            }
-            entry.handle = fh;
-            entry.original = original;
-            entry.active = cand.context;
-            DuskLog.info("HookSystem: reinstalled trampoline for {:p}: {} -> {} (tramp={:p})",
-                target, mod_id_from_context(context), mod_id_from_context(cand.context),
-                cand.trampoline);
-            break;
-        }
-
-        if (entry.active == nullptr) {
-            DuskLog.warn("HookSystem: no reinstallable trampoline for {:p}; hooks there are "
-                         "disabled until a mod reinstalls one",
-                target);
-            for (auto& cand : entry.candidates) {
-                *cand.origStore = target;
+            if (!deactivate_backend(target, entry.backend)) {
+                DuskLog.fatal("HookSystem: cannot detach a mod with a live hook at {:p}", target);
             }
             it = s_installed.erase(it);
             continue;
         }
 
-        for (auto& cand : entry.candidates) {
-            *cand.origStore = entry.original;
+        if (!handoff_hook(target, entry)) {
+            it = s_installed.erase(it);
+            continue;
         }
+        DuskLog.info("HookSystem: replaced trampoline for {:p}: {} -> {}", target,
+            mod_id_from_context(context), mod_id_from_context(entry.active));
         ++it;
     }
 }
@@ -464,6 +940,9 @@ ModResult hook_add_post(ModContext*, void*, HookPostFn, const HookOptions*) {
 ModResult hook_replace(ModContext*, void*, HookReplaceFn, const HookOptions*) {
     return MOD_UNSUPPORTED;
 }
+ModResult hook_uninstall(ModContext*, void*, void**) {
+    return MOD_UNSUPPORTED;
+}
 ModResult hook_dispatch_pre(ModContext*, void*, void*, void*, int* outSkipOriginal) {
     if (outSkipOriginal != nullptr) {
         *outSkipOriginal = 0;
@@ -504,10 +983,71 @@ constexpr HookService s_hookService{
     .dispatch_pre = hook_dispatch_pre,
     .dispatch_post = hook_dispatch_post,
     .resolve = hook_resolve,
+    .uninstall = hook_uninstall,
 };
 
 }  // namespace
 
+#if DUSK_CODE_MODS
+void hook_resolve_mod_records(LoadedMod& mod) {
+    auto& declared = s_declaredTargets[mod.context.get()];
+    declared.clear();
+    if (!mod.native) {
+        return;
+    }
+
+    const auto resolved = [&](void* target, void** slot) {
+        target = resolve_target(target);
+        *slot = target;
+        declared.push_back(reinterpret_cast<uintptr_t>(target));
+    };
+    const auto unresolved = [&](const char* what, std::string_view why, void** slot) {
+        *slot = nullptr;
+        log::write(mod.metadata.id, LOG_LEVEL_WARN,
+            "hook target '{}' did not resolve ({}); installing this hook will fail", what, why);
+    };
+
+    for (auto* record : mod.native->parsed.hookFns) {
+        if (record->target != nullptr) {
+            resolved(record->target, &record->resolved);
+        } else {
+            unresolved("<fn>", "null link-time target", &record->resolved);
+        }
+    }
+    const auto resolveMember = [&](auto* record, const unsigned char* pmf, size_t pmfSize) {
+        const char* displayName = hook_mem_display_name(*record);
+        std::string why;
+        void* target =
+            resolve_member_record(pmf, pmfSize, hook_mem_vtable_symbol(*record), displayName, why);
+        if (target != nullptr) {
+            resolved(target, &record->resolved);
+        } else {
+            unresolved(displayName, why, &record->resolved);
+        }
+    };
+    for (auto* record : mod.native->parsed.hookMems) {
+        resolveMember(record, record->pmf, sizeof(record->pmf));
+    }
+    for (auto* record : mod.native->parsed.hookMemExts) {
+        alignas(std::max_align_t) unsigned char pmf[MOD_META_HOOK_MEM_EXT_CAPACITY]{};
+        record->materialize(pmf);
+        resolveMember(record, pmf, record->pmf_size);
+    }
+    for (auto* record : mod.native->parsed.hookNames) {
+        const char* name = hook_name_symbol(*record);
+        std::string why;
+        void* target = nullptr;
+        if (resolve_symbol_checked(name, true, &target, why)) {
+            resolved(target, &record->resolved);
+        } else {
+            unresolved(name, why, &record->resolved);
+        }
+    }
+}
+#else
+void hook_resolve_mod_records(LoadedMod&) {}
+#endif  // DUSK_CODE_MODS
+
 constinit const ServiceModule g_hookModule{
     .id = HOOK_SERVICE_ID,
     .majorVersion = HOOK_SERVICE_MAJOR,
diff --git a/src/dusk/mods/svc/hook.hpp b/src/dusk/mods/svc/hook.hpp
new file mode 100644
index 0000000000..d712a8054a
--- /dev/null
+++ b/src/dusk/mods/svc/hook.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace dusk::mods {
+struct LoadedMod;
+}
+
+namespace dusk::mods::svc {
+
+void hook_resolve_mod_records(LoadedMod& mod);
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/host.cpp b/src/dusk/mods/svc/host.cpp
index 5904903ee7..bde28f6b89 100644
--- a/src/dusk/mods/svc/host.cpp
+++ b/src/dusk/mods/svc/host.cpp
@@ -1,12 +1,18 @@
+#include "internal.hpp"
 #include "registry.hpp"
 
+#include "dusk/main.h"
 #include "dusk/mods/loader/loader.hpp"
+#include "dusk/mods/log_buffer.hpp"
 #include "dusk/mods/manifest.hpp"
-#include "fmt/format.h"
+
+#include <borealis/io.hpp>
+#include <borealis/version.h>
+#include <fmt/format.h>
 
 #include <algorithm>
+#include <filesystem>
 #include <vector>
-#include <version.h>
 
 namespace dusk::mods::svc {
 namespace {
@@ -59,18 +65,57 @@ const char* host_mod_version(ModContext* context) {
 
 const char* host_mod_dir(ModContext* context) {
     const auto* mod = mod_from_context(context);
-    return mod != nullptr ? mod->dir.c_str() : "";
+    return mod != nullptr ? mod->dirUtf8.c_str() : "";
+}
+
+const char* host_native_dir(ModContext* context) {
+    const auto* mod = mod_from_context(context);
+    return mod != nullptr ? mod->nativeDirUtf8.c_str() : "";
+}
+
+ModResult host_data_dir(ModContext* context, const char** outPath) {
+    if (outPath == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outPath = nullptr;
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    if (mod->dataDirUtf8.empty()) {
+        namespace fs = std::filesystem;
+        std::error_code ec;
+        const fs::path path = fs::absolute(dusk::ConfigPath / "mod_data" / mod->metadata.id, ec);
+        if (ec) {
+            log::write(mod->metadata.id, LOG_LEVEL_ERROR,
+                "failed to resolve persistent mod data directory: {}", ec.message());
+            return MOD_ERROR;
+        }
+
+        fs::create_directories(path, ec);
+        if (ec) {
+            log::write(mod->metadata.id, LOG_LEVEL_ERROR,
+                "failed to create persistent mod data directory {}: {}",
+                borealis::io::fs_path_to_string(path), ec.message());
+            return MOD_ERROR;
+        }
+        mod->dataDirUtf8 = borealis::io::fs_path_to_string(path);
+    }
+
+    *outPath = mod->dataDirUtf8.c_str();
+    return MOD_OK;
 }
 
 struct LifecycleWatcher {
-    uint64_t handle = 0;
-    LoadedMod* owner = nullptr;
     ModLifecycleFn fn = nullptr;
     void* userData = nullptr;
+    uint64_t order = 0;
 };
 
-std::vector<LifecycleWatcher> s_watchers;
-uint64_t s_nextWatchHandle = 1;
+SlotMap<LifecycleWatcher> s_watchers;
+uint64_t s_nextWatchOrder = 0;
 
 ModResult host_watch_mod_lifecycle(
     ModContext* context, ModLifecycleFn fn, void* userData, uint64_t* outHandle) {
@@ -78,8 +123,8 @@ ModResult host_watch_mod_lifecycle(
     if (mod == nullptr || fn == nullptr || outHandle == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    const auto handle = s_nextWatchHandle++;
-    s_watchers.push_back({handle, mod, fn, userData});
+    const auto handle = s_watchers.emplace(
+        *mod, LifecycleWatcher{.fn = fn, .userData = userData, .order = s_nextWatchOrder++});
     *outHandle = handle;
     return MOD_OK;
 }
@@ -89,39 +134,48 @@ ModResult host_unwatch_mod_lifecycle(ModContext* context, const uint64_t handle)
     if (mod == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    const auto erased = std::erase_if(s_watchers,
-        [&](const LifecycleWatcher& w) { return w.handle == handle && w.owner == mod; });
-    return erased != 0 ? MOD_OK : MOD_INVALID_ARGUMENT;
+    return s_watchers.erase_owned(handle, *mod) ? MOD_OK : MOD_INVALID_ARGUMENT;
 }
 
 void host_mod_detached(LoadedMod& mod) {
     // The subject's own watches go first: a mod is never notified about its own teardown.
-    std::erase_if(s_watchers, [&](const LifecycleWatcher& w) { return w.owner == &mod; });
+    s_watchers.erase_all(mod);
 
-    // Iterate a snapshot: callbacks may watch/unwatch, and a failing callback erases the
-    // failing mod's services.
-    const auto snapshot = s_watchers;
-    for (const auto& watcher : snapshot) {
-        const bool alive = std::ranges::any_of(
-            s_watchers, [&](const LifecycleWatcher& w) { return w.handle == watcher.handle; });
-        if (!alive) {
+    // Iterate a snapshot in registration order: callbacks may watch/unwatch, and a failing
+    // callback erases the failing mod's services.
+    struct PendingNotify {
+        uint64_t order;
+        uint64_t handle;
+    };
+    std::vector<PendingNotify> snapshot;
+    s_watchers.for_each([&](const uint64_t handle, const auto& entry) {
+        snapshot.push_back({.order = entry.value.order, .handle = handle});
+    });
+    std::ranges::sort(snapshot, {}, &PendingNotify::order);
+
+    for (const auto& pending : snapshot) {
+        const auto* entry = s_watchers.find(pending.handle);
+        if (entry == nullptr) {
             continue;
         }
+        // Do not retain pointers into SlotMap across a callback that may mutate it.
+        auto* owner = entry->owner;
+        const auto watcher = entry->value;
         try {
-            watcher.fn(watcher.owner->context.get(), mod.context.get(), mod.metadata.id.c_str(),
+            watcher.fn(owner->context.get(), mod.context.get(), mod.metadata.id.c_str(),
                 MOD_LIFECYCLE_DETACHED, watcher.userData);
         } catch (const std::exception& e) {
-            fail_mod(*watcher.owner, MOD_ERROR,
+            fail_mod(*owner, MOD_ERROR,
                 fmt::format("Exception in mod lifecycle callback: {}", e.what()));
         } catch (...) {
-            fail_mod(*watcher.owner, MOD_ERROR, "Unknown exception in mod lifecycle callback");
+            fail_mod(*owner, MOD_ERROR, "Unknown exception in mod lifecycle callback");
         }
     }
 }
 
 constinit HostService s_hostService{
     .header = SERVICE_HEADER(HostService, HOST_SERVICE_MAJOR, HOST_SERVICE_MINOR),
-    .version = DUSK_VERSION_STRING,
+    .version = BOREALIS_APP_VERSION,
     .build_id = nullptr,
     .build_id_len = 0,
     .get_service = host_get_service,
@@ -133,6 +187,8 @@ constinit HostService s_hostService{
     .mod_dir = host_mod_dir,
     .watch_mod_lifecycle = host_watch_mod_lifecycle,
     .unwatch_mod_lifecycle = host_unwatch_mod_lifecycle,
+    .native_dir = host_native_dir,
+    .data_dir = host_data_dir,
 };
 
 }  // namespace
diff --git a/src/dusk/mods/svc/http.cpp b/src/dusk/mods/svc/http.cpp
new file mode 100644
index 0000000000..423bd50b70
--- /dev/null
+++ b/src/dusk/mods/svc/http.cpp
@@ -0,0 +1,512 @@
+#include "registry.hpp"
+
+#include "internal.hpp"
+#include "net.hpp"
+
+#include "dusk/main.h"
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/http.h"
+
+#include <borealis/http.hpp>
+#include <borealis/io.hpp>
+#include <borealis/url.hpp>
+#include <fmt/format.h>
+#include <xxhash.h>
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr size_t MaxRequestsPerMod = 16;
+constexpr size_t MaxUrlBytes = 8 * 1024;
+constexpr size_t MaxHeaders = 64;
+constexpr size_t MaxHeaderBytes = 16 * 1024;
+constexpr size_t MaxRequestBodyBytes = 16 * 1024 * 1024;
+constexpr size_t DefaultResponseBodyBytes = 1024 * 1024;
+constexpr size_t MaxResponseBodyBytes = 64 * 1024 * 1024;
+constexpr std::chrono::milliseconds DefaultTimeout{10000};
+constexpr std::string_view ReservedHeaders[]{
+    "User-Agent",
+    "Host",
+    "Content-Length",
+    "Connection",
+    "Accept-Encoding",
+    "Range",
+    "If-Range",
+};
+
+struct PendingRequest {
+    HttpCompleteFn callback = nullptr;
+    void* userData = nullptr;
+    borealis::Task<borealis::http::Result> task;
+    std::filesystem::path stagingPath;
+    std::filesystem::path downloadPath;
+    bool completing = false;
+};
+
+static_assert(std::is_nothrow_move_constructible_v<PendingRequest>);
+
+SlotMap<PendingRequest> s_requests;
+
+bool valid_url(std::string_view url) {
+    const auto parsed = url.size() <= MaxUrlBytes ? borealis::url::parse(url) : std::nullopt;
+    return parsed && parsed->scheme == "https";
+}
+
+std::filesystem::path normalized_absolute(const std::filesystem::path& path, std::error_code& ec) {
+    auto result = std::filesystem::absolute(path, ec);
+    return ec ? std::filesystem::path{} : result.lexically_normal();
+}
+
+bool path_is_below(const std::filesystem::path& path, const std::filesystem::path& directory) {
+    const auto [directoryEnd, pathPosition] =
+        std::mismatch(directory.begin(), directory.end(), path.begin(), path.end());
+    return directoryEnd == directory.end() && pathPosition != path.end();
+}
+
+bool path_is_at_or_below(
+    const std::filesystem::path& path, const std::filesystem::path& directory) {
+    const auto [directoryEnd, pathPosition] =
+        std::mismatch(directory.begin(), directory.end(), path.begin(), path.end());
+    (void)pathPosition;
+    return directoryEnd == directory.end();
+}
+
+std::filesystem::path data_root(const LoadedMod& mod, std::error_code& ec) {
+    if (!mod.dataDirUtf8.empty()) {
+        return normalized_absolute(borealis::io::fs_path_from_utf8(mod.dataDirUtf8), ec);
+    }
+    return normalized_absolute(ConfigPath / "mod_data" / mod.metadata.id, ec);
+}
+
+std::optional<std::filesystem::path> validate_download_path(
+    const LoadedMod& mod, const char* rawPath) {
+    if (rawPath == nullptr) {
+        return std::filesystem::path{};
+    }
+    const auto supplied = borealis::io::fs_path_from_utf8(rawPath);
+    if (!supplied.is_absolute()) {
+        return std::nullopt;
+    }
+
+    std::error_code ec;
+    const auto path = normalized_absolute(supplied, ec);
+    if (ec) {
+        return std::nullopt;
+    }
+    const auto modRoot = normalized_absolute(mod.dir, ec);
+    if (ec) {
+        return std::nullopt;
+    }
+    const auto dataRoot = data_root(mod, ec);
+    if (ec) {
+        return std::nullopt;
+    }
+    const auto stagingRoot = (modRoot / "downloads").lexically_normal();
+    if ((!path_is_below(path, modRoot) && !path_is_below(path, dataRoot)) ||
+        path_is_at_or_below(path, stagingRoot))
+    {
+        return std::nullopt;
+    }
+    return path;
+}
+
+std::filesystem::path staging_path(const LoadedMod& mod, std::string_view url) {
+    const auto& modId = mod.metadata.id;
+    const auto modHash = XXH64(modId.data(), modId.size(), 0);
+    const auto hash = XXH64(url.data(), url.size(), modHash);
+    return mod.dir / "downloads" / fmt::format("{:016x}.part", hash);
+}
+
+HttpError map_error(borealis::http::Error error) {
+    switch (error) {
+    case borealis::http::Error::None:
+        return HTTP_ERROR_NONE;
+    case borealis::http::Error::InvalidUrl:
+        return HTTP_ERROR_INVALID_URL;
+    case borealis::http::Error::UnsupportedScheme:
+        return HTTP_ERROR_UNSUPPORTED_SCHEME;
+    case borealis::http::Error::Timeout:
+        return HTTP_ERROR_TIMEOUT;
+    case borealis::http::Error::TooLarge:
+        return HTTP_ERROR_TOO_LARGE;
+    case borealis::http::Error::Canceled:
+        return HTTP_ERROR_CANCELED;
+    case borealis::http::Error::Io:
+        return HTTP_ERROR_IO;
+    case borealis::http::Error::NoBackend:
+    case borealis::http::Error::Network:
+        return HTTP_ERROR_NETWORK;
+    default:
+        return HTTP_ERROR_NETWORK;
+    }
+}
+
+std::optional<borealis::http::Method> borealis_method(HttpMethod method) {
+    switch (method) {
+    case HTTP_METHOD_GET:
+        return borealis::http::Method::Get;
+    case HTTP_METHOD_POST:
+        return borealis::http::Method::Post;
+    case HTTP_METHOD_HEAD:
+        return borealis::http::Method::Head;
+    }
+    return std::nullopt;
+}
+
+borealis::http::Result publish_download(borealis::http::Result result,
+    const std::filesystem::path& staging, const std::filesystem::path& destination) noexcept {
+    if (result.error != borealis::http::Error::None) {
+        return result;
+    }
+
+    try {
+        std::string renameError;
+        if (borealis::io::atomic_replace(staging, destination, renameError)) {
+            return result;
+        }
+
+        std::filesystem::path temporary = destination;
+        temporary += fmt::format(".{}.part", borealis::io::fs_path_to_string(staging.filename()));
+        std::error_code ec;
+        std::filesystem::copy_file(
+            staging, temporary, std::filesystem::copy_options::overwrite_existing, ec);
+        if (ec) {
+            const std::string copyError = ec.message();
+            std::error_code ignored;
+            std::filesystem::remove(temporary, ignored);
+            result.error = borealis::http::Error::Io;
+            result.message = fmt::format("Failed to publish download: {}", copyError);
+            return result;
+        }
+
+        std::string replaceError;
+        if (!borealis::io::atomic_replace(temporary, destination, replaceError)) {
+            std::filesystem::remove(temporary, ec);
+            result.error = borealis::http::Error::Io;
+            result.message = fmt::format("Failed to publish download: {}", replaceError);
+            return result;
+        }
+        std::filesystem::remove(staging, ec);
+        return result;
+    } catch (const std::exception& exception) {
+        result.error = borealis::http::Error::Io;
+        result.message = fmt::format("Failed to publish download: {}", exception.what());
+        return result;
+    } catch (...) {
+        result.error = borealis::http::Error::Io;
+        result.message = "Failed to publish download";
+        return result;
+    }
+}
+
+void http_frame_begin() {
+    std::vector<HttpRequestHandle> ready;
+    s_requests.for_each([&](const HttpRequestHandle handle, const auto& entry) {
+        const auto& pending = entry.value;
+        if (!pending.completing && pending.task.ready()) {
+            ready.push_back(handle);
+        }
+    });
+
+    for (const auto handle : ready) {
+        auto* entry = s_requests.find(handle);
+        if (entry == nullptr || !entry->owner->active || entry->value.completing) {
+            continue;
+        }
+        auto& pending = entry->value;
+        borealis::http::Result result;
+        try {
+            auto completed = pending.task.try_take();
+            if (!completed.has_value()) {
+                continue;
+            }
+            result = std::move(*completed);
+        } catch (const std::exception& exception) {
+            result = {
+                .error = borealis::http::Error::Io,
+                .message = exception.what(),
+            };
+        } catch (...) {
+            result = {
+                .error = borealis::http::Error::Io,
+                .message = "HTTP request completion failed",
+            };
+        }
+
+        auto* owner = entry->owner;
+        const auto callback = pending.callback;
+        const auto userData = pending.userData;
+        pending.completing = true;
+
+        std::vector<HttpHeader> headers;
+        headers.reserve(result.response.headers.size());
+        for (const auto& header : result.response.headers) {
+            headers.push_back({.name = header.name.c_str(), .value = header.value.c_str()});
+        }
+        const bool downloadSucceeded =
+            !pending.downloadPath.empty() && result.error == borealis::http::Error::None;
+        const auto publishedPath = downloadSucceeded ?
+                                       borealis::io::fs_path_to_string(pending.downloadPath) :
+                                       std::string{};
+        const HttpResult snapshot{
+            .struct_size = sizeof(HttpResult),
+            .error = map_error(result.error),
+            .error_message = result.message.c_str(),
+            .status_code = result.response.statusCode,
+            .headers = headers.empty() ? nullptr : headers.data(),
+            .header_count = static_cast<uint32_t>(headers.size()),
+            .body = pending.downloadPath.empty() && !result.response.body.empty() ?
+                        result.response.body.data() :
+                        nullptr,
+            .body_size = pending.downloadPath.empty() ? result.response.body.size() : 0,
+            .download_path = downloadSucceeded ? publishedPath.c_str() : nullptr,
+        };
+
+        guarded_callback(*owner, "HTTP completion callback",
+            [&] { callback(owner->context.get(), handle, &snapshot, userData); });
+        s_requests.erase(handle);
+    }
+}
+
+size_t active_request_count(const LoadedMod& mod) {
+    size_t count = 0;
+    s_requests.for_each([&](HttpRequestHandle, const auto& entry) {
+        if (entry.owner == &mod && !entry.value.completing) {
+            ++count;
+        }
+    });
+    return count;
+}
+
+bool staging_path_in_use(const LoadedMod& mod, const std::filesystem::path& path) {
+    bool inUse = false;
+    s_requests.for_each([&](HttpRequestHandle, const auto& entry) {
+        if (entry.owner == &mod && !entry.value.completing && entry.value.stagingPath == path) {
+            inUse = true;
+        }
+    });
+    return inUse;
+}
+
+ModResult start_request(LoadedMod& mod, const HttpRequestDesc& desc, HttpCompleteFn callback,
+    void* userData, HttpRequestHandle& outHandle) {
+    const std::string_view url{desc.url};
+    const auto method = borealis_method(desc.method);
+    if (!valid_url(url) || !method.has_value() ||
+        (desc.header_count != 0 && desc.headers == nullptr) ||
+        (desc.body_size != 0 && desc.body == nullptr) || desc.body_size > MaxRequestBodyBytes ||
+        ((desc.method == HTTP_METHOD_GET || desc.method == HTTP_METHOD_HEAD) &&
+            desc.body_size != 0) ||
+        (desc.method == HTTP_METHOD_HEAD && desc.download_path != nullptr) ||
+        desc.header_count > MaxHeaders)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    size_t headerBytes = 0;
+    for (uint32_t i = 0; i < desc.header_count; ++i) {
+        const auto& header = desc.headers[i];
+        if (header.name == nullptr || header.value == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        const std::string_view name{header.name};
+        const std::string_view value{header.value};
+        if (!valid_header(name, value, ReservedHeaders, true) ||
+            name.size() > MaxHeaderBytes - headerBytes)
+        {
+            return MOD_INVALID_ARGUMENT;
+        }
+        headerBytes += name.size();
+        if (value.size() > MaxHeaderBytes - headerBytes) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        headerBytes += value.size();
+    }
+
+    auto downloadPath = validate_download_path(mod, desc.download_path);
+    if (!downloadPath.has_value() ||
+        (downloadPath->empty() && desc.max_body_bytes > MaxResponseBodyBytes))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (active_request_count(mod) >= MaxRequestsPerMod) {
+        return MOD_CONFLICT;
+    }
+
+    std::filesystem::path staging;
+    if (!downloadPath->empty()) {
+        staging = staging_path(mod, url);
+        if (staging_path_in_use(mod, staging)) {
+            return MOD_CONFLICT;
+        }
+        std::error_code ec;
+        std::filesystem::create_directories(staging.parent_path(), ec);
+        if (ec) {
+            return MOD_ERROR;
+        }
+        std::filesystem::create_directories(downloadPath->parent_path(), ec);
+        if (ec) {
+            return MOD_ERROR;
+        }
+    }
+
+    PendingRequest pending{
+        .callback = callback,
+        .userData = userData,
+        .stagingPath = staging,
+        .downloadPath = *downloadPath,
+    };
+
+    if (!borealis::http::available()) {
+        return MOD_UNAVAILABLE;
+    }
+    borealis::http::Request request{
+        .method = *method,
+        .url = std::string{url},
+        .body = desc.body_size != 0 ?
+                    std::string{static_cast<const char*>(desc.body), desc.body_size} :
+                    std::string{},
+        .downloadTo = staging,
+        .connectTimeout = desc.connect_timeout_ms != 0 ?
+                              std::chrono::milliseconds{desc.connect_timeout_ms} :
+                              DefaultTimeout,
+        .idleTimeout = desc.idle_timeout_ms != 0 ? std::chrono::milliseconds{desc.idle_timeout_ms} :
+                                                   DefaultTimeout,
+        .totalTimeout = desc.total_timeout_ms != 0 ?
+                            std::optional{std::chrono::milliseconds{desc.total_timeout_ms}} :
+                            std::nullopt,
+        .maxBodyBytes = desc.max_body_bytes != 0 ? desc.max_body_bytes : DefaultResponseBodyBytes,
+    };
+    request.headers.reserve(desc.header_count + 1);
+    for (uint32_t i = 0; i < desc.header_count; ++i) {
+        request.headers.push_back({desc.headers[i].name, desc.headers[i].value});
+    }
+    request.headers.push_back({
+        .name = "User-Agent",
+        .value = user_agent(mod),
+    });
+
+    auto task = borealis::http::start(std::move(request));
+    if (task.ready()) {
+        auto immediate = task.try_take();
+        if (!immediate.has_value()) {
+            return MOD_UNAVAILABLE;
+        }
+        if (immediate->error == borealis::http::Error::NoBackend) {
+            return MOD_UNAVAILABLE;
+        }
+        task = borealis::detail::make_ready_task(std::move(*immediate));
+    }
+    if (!downloadPath->empty()) {
+        task = std::move(task).map([staging, destination = *downloadPath](auto&& result) {
+            return publish_download(std::move(result), staging, destination);
+        });
+    }
+    pending.task = std::move(task);
+
+    outHandle = s_requests.emplace(mod, std::move(pending));
+    return MOD_OK;
+}
+
+ModResult http_request(ModContext* context, const HttpRequestDesc* desc, HttpCompleteFn callback,
+    void* userData, HttpRequestHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(HttpRequestDesc) ||
+        desc->url == nullptr || callback == nullptr || outHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!declares_import(*mod, HTTP_SERVICE_ID)) {
+        return MOD_UNSUPPORTED;
+    }
+    return start_request(*mod, *desc, callback, userData, *outHandle);
+}
+
+ModResult http_progress(ModContext* context, HttpRequestHandle handle, HttpProgress* outProgress) {
+    const uint32_t structSize = outProgress != nullptr ? outProgress->struct_size : 0;
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outProgress == nullptr || structSize < sizeof(HttpProgress)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outProgress = HttpProgress{.struct_size = structSize};
+    const auto* entry = s_requests.find_owned(handle, *mod);
+    if (entry == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+
+    const auto progress = entry->value.task.progress();
+    outProgress->completed_bytes = progress.completed;
+    outProgress->total_bytes = progress.total.value_or(0);
+    outProgress->total_known = progress.total.has_value();
+    return MOD_OK;
+}
+
+ModResult http_cancel(ModContext* context, HttpRequestHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* entry = s_requests.find_owned(handle, *mod);
+    if (entry == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    entry->value.task.cancel();
+    return MOD_OK;
+}
+
+void http_mod_deactivating(LoadedMod& mod) {
+    (void)s_requests.take_all(mod);
+}
+
+void http_mod_detached(LoadedMod& mod) {
+    bool found = false;
+    s_requests.for_each(
+        [&](HttpRequestHandle, const auto& entry) { found = found || entry.owner == &mod; });
+    assert(!found);
+}
+
+void http_shutdown() {
+    s_requests = {};
+}
+
+bool http_available() {
+    return borealis::http::available();
+}
+
+constexpr HttpService s_httpService{
+    .header = SERVICE_HEADER(HttpService, HTTP_SERVICE_MAJOR, HTTP_SERVICE_MINOR),
+    .request = SERVICE_FUNCTION(http_request),
+    .progress = SERVICE_FUNCTION(http_progress),
+    .cancel = SERVICE_FUNCTION(http_cancel),
+};
+
+}  // namespace
+
+constinit const ServiceModule g_httpModule{
+    .id = HTTP_SERVICE_ID,
+    .majorVersion = HTTP_SERVICE_MAJOR,
+    .minorVersion = HTTP_SERVICE_MINOR,
+    .service = &s_httpService,
+    .available = http_available,
+    .modDeactivating = http_mod_deactivating,
+    .modDetached = http_mod_detached,
+    .frameBegin = http_frame_begin,
+    .shutdown = http_shutdown,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/internal.hpp b/src/dusk/mods/svc/internal.hpp
new file mode 100644
index 0000000000..496b2a58a5
--- /dev/null
+++ b/src/dusk/mods/svc/internal.hpp
@@ -0,0 +1,258 @@
+#pragma once
+
+#include "../loader/loader.hpp"
+#include "../log_buffer.hpp"
+
+#include <fmt/format.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace dusk::mods {
+
+struct LoadedMod;
+
+namespace svc {
+
+template <typename T>
+class SlotMap {
+public:
+    static_assert(std::is_nothrow_move_constructible_v<T>);
+
+    using Handle = uint64_t;
+    static constexpr Handle InvalidHandle = 0;
+
+    struct Entry {
+        LoadedMod* owner = nullptr;
+        T value;
+    };
+
+    template <typename... Args>
+    Handle emplace(LoadedMod& owner, Args&&... args) {
+        T value{std::forward<Args>(args)...};
+        const auto index = allocate_index();
+        auto& slot = m_slots[index];
+        slot.entry.emplace(Entry{.owner = &owner, .value = std::move(value)});
+        return make_handle(index, slot.generation);
+    }
+
+    // Returned pointers remain valid only until the next mutating operation.
+    Entry* find(Handle handle) {
+        auto* slot = find_slot(handle);
+        return slot != nullptr ? &*slot->entry : nullptr;
+    }
+
+    const Entry* find(Handle handle) const {
+        const auto* slot = find_slot(handle);
+        return slot != nullptr ? &*slot->entry : nullptr;
+    }
+
+    Entry* find_owned(Handle handle, const LoadedMod& owner) {
+        auto* entry = find(handle);
+        return entry != nullptr && entry->owner == &owner ? entry : nullptr;
+    }
+
+    const Entry* find_owned(Handle handle, const LoadedMod& owner) const {
+        const auto* entry = find(handle);
+        return entry != nullptr && entry->owner == &owner ? entry : nullptr;
+    }
+
+    std::optional<Entry> take(Handle handle) {
+        const auto index = handle_index(handle);
+        auto* slot = find_slot(handle);
+        if (slot == nullptr) {
+            return std::nullopt;
+        }
+        std::optional<Entry> entry{std::move(slot->entry)};
+        release_slot(index);
+        return entry;
+    }
+
+    std::optional<Entry> take_owned(Handle handle, const LoadedMod& owner) {
+        if (find_owned(handle, owner) == nullptr) {
+            return std::nullopt;
+        }
+        return take(handle);
+    }
+
+    std::vector<Entry> take_all(const LoadedMod& owner) {
+        std::vector<Entry> entries;
+        for (size_t slotIndex = 0; slotIndex < m_slots.size(); ++slotIndex) {
+            const auto index = static_cast<uint32_t>(slotIndex);
+            auto& slot = m_slots[index];
+            if (!slot.entry.has_value() || slot.entry->owner != &owner) {
+                continue;
+            }
+            entries.push_back(std::move(*slot.entry));
+            release_slot(index);
+        }
+        return entries;
+    }
+
+    bool erase(Handle handle) {
+        const auto index = handle_index(handle);
+        if (find_slot(handle) == nullptr) {
+            return false;
+        }
+        release_slot(index);
+        return true;
+    }
+
+    bool erase_owned(Handle handle, const LoadedMod& owner) {
+        if (find_owned(handle, owner) == nullptr) {
+            return false;
+        }
+        return erase(handle);
+    }
+
+    size_t erase_all(const LoadedMod& owner) { return take_all(owner).size(); }
+
+    template <typename Fn>
+    void for_each(Fn&& fn) const {
+        // The visitor may inspect entries but must not mutate this SlotMap.
+        for (size_t slotIndex = 0; slotIndex < m_slots.size(); ++slotIndex) {
+            const auto index = static_cast<uint32_t>(slotIndex);
+            const auto& slot = m_slots[index];
+            if (slot.entry.has_value()) {
+                fn(make_handle(index, slot.generation), *slot.entry);
+            }
+        }
+    }
+
+    // Returns the index of the handle within the slot map.
+    static constexpr uint32_t index_of(Handle handle) { return handle_index(handle); }
+
+private:
+    struct Slot {
+        uint32_t generation = 1;
+        std::optional<Entry> entry;
+    };
+
+    static constexpr Handle make_handle(uint32_t index, uint32_t generation) {
+        return static_cast<Handle>(generation) << 32 | index;
+    }
+
+    static constexpr uint32_t handle_index(Handle handle) {
+        return static_cast<uint32_t>(handle & std::numeric_limits<uint32_t>::max());
+    }
+
+    static constexpr uint32_t handle_generation(Handle handle) {
+        return static_cast<uint32_t>(handle >> 32);
+    }
+
+    Slot* find_slot(Handle handle) {
+        return const_cast<Slot*>(std::as_const(*this).find_slot(handle));
+    }
+
+    const Slot* find_slot(Handle handle) const {
+        const auto index = handle_index(handle);
+        if (handle == InvalidHandle || index >= m_slots.size()) {
+            return nullptr;
+        }
+        const auto& slot = m_slots[index];
+        if (!slot.entry.has_value() || slot.generation != handle_generation(handle)) {
+            return nullptr;
+        }
+        return &slot;
+    }
+
+    uint32_t allocate_index() {
+        if (!m_freeSlots.empty()) {
+            const auto index = m_freeSlots.back();
+            m_freeSlots.pop_back();
+            return index;
+        }
+        if (m_slots.size() > std::numeric_limits<uint32_t>::max()) {
+            throw std::length_error{"SlotMap handle space exhausted"};
+        }
+        const auto index = static_cast<uint32_t>(m_slots.size());
+        m_slots.emplace_back();
+        return index;
+    }
+
+    void release_slot(uint32_t index) {
+        auto& slot = m_slots[index];
+        slot.entry.reset();
+        if (slot.generation == std::numeric_limits<uint32_t>::max()) {
+            return;
+        }
+        ++slot.generation;
+        m_freeSlots.push_back(index);
+    }
+
+    std::vector<Slot> m_slots;
+    std::vector<uint32_t> m_freeSlots;
+};
+
+template <typename T>
+class PerMod {
+public:
+    template <typename... Args>
+    T& get_or_create(LoadedMod& mod, Args&&... args) {
+        auto& state = m_states[&mod];
+        if (!state) {
+            state = std::make_unique<T>(std::forward<Args>(args)...);
+        }
+        return *state;
+    }
+
+    T* find(LoadedMod& mod) {
+        const auto found = m_states.find(&mod);
+        return found != m_states.end() ? found->second.get() : nullptr;
+    }
+
+    const T* find(const LoadedMod& mod) const {
+        const auto found = m_states.find(&mod);
+        return found != m_states.end() ? found->second.get() : nullptr;
+    }
+
+    void erase(LoadedMod& mod) { m_states.erase(&mod); }
+    bool contains(const LoadedMod& mod) const { return m_states.contains(&mod); }
+    void clear() { m_states.clear(); }
+
+private:
+    std::unordered_map<const LoadedMod*, std::unique_ptr<T>> m_states;
+};
+
+template <typename Fn>
+ModResult guarded(ModContext* context, std::string_view operation, Fn&& fn) noexcept {
+    try {
+        return fn();
+    } catch (const std::exception& exception) {
+        log::emit(log::Source::Mod, mod_id_from_context(context), LOG_LEVEL_ERROR,
+            fmt::format("{}: {}", operation, exception.what()));
+    } catch (...) {
+        log::emit(log::Source::Mod, mod_id_from_context(context), LOG_LEVEL_ERROR,
+            fmt::format("{}: unknown exception", operation));
+    }
+    return MOD_ERROR;
+}
+
+// Wraps a mod callback, attempting to catch any escaping exceptions.
+// Immediately logs and fails the mod.
+template <typename Fn>
+void guarded_callback(LoadedMod& mod, std::string_view operation, Fn&& fn) noexcept {
+    try {
+        fn();
+    } catch (const std::exception& exception) {
+        fail_mod(mod, MOD_ERROR, fmt::format("exception in {}: {}", operation, exception.what()));
+    } catch (...) {
+        fail_mod(mod, MOD_ERROR, fmt::format("unknown exception in {}", operation));
+    }
+}
+
+}  // namespace svc
+}  // namespace dusk::mods
+
+// Wraps service functions, catching C++ exceptions to avoid unwinding into mod code.
+#define SERVICE_FUNCTION(function)                                                                 \
+    [](ModContext* context, auto... arguments) -> ModResult {                                      \
+        return ::dusk::mods::svc::guarded(                                                         \
+            context, #function, [&] { return function(context, arguments...); });                  \
+    }
diff --git a/src/dusk/mods/svc/item.cpp b/src/dusk/mods/svc/item.cpp
new file mode 100644
index 0000000000..44b0eff37e
--- /dev/null
+++ b/src/dusk/mods/svc/item.cpp
@@ -0,0 +1,163 @@
+#include "item.hpp"
+
+#include "registry.hpp"
+
+#include "dusk/mods/item.hpp"
+#include "dusk/mods/loader/loader.hpp"
+
+#include "d/d_item_data.h"
+
+#include <string_view>
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr size_t kMaxCheckNameLength = 256;
+constexpr uint32_t kGiveFlagMask = ITEM_GIVE_SILENT | ITEM_GIVE_RESOLVE;
+
+bool is_valid_check_name(const char* name) {
+    if (name == nullptr) {
+        return false;
+    }
+    const std::string_view view{name};
+    return !view.empty() && view.size() <= kMaxCheckNameLength;
+}
+
+ModResult item_set_check_override(ModContext* context, const char* name, uint8_t itemNo) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_check_name(name)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return item_check_set_override(*mod, name, itemNo);
+}
+
+ModResult item_clear_check_override(ModContext* context, const char* name) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_check_name(name)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return item_check_clear_override(*mod, name);
+}
+
+ModResult item_set_check_resolver(ModContext* context, const char* name, ItemCheckResolveFn fn,
+    void* userData, ItemCheckHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || fn == nullptr || (name != nullptr && !is_valid_check_name(name))) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    ItemCheckHandle handle = 0;
+    const auto result = item_check_add_resolver(*mod, name, fn, userData, handle);
+    if (outHandle != nullptr) {
+        *outHandle = handle;
+    }
+    return result;
+}
+
+ModResult item_clear_check_resolver(ModContext* context, ItemCheckHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return item_check_remove_resolver(*mod, handle);
+}
+
+ModResult item_resolve_check(
+    ModContext* context, const char* name, uint8_t originalItemNo, uint8_t* outItem) {
+    if (mod_from_context(context) == nullptr || !is_valid_check_name(name) || outItem == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outItem = item_check(name, originalItemNo, nullptr);
+    return MOD_OK;
+}
+
+ModResult item_resolve_check_full(ModContext* context, const char* name, uint8_t originalItemNo,
+    ItemCheckResolution* outResolution) {
+    if (mod_from_context(context) == nullptr || !is_valid_check_name(name) ||
+        outResolution == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    *outResolution = item_check_resolve(name, originalItemNo, nullptr);
+    return MOD_OK;
+}
+
+ModResult item_give_item(
+    ModContext* context, const char* checkName, uint8_t itemNo, uint32_t flags) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || (checkName != nullptr && !is_valid_check_name(checkName)) ||
+        (flags & ~kGiveFlagMask) != 0)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if ((flags & ITEM_GIVE_RESOLVE) != 0) {
+        if (checkName == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+    } else if (itemNo == dItemNo_NONE_e) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return item_give_enqueue(*mod, checkName, itemNo, flags);
+}
+
+ModResult item_observe_gives(
+    ModContext* context, ItemGiveObserveFn fn, void* userData, ItemGiveHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || fn == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    ItemGiveHandle handle = 0;
+    const auto result = item_give_add_observer(*mod, fn, userData, handle);
+    if (outHandle != nullptr) {
+        *outHandle = handle;
+    }
+    return result;
+}
+
+ModResult item_unobserve_gives(ModContext* context, ItemGiveHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return item_give_remove_observer(*mod, handle);
+}
+
+constexpr ItemService s_itemService{
+    .header = SERVICE_HEADER(ItemService, ITEM_SERVICE_MAJOR, ITEM_SERVICE_MINOR),
+    .set_check_override = item_set_check_override,
+    .clear_check_override = item_clear_check_override,
+    .set_check_resolver = item_set_check_resolver,
+    .clear_check_resolver = item_clear_check_resolver,
+    .resolve_check = item_resolve_check,
+    .give_item = item_give_item,
+    .observe_gives = item_observe_gives,
+    .unobserve_gives = item_unobserve_gives,
+    .resolve_check_full = item_resolve_check_full,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_itemModule{
+    .id = ITEM_SERVICE_ID,
+    .majorVersion = ITEM_SERVICE_MAJOR,
+    .minorVersion = ITEM_SERVICE_MINOR,
+    .service = &s_itemService,
+    .modDetached =
+        [](LoadedMod& mod) {
+            item_checks_remove_mod(mod);
+            item_gives_remove_mod(mod);
+        },
+    .frameEnd = item_gives_tick,
+    .shutdown = item_gives_clear,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/item.hpp b/src/dusk/mods/svc/item.hpp
new file mode 100644
index 0000000000..355278a3af
--- /dev/null
+++ b/src/dusk/mods/svc/item.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "mods/svc/item.h"
+
+#include <cstdint>
+
+namespace dusk::mods {
+
+struct LoadedMod;
+
+namespace svc {
+
+ModResult item_check_set_override(LoadedMod& mod, const char* name, uint8_t itemNo);
+ModResult item_check_clear_override(LoadedMod& mod, const char* name);
+ModResult item_check_add_resolver(LoadedMod& mod, const char* name, ItemCheckResolveFn fn,
+    void* userData, ItemCheckHandle& outHandle);
+ModResult item_check_remove_resolver(LoadedMod& mod, ItemCheckHandle handle);
+void item_checks_remove_mod(LoadedMod& mod);
+
+ModResult item_give_enqueue(LoadedMod& mod, const char* checkName, uint8_t itemNo, uint32_t flags);
+ModResult item_give_add_observer(
+    LoadedMod& mod, ItemGiveObserveFn fn, void* userData, ItemGiveHandle& outHandle);
+ModResult item_give_remove_observer(LoadedMod& mod, ItemGiveHandle handle);
+void item_gives_remove_mod(LoadedMod& mod);
+void item_gives_tick();
+void item_gives_clear();
+
+}  // namespace svc
+}  // namespace dusk::mods
diff --git a/src/dusk/mods/svc/net.cpp b/src/dusk/mods/svc/net.cpp
new file mode 100644
index 0000000000..4b929524cf
--- /dev/null
+++ b/src/dusk/mods/svc/net.cpp
@@ -0,0 +1,574 @@
+#include "registry.hpp"
+
+#include "internal.hpp"
+#include "net.hpp"
+
+#include "dusk/logging.h"
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/net.h"
+
+#include <borealis/net.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cstring>
+#include <memory>
+#include <ranges>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr size_t MaxListenersPerMod = 4;
+constexpr size_t MaxStreamsPerMod = 32;
+constexpr size_t MaxDatagramsPerMod = 4;
+constexpr size_t MaxResolversPerMod = 8;
+constexpr size_t DefaultSendQueueBytes = 1024 * 1024;
+constexpr size_t MaxSendQueueBytes = 8 * 1024 * 1024;
+constexpr std::chrono::milliseconds DefaultConnectTimeout{10000};
+constexpr std::chrono::milliseconds DefaultCloseTimeout{5000};
+constexpr std::chrono::milliseconds InboundStallTimeout{30000};
+
+enum class HandleKind {
+    Listener,
+    Stream,
+    Datagram,
+    Resolver,
+};
+
+struct HandleState {
+    borealis::net::SocketId socket = 0;
+    HandleKind kind = HandleKind::Stream;
+    // Stream sends remain unavailable until the mod observes CONNECTED.
+    bool openPublished = false;
+};
+
+struct ModState {
+    ModState()
+        : context{borealis::net::ContextOptions{
+              .maxQueuedBytes = 16 * 1024 * 1024,
+              .maxQueuedEvents = 4096,
+              .maxStreams = MaxStreamsPerMod,
+              .maxListeners = MaxListenersPerMod,
+              .maxDatagramSockets = MaxDatagramsPerMod,
+              .maxResolvers = MaxResolversPerMod,
+          }} {}
+
+    borealis::net::Context context;
+    std::unordered_map<borealis::net::SocketId, NetHandle> handles;
+    borealis::net::Event currentEvent;
+};
+
+SlotMap<HandleState> s_handles;
+PerMod<ModState> s_modStates;
+
+NetError map_error(borealis::net::Error error) {
+    switch (error) {
+    case borealis::net::Error::None:
+        return NET_ERROR_NONE;
+    case borealis::net::Error::InvalidEndpoint:
+        return NET_ERROR_INVALID_ENDPOINT;
+    case borealis::net::Error::Resolve:
+        return NET_ERROR_RESOLVE;
+    case borealis::net::Error::Timeout:
+        return NET_ERROR_TIMEOUT;
+    case borealis::net::Error::Refused:
+        return NET_ERROR_REFUSED;
+    case borealis::net::Error::Unreachable:
+        return NET_ERROR_UNREACHABLE;
+    case borealis::net::Error::Reset:
+        return NET_ERROR_RESET;
+    case borealis::net::Error::AddressInUse:
+        return NET_ERROR_ADDRESS_IN_USE;
+    case borealis::net::Error::Permission:
+        return NET_ERROR_PERMISSION;
+    case borealis::net::Error::TooLarge:
+        return NET_ERROR_TOO_LARGE;
+    case borealis::net::Error::Canceled:
+        return NET_ERROR_CANCELED;
+    case borealis::net::Error::Network:
+    default:
+        return NET_ERROR_NETWORK;
+    }
+}
+
+ModResult map_send_result(borealis::net::SendResult result) {
+    switch (result) {
+    case borealis::net::SendResult::Ok:
+        return MOD_OK;
+    case borealis::net::SendResult::NotOpen:
+        return MOD_UNAVAILABLE;
+    case borealis::net::SendResult::QueueFull:
+        return MOD_CONFLICT;
+    case borealis::net::SendResult::TooLarge:
+    case borealis::net::SendResult::InvalidEndpoint:
+        return MOD_INVALID_ARGUMENT;
+    }
+    return MOD_ERROR;
+}
+
+NetEventType map_event(borealis::net::Event::Kind kind) {
+    switch (kind) {
+    case borealis::net::Event::Kind::Connected:
+        return NET_EVENT_CONNECTED;
+    case borealis::net::Event::Kind::Accepted:
+        return NET_EVENT_ACCEPTED;
+    case borealis::net::Event::Kind::StreamData:
+        return NET_EVENT_STREAM_DATA;
+    case borealis::net::Event::Kind::Datagram:
+        return NET_EVENT_DATAGRAM;
+    case borealis::net::Event::Kind::Dropped:
+        return NET_EVENT_DROPPED;
+    case borealis::net::Event::Kind::Resolved:
+        return NET_EVENT_RESOLVED;
+    case borealis::net::Event::Kind::Closed:
+        return NET_EVENT_CLOSED;
+    default:
+        return NET_EVENT_NONE;
+    }
+}
+
+bool valid_endpoint(std::string_view text, std::string_view scheme, bool requireLiteral) {
+    if (text.empty() || text.size() >= NET_ENDPOINT_MAX) {
+        return false;
+    }
+    const auto endpoint = borealis::net::parse_endpoint(text);
+    return endpoint && endpoint->scheme == scheme && (!requireLiteral || endpoint->literal);
+}
+
+bool copy_endpoint(NetEndpoint& output, std::string_view endpoint) {
+    if (endpoint.size() >= sizeof(output.text)) {
+        output.text[0] = '\0';
+        return false;
+    }
+    std::memcpy(output.text, endpoint.data(), endpoint.size());
+    output.text[endpoint.size()] = '\0';
+    return true;
+}
+
+size_t bounded_send_queue(size_t requested) {
+    return requested != 0 ? requested : DefaultSendQueueBytes;
+}
+
+std::chrono::milliseconds timeout_or_default(uint32_t value, std::chrono::milliseconds fallback) {
+    return value != 0 ? std::chrono::milliseconds{value} : fallback;
+}
+
+size_t count_handles(const LoadedMod& mod, HandleKind kind) {
+    size_t count = 0;
+    s_handles.for_each([&](NetHandle, const auto& entry) {
+        if (entry.owner == &mod && entry.value.kind == kind) {
+            ++count;
+        }
+    });
+    return count;
+}
+
+ModState& state_for(LoadedMod& mod) {
+    return s_modStates.get_or_create(mod);
+}
+
+ModState* find_state(LoadedMod& mod) {
+    return s_modStates.find(mod);
+}
+
+NetHandle add_handle(LoadedMod& mod, ModState& state, borealis::net::SocketId socket,
+    HandleKind kind, bool openPublished) {
+    const NetHandle handle = s_handles.emplace(mod, HandleState{
+                                                        .socket = socket,
+                                                        .kind = kind,
+                                                        .openPublished = openPublished,
+                                                    });
+    state.handles.emplace(socket, handle);
+    return handle;
+}
+
+ModResult net_connect(ModContext* context, const NetConnectDesc* desc, NetHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(NetConnectDesc) ||
+        desc->endpoint == nullptr || outHandle == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!declares_import(*mod, NET_SERVICE_ID)) {
+        return MOD_UNSUPPORTED;
+    }
+    const std::string_view endpoint{desc->endpoint};
+    if (!valid_endpoint(endpoint, "tcp", false) || desc->max_send_queue_bytes > MaxSendQueueBytes) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!borealis::net::available()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (count_handles(*mod, HandleKind::Stream) >= MaxStreamsPerMod) {
+        return MOD_CONFLICT;
+    }
+    auto& state = state_for(*mod);
+    const size_t maxSendQueueBytes = bounded_send_queue(desc->max_send_queue_bytes);
+    const borealis::net::SocketId socket = state.context.connect(endpoint,
+        borealis::net::StreamOptions{
+            .connectTimeout = timeout_or_default(desc->connect_timeout_ms, DefaultConnectTimeout),
+            .closeTimeout = timeout_or_default(desc->close_timeout_ms, DefaultCloseTimeout),
+            .inboundStallTimeout = InboundStallTimeout,
+            .maxSendQueueBytes = maxSendQueueBytes,
+            .readChunkBytes = 64 * 1024,
+            .noDelay = desc->no_delay,
+        },
+        desc->user_data);
+    if (socket == 0) {
+        return MOD_CONFLICT;
+    }
+    *outHandle = add_handle(*mod, state, socket, HandleKind::Stream, false);
+    return MOD_OK;
+}
+
+ModResult net_listen(ModContext* context, const NetListenDesc* desc, NetHandle* outHandle,
+    NetEndpoint* outLocal, NetError* outError) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    if (outLocal != nullptr) {
+        *outLocal = {};
+    }
+    if (outError != nullptr) {
+        *outError = NET_ERROR_NONE;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(NetListenDesc) ||
+        desc->bind == nullptr || outHandle == nullptr || outLocal == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!declares_import(*mod, NET_SERVICE_ID)) {
+        return MOD_UNSUPPORTED;
+    }
+    const std::string_view bind{desc->bind};
+    if (!valid_endpoint(bind, "tcp", true) || desc->max_send_queue_bytes > MaxSendQueueBytes) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!borealis::net::available()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (count_handles(*mod, HandleKind::Listener) >= MaxListenersPerMod) {
+        return MOD_CONFLICT;
+    }
+    auto& state = state_for(*mod);
+    const size_t maxSendQueueBytes = bounded_send_queue(desc->max_send_queue_bytes);
+    const auto result = state.context.listen(bind,
+        borealis::net::ListenOptions{
+            .accepted =
+                borealis::net::StreamOptions{
+                    .connectTimeout = DefaultConnectTimeout,
+                    .closeTimeout = timeout_or_default(desc->close_timeout_ms, DefaultCloseTimeout),
+                    .inboundStallTimeout = InboundStallTimeout,
+                    .maxSendQueueBytes = maxSendQueueBytes,
+                    .readChunkBytes = 64 * 1024,
+                    .noDelay = desc->no_delay,
+                },
+            .backlog = 64,
+            .reuseAddress = true,
+        },
+        desc->user_data);
+    if (result.id == 0) {
+        if (outError != nullptr) {
+            *outError = map_error(result.error);
+        }
+        DuskLog.error("[{}] could not listen on '{}': {}", mod->metadata.id, bind, result.message);
+        return MOD_ERROR;
+    }
+    if (!copy_endpoint(*outLocal, result.localEndpoint)) {
+        state.context.close(result.id);
+        return MOD_ERROR;
+    }
+    *outHandle = add_handle(*mod, state, result.id, HandleKind::Listener, true);
+    return MOD_OK;
+}
+
+ModResult net_open_datagram(ModContext* context, const NetDatagramDesc* desc, NetHandle* outHandle,
+    NetEndpoint* outLocal, NetError* outError) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    if (outLocal != nullptr) {
+        *outLocal = {};
+    }
+    if (outError != nullptr) {
+        *outError = NET_ERROR_NONE;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(NetDatagramDesc) ||
+        desc->bind == nullptr || outHandle == nullptr || outLocal == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!declares_import(*mod, NET_SERVICE_ID)) {
+        return MOD_UNSUPPORTED;
+    }
+    const std::string_view bind{desc->bind};
+    if (!valid_endpoint(bind, "udp", true) || desc->max_send_queue_bytes > MaxSendQueueBytes) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!borealis::net::available()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (count_handles(*mod, HandleKind::Datagram) >= MaxDatagramsPerMod) {
+        return MOD_CONFLICT;
+    }
+    auto& state = state_for(*mod);
+    const size_t maxSendQueueBytes = bounded_send_queue(desc->max_send_queue_bytes);
+    const auto result = state.context.open_datagram(bind,
+        borealis::net::DatagramOptions{
+            .maxSendQueueBytes = maxSendQueueBytes,
+            .recvBufferBytes = 1024 * 1024,
+            .sendBufferBytes = 1024 * 1024,
+        },
+        desc->user_data);
+    if (result.id == 0) {
+        if (outError != nullptr) {
+            *outError = map_error(result.error);
+        }
+        DuskLog.error("[{}] could not bind datagram socket on '{}': {}", mod->metadata.id, bind,
+            result.message);
+        return MOD_ERROR;
+    }
+    if (!copy_endpoint(*outLocal, result.localEndpoint)) {
+        state.context.close(result.id);
+        return MOD_ERROR;
+    }
+    *outHandle = add_handle(*mod, state, result.id, HandleKind::Datagram, true);
+    return MOD_OK;
+}
+
+ModResult net_resolve(
+    ModContext* context, const char* endpoint, void* userData, NetHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || endpoint == nullptr || outHandle == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!declares_import(*mod, NET_SERVICE_ID)) {
+        return MOD_UNSUPPORTED;
+    }
+    const std::string_view endpointText{endpoint};
+    if (endpointText.empty() || endpointText.size() >= NET_ENDPOINT_MAX ||
+        !borealis::net::parse_endpoint(endpointText))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!borealis::net::available()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (count_handles(*mod, HandleKind::Resolver) >= MaxResolversPerMod) {
+        return MOD_CONFLICT;
+    }
+    auto& state = state_for(*mod);
+    const auto socket = state.context.resolve(endpointText, userData);
+    if (socket == 0) {
+        return MOD_CONFLICT;
+    }
+    *outHandle = add_handle(*mod, state, socket, HandleKind::Resolver, false);
+    return MOD_OK;
+}
+
+ModResult net_poll_event(ModContext* context, NetEvent* outEvent) {
+    const uint32_t structSize = outEvent != nullptr ? outEvent->struct_size : 0;
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outEvent == nullptr || structSize < sizeof(NetEvent)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    NetEvent output{.struct_size = structSize, .error_message = ""};
+    auto* state = find_state(*mod);
+    if (state == nullptr) {
+        std::memcpy(outEvent, &output, sizeof(output));
+        return MOD_OK;
+    }
+
+    while (state->context.poll(state->currentEvent)) {
+        const auto handleFound = state->handles.find(state->currentEvent.id);
+        if (handleFound == state->handles.end()) {
+            continue;
+        }
+        const NetHandle handle = handleFound->second;
+        auto* handleState = s_handles.find_owned(handle, *mod);
+        if (handleState == nullptr) {
+            continue;
+        }
+        output.type = map_event(state->currentEvent.kind);
+        output.handle = handle;
+        output.user_data = state->currentEvent.userData;
+        output.data = state->currentEvent.data.data();
+        output.size = state->currentEvent.data.size();
+        output.dropped = state->currentEvent.dropped;
+        output.error = map_error(state->currentEvent.error);
+        output.error_message = state->currentEvent.message.c_str();
+        if (!copy_endpoint(output.endpoint, state->currentEvent.endpoint)) {
+            output.endpoint = {};
+        }
+
+        if (state->currentEvent.kind == borealis::net::Event::Kind::Connected) {
+            handleState->value.openPublished = true;
+        } else if (state->currentEvent.kind == borealis::net::Event::Kind::Accepted) {
+            const NetHandle accepted =
+                add_handle(*mod, *state, state->currentEvent.accepted, HandleKind::Stream, true);
+            output.accepted = accepted;
+        } else if (state->currentEvent.kind == borealis::net::Event::Kind::Closed ||
+                   state->currentEvent.kind == borealis::net::Event::Kind::Resolved)
+        {
+            state->handles.erase(state->currentEvent.id);
+            s_handles.erase(handle);
+        }
+
+        std::memcpy(outEvent, &output, sizeof(output));
+        return MOD_OK;
+    }
+
+    std::memcpy(outEvent, &output, sizeof(output));
+    return MOD_OK;
+}
+
+ModResult net_send(ModContext* context, NetHandle handle, const void* data, size_t size) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || (size != 0 && data == nullptr)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* handleState = s_handles.find_owned(handle, *mod);
+    auto* state = find_state(*mod);
+    if (handleState == nullptr || state == nullptr ||
+        handleState->value.kind != HandleKind::Stream || !handleState->value.openPublished)
+    {
+        return MOD_UNAVAILABLE;
+    }
+    const auto* bytes = static_cast<const std::byte*>(data);
+    return map_send_result(state->context.send(handleState->value.socket, {bytes, size}));
+}
+
+ModResult net_send_to(
+    ModContext* context, NetHandle handle, const char* endpoint, const void* data, size_t size) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || endpoint == nullptr || (size != 0 && data == nullptr)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* handleState = s_handles.find_owned(handle, *mod);
+    auto* state = find_state(*mod);
+    if (handleState == nullptr || state == nullptr ||
+        handleState->value.kind != HandleKind::Datagram)
+    {
+        return MOD_UNAVAILABLE;
+    }
+    const auto* bytes = static_cast<const std::byte*>(data);
+    return map_send_result(
+        state->context.send_to(handleState->value.socket, endpoint, {bytes, size}));
+}
+
+ModResult net_set_user_data(ModContext* context, NetHandle handle, void* userData) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const auto* handleState = s_handles.find_owned(handle, *mod);
+    auto* state = find_state(*mod);
+    if (handleState == nullptr || state == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    state->context.set_user_data(handleState->value.socket, userData);
+    return MOD_OK;
+}
+
+ModResult net_stats(ModContext* context, NetHandle handle, NetStats* outStats) {
+    const uint32_t structSize = outStats != nullptr ? outStats->struct_size : 0;
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outStats == nullptr || structSize < sizeof(NetStats)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    NetStats output{.struct_size = structSize};
+    const auto* handleState = s_handles.find_owned(handle, *mod);
+    auto* state = find_state(*mod);
+    if (handleState == nullptr || state == nullptr) {
+        std::memcpy(outStats, &output, sizeof(output));
+        return MOD_UNAVAILABLE;
+    }
+    const auto stats = state->context.stats(handleState->value.socket);
+    if (!stats) {
+        std::memcpy(outStats, &output, sizeof(output));
+        return MOD_UNAVAILABLE;
+    }
+    output.queued_send_bytes = stats->queuedSendBytes;
+    output.inbound_dropped = stats->inboundDropped;
+    output.send_failures = stats->sendFailures;
+    output.bytes_sent = stats->bytesSent;
+    output.bytes_received = stats->bytesReceived;
+    std::memcpy(outStats, &output, sizeof(output));
+    return MOD_OK;
+}
+
+ModResult net_close(ModContext* context, NetHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* handleState = s_handles.find_owned(handle, *mod);
+    auto* state = find_state(*mod);
+    if (handleState == nullptr || state == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    state->context.close(handleState->value.socket);
+    return MOD_OK;
+}
+
+void net_mod_deactivating(LoadedMod& mod) {
+    (void)s_handles.take_all(mod);
+    s_modStates.erase(mod);
+}
+
+void net_mod_detached(LoadedMod& mod) {
+    assert(find_state(mod) == nullptr);
+    bool found = false;
+    s_handles.for_each([&](NetHandle, const auto& entry) { found = found || entry.owner == &mod; });
+    assert(!found);
+}
+
+void net_shutdown() {
+    s_modStates.clear();
+    s_handles = {};
+}
+
+bool net_available() {
+    return borealis::net::available();
+}
+
+constexpr NetService s_netService{
+    .header = SERVICE_HEADER(NetService, NET_SERVICE_MAJOR, NET_SERVICE_MINOR),
+    .connect = SERVICE_FUNCTION(net_connect),
+    .listen = SERVICE_FUNCTION(net_listen),
+    .open_datagram = SERVICE_FUNCTION(net_open_datagram),
+    .resolve = SERVICE_FUNCTION(net_resolve),
+    .poll_event = SERVICE_FUNCTION(net_poll_event),
+    .send = SERVICE_FUNCTION(net_send),
+    .send_to = SERVICE_FUNCTION(net_send_to),
+    .set_user_data = SERVICE_FUNCTION(net_set_user_data),
+    .stats = SERVICE_FUNCTION(net_stats),
+    .close = SERVICE_FUNCTION(net_close),
+};
+
+}  // namespace
+
+constinit const ServiceModule g_netModule{
+    .id = NET_SERVICE_ID,
+    .majorVersion = NET_SERVICE_MAJOR,
+    .minorVersion = NET_SERVICE_MINOR,
+    .service = &s_netService,
+    .available = net_available,
+    .modDeactivating = net_mod_deactivating,
+    .modDetached = net_mod_detached,
+    .shutdown = net_shutdown,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/net.hpp b/src/dusk/mods/svc/net.hpp
new file mode 100644
index 0000000000..34ca17362f
--- /dev/null
+++ b/src/dusk/mods/svc/net.hpp
@@ -0,0 +1,79 @@
+#pragma once
+
+#include "dusk/app_info.hpp"
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/http.h"
+#include "mods/svc/net.h"
+#include "mods/svc/websocket.h"
+
+#include <borealis/version.h>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <ranges>
+#include <span>
+#include <string>
+#include <string_view>
+
+namespace dusk::mods::svc {
+
+inline bool ascii_iequals(std::string_view left, std::string_view right) {
+    if (left.size() != right.size()) {
+        return false;
+    }
+    const auto ascii_lower = [](char value) {
+        return value >= 'A' && value <= 'Z' ? static_cast<char>(value - 'A' + 'a') : value;
+    };
+    return std::ranges::equal(
+        left, right, [&](char a, char b) { return ascii_lower(a) == ascii_lower(b); });
+}
+
+inline bool valid_header_name(std::string_view name) {
+    constexpr std::string_view Separators{"()<>@,;:\\\"/[]?={} \t"};
+    return !name.empty() && std::ranges::all_of(name, [&](unsigned char value) {
+        return value > 32 && value < 127 &&
+               Separators.find(static_cast<char>(value)) == std::string_view::npos;
+    });
+}
+
+inline bool valid_header_value(std::string_view value, bool allowHorizontalTab) {
+    return std::ranges::all_of(value, [=](unsigned char character) {
+        return character >= 32 || (allowHorizontalTab && character == '\t');
+    }) && std::ranges::none_of(value, [](unsigned char character) { return character == 127; });
+}
+
+inline bool is_reserved_header(std::string_view name, std::span<const std::string_view> reserved) {
+    return std::ranges::any_of(
+        reserved, [&](std::string_view value) { return ascii_iequals(name, value); });
+}
+
+inline bool valid_header(std::string_view name, std::string_view value,
+    std::span<const std::string_view> reserved, bool allowHorizontalTab = false) {
+    return valid_header_name(name) && valid_header_value(value, allowHorizontalTab) &&
+           !is_reserved_header(name, reserved);
+}
+
+inline bool declares_import(const LoadedMod& mod, std::string_view serviceId) {
+    return std::ranges::any_of(
+        mod.manifestInfo.imports, [&](const ModManifestInfo::Import& serviceImport) {
+            return serviceImport.id == serviceId;
+        });
+}
+
+inline bool is_network_service(std::string_view serviceId) {
+    return serviceId == HTTP_SERVICE_ID || serviceId == NET_SERVICE_ID ||
+           serviceId == WEBSOCKET_SERVICE_ID;
+}
+
+inline std::string user_agent(const LoadedMod& mod) {
+    std::string version{mod.metadata.version};
+    for (char& character : version) {
+        const auto value = static_cast<unsigned char>(character);
+        if (value <= 32 || value >= 127) {
+            character = '_';
+        }
+    }
+    return fmt::format("{}/{} {}/{}", AppName, BOREALIS_APP_VERSION, mod.metadata.id, version);
+}
+
+}  // namespace dusk::mods::svc::network
diff --git a/src/dusk/mods/svc/overlay.cpp b/src/dusk/mods/svc/overlay.cpp
index 13cab1ac0f..478fbe32de 100644
--- a/src/dusk/mods/svc/overlay.cpp
+++ b/src/dusk/mods/svc/overlay.cpp
@@ -1,12 +1,16 @@
+#include "internal.hpp"
 #include "registry.hpp"
 
-#include "aurora/dvd.h"
-#include "aurora/lib/logging.hpp"
 #include "dusk/mods/loader/loader.hpp"
 #include "mods/svc/overlay.h"
 
+#include "JSystem/JKernel/JKRArchive.h"
+
+#include <aurora/dvd.h>
+#include <borealis/log.hpp>
+
+#include <algorithm>
 #include <cstdint>
-#include <cstring>
 #include <mutex>
 #include <string_view>
 #include <unordered_map>
@@ -17,12 +21,12 @@ using namespace std::string_literals;
 namespace dusk::mods::svc {
 namespace {
 
-aurora::Module Log("dusk::mods::overlay");
+constexpr borealis::Log Log{"dusk::mods::overlay"};
 
 struct OverlayFileData {
     std::string bundlePath;
     std::shared_ptr<ModBundle> bundle;
-    std::shared_ptr<const std::vector<u8> > buffer;
+    std::shared_ptr<const std::vector<u8>> buffer;
 };
 
 // Keyed by the id passed to Aurora as per-file userdata. Guarded by s_overlayMutex: Aurora may
@@ -33,15 +37,15 @@ std::unordered_map<uintptr_t, OverlayFileData> s_overlayFiles;
 uintptr_t s_nextOverlayId = 1;
 std::mutex s_overlayMutex;
 
-struct RuntimeOverlayEntry {
-    uint64_t handle = 0;
+struct RuntimeOverlaySlot {
     std::string discPath;
     std::string bundlePath;                         // bundle-backed if non-empty
     std::shared_ptr<const std::vector<u8>> buffer;  // buffer-backed otherwise
     size_t size = 0;
+    uint64_t order = 0;
 };
-std::unordered_map<const LoadedMod*, std::vector<RuntimeOverlayEntry>> s_runtimeOverlays;
-uint64_t s_nextRuntimeHandle = 1;
+SlotMap<RuntimeOverlaySlot> s_runtimeOverlays;
+uint64_t s_nextRuntimeOrder = 0;
 bool s_overlaysDirty = false;
 
 // Aurora matches overlay paths against the disc case-insensitively and later entries win, so
@@ -84,26 +88,32 @@ void find_overlay_files(std::vector<AuroraOverlayFile>& files, LoadedMod& mod,
 
 void append_runtime_overlays(std::vector<AuroraOverlayFile>& files, LoadedMod& mod,
     std::unordered_map<std::string, const LoadedMod*>& claims) {
-    const auto it = s_runtimeOverlays.find(&mod);
-    if (it == s_runtimeOverlays.end()) {
-        return;
-    }
-
-    for (const auto& entry : it->second) {
-        const auto id = s_nextOverlayId++;
-        if (entry.buffer != nullptr) {
-            s_overlayFiles.emplace(id, OverlayFileData{{}, nullptr, entry.buffer});
-        } else {
-            s_overlayFiles.emplace(id, OverlayFileData{entry.bundlePath, mod.bundle, nullptr});
+    // Aurora resolves duplicate paths later-entry-wins, so emit in registration order (SlotMap
+    // iteration is index order, and freed indices are reused).
+    std::vector<const RuntimeOverlaySlot*> slots;
+    s_runtimeOverlays.for_each([&](uint64_t, const auto& entry) {
+        if (entry.owner == &mod) {
+            slots.push_back(&entry.value);
         }
-        claim_overlay_path(claims, entry.discPath, mod);
-        files.emplace_back(strdup(entry.discPath.c_str()), reinterpret_cast<void*>(id), entry.size);
+    });
+    std::ranges::sort(slots, {}, &RuntimeOverlaySlot::order);
+
+    for (const auto* slot : slots) {
+        const auto id = s_nextOverlayId++;
+
+        if (slot->buffer != nullptr) {
+            s_overlayFiles.emplace(id, OverlayFileData{{}, nullptr, slot->buffer});
+        } else {
+            s_overlayFiles.emplace(id, OverlayFileData{slot->bundlePath, mod.bundle, nullptr});
+        }
+        claim_overlay_path(claims, slot->discPath, mod);
+        files.emplace_back(strdup(slot->discPath.c_str()), reinterpret_cast<void*>(id), slot->size);
     }
 }
 
 struct OpenOverlayFile {
     std::vector<u8> ownedData;
-    std::shared_ptr<const std::vector<u8> > shared;
+    std::shared_ptr<const std::vector<u8>> shared;
     size_t pos = 0;
 
     [[nodiscard]] const std::vector<u8>& data() const {
@@ -193,6 +203,7 @@ void overlay_sync_files() {
 
     Log.debug("Registering {} overlay file(s).", files.size());
     aurora_dvd_overlay_files(files.data(), files.size(), nullptr);
+    JKRArchive::notifyOverlayFilesChanged();
 
     for (const auto& file : files) {
         std::free(const_cast<char*>(file.fileName));
@@ -201,47 +212,39 @@ void overlay_sync_files() {
 
 uint64_t overlay_add_file(
     LoadedMod& mod, std::string discPath, std::string bundlePath, size_t size) {
-    const auto handle = s_nextRuntimeHandle++;
-    s_runtimeOverlays[&mod].push_back({
-        .handle = handle,
-        .discPath = std::move(discPath),
-        .bundlePath = std::move(bundlePath),
-        .size = size,
-    });
+    const auto handle = s_runtimeOverlays.emplace(mod, RuntimeOverlaySlot{
+                                                           .discPath = std::move(discPath),
+                                                           .bundlePath = std::move(bundlePath),
+                                                           .size = size,
+                                                           .order = s_nextRuntimeOrder++,
+                                                       });
     s_overlaysDirty = true;
     return handle;
 }
 
 uint64_t overlay_add_buffer(LoadedMod& mod, std::string discPath, std::vector<u8> data) {
-    const auto handle = s_nextRuntimeHandle++;
     const auto size = data.size();
-    s_runtimeOverlays[&mod].push_back({
-        .handle = handle,
-        .discPath = std::move(discPath),
-        .buffer = std::make_shared<const std::vector<u8>>(std::move(data)),
-        .size = size,
-    });
+    const auto handle = s_runtimeOverlays.emplace(
+        mod, RuntimeOverlaySlot{
+                 .discPath = std::move(discPath),
+                 .buffer = std::make_shared<const std::vector<u8>>(std::move(data)),
+                 .size = size,
+                 .order = s_nextRuntimeOrder++,
+             });
     s_overlaysDirty = true;
     return handle;
 }
 
 bool overlay_remove(LoadedMod& mod, uint64_t handle) {
-    const auto it = s_runtimeOverlays.find(&mod);
-    if (it == s_runtimeOverlays.end()) {
+    if (!s_runtimeOverlays.erase_owned(handle, mod)) {
         return false;
     }
-    if (std::erase_if(it->second, [&](const auto& entry) { return entry.handle == handle; }) == 0) {
-        return false;
-    }
-    if (it->second.empty()) {
-        s_runtimeOverlays.erase(it);
-    }
     s_overlaysDirty = true;
     return true;
 }
 
 void overlay_remove_mod(LoadedMod& mod) {
-    if (s_runtimeOverlays.erase(&mod) != 0) {
+    if (s_runtimeOverlays.erase_all(mod) != 0) {
         s_overlaysDirty = true;
     }
 }
@@ -276,13 +279,12 @@ ModResult overlay_add_file(
     try {
         size = mod->bundle->getFileSize(bundlePath);
     } catch (const std::exception& e) {
-        Log.error(
-            "[{}] overlay add_file '{}' failed: {}", mod->metadata.id, bundlePath, e.what());
+        Log.error("[{}] overlay add_file '{}' failed: {}", mod->metadata.id, bundlePath, e.what());
         return MOD_UNAVAILABLE;
     }
     if (size > kMaxOverlayFileSize) {
-        Log.error("[{}] overlay add_file '{}' failed: file too large ({} bytes)",
-            mod->metadata.id, bundlePath, size);
+        Log.error("[{}] overlay add_file '{}' failed: file too large ({} bytes)", mod->metadata.id,
+            bundlePath, size);
         return MOD_INVALID_ARGUMENT;
     }
 
diff --git a/src/dusk/mods/svc/registry.cpp b/src/dusk/mods/svc/registry.cpp
index 206acc8994..85035fd908 100644
--- a/src/dusk/mods/svc/registry.cpp
+++ b/src/dusk/mods/svc/registry.cpp
@@ -4,22 +4,25 @@
 #include "dusk/logging.h"
 #include "dusk/mods/loader/loader.hpp"
 
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <optional>
 #include <ranges>
 #include <string_view>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 namespace dusk::mods::svc {
 namespace {
 
 std::unordered_map<std::string, ServiceRecord> s_services;
+std::unordered_set<std::string> s_unavailableServices;
 std::vector<const ServiceModule*> s_modules;
 
 std::string service_key(std::string_view id, const uint16_t majorVersion) {
-    std::string key{id};
-    key.push_back('\x1f');
-    key += std::to_string(majorVersion);
-    return key;
+    return fmt::format("{}\x1f{}", id, majorVersion);
 }
 
 const char* mod_id(const LoadedMod* mod) {
@@ -48,6 +51,7 @@ bool validate_service_header(const ServiceHeader* header, const char* serviceId,
 
 void clear_services() {
     s_services.clear();
+    s_unavailableServices.clear();
     s_modules.clear();
 }
 
@@ -137,12 +141,46 @@ const ServiceRecord* find_service_record(const char* serviceId, const uint16_t m
     return it != s_services.end() ? &it->second : nullptr;
 }
 
+std::string describe_missing_service(const char* serviceId, const uint16_t majorVersion,
+    const uint16_t minMinorVersion) {
+    const char* message = "Mod requires a service that is unavailable";
+    if (std::string_view{serviceId}.starts_with(DUSKLIGHT_SERVICE_ID_PREFIX) &&
+        !s_unavailableServices.contains(service_key(serviceId, majorVersion)))
+    {
+        if (const auto* record = find_service_record(serviceId, majorVersion)) {
+            if (record->provider == nullptr && record->service != nullptr &&
+                record->minorVersion < minMinorVersion)
+            {
+                message = "Mod requires a newer Dusklight version";
+            }
+        } else {
+            std::optional<uint16_t> highestMajor;
+            for (const auto& [key, record] : s_services) {
+                if (record.provider == nullptr && record.service != nullptr && record.id == serviceId) {
+                    highestMajor = std::max(highestMajor.value_or(0), record.majorVersion);
+                }
+            }
+            if (highestMajor) {
+                message = majorVersion > *highestMajor ?
+                    "Mod requires a newer Dusklight version" :
+                    "Mod must be updated for the current Dusklight version";
+            }
+        }
+    }
+    return fmt::format("{} (missing: {})", message, serviceId);
+}
+
 ModResult register_module(const ServiceModule& module) {
+    if (module.available != nullptr && !module.available()) {
+        s_unavailableServices.insert(service_key(module.id, module.majorVersion));
+        return MOD_UNAVAILABLE;
+    }
     const auto result = register_service(
         module.id, module.majorVersion, module.minorVersion, module.service, nullptr, false);
     if (result != MOD_OK) {
         return result;
     }
+    s_unavailableServices.erase(service_key(module.id, module.majorVersion));
     s_modules.push_back(&module);
     if (module.initialize != nullptr) {
         module.initialize();
@@ -150,6 +188,14 @@ ModResult register_module(const ServiceModule& module) {
     return MOD_OK;
 }
 
+void modules_mod_deactivating(LoadedMod& mod) {
+    for (const auto* module : s_modules | std::views::reverse) {
+        if (module->modDeactivating != nullptr) {
+            module->modDeactivating(mod);
+        }
+    }
+}
+
 void modules_mod_detached(LoadedMod& mod) {
     for (const auto* module : s_modules | std::views::reverse) {
         if (module->modDetached != nullptr) {
@@ -202,12 +248,27 @@ void ModLoader::init_services() {
             &svc::g_hostModule,
             &svc::g_logModule,
             &svc::g_resourceModule,
+            &svc::g_fileModule,
+            &svc::g_httpModule,
+            &svc::g_netModule,
+            &svc::g_websocketModule,
             &svc::g_hookModule,
             &svc::g_overlayModule,
             &svc::g_textureModule,
             &svc::g_configModule,
+            &svc::g_uiModule_v1,
             &svc::g_uiModule,
             &svc::g_gameModule,
+            &svc::g_cameraModule,
+            &svc::g_windowModule,
+            &svc::g_gfxModule,
+            &svc::g_saveModule,
+            &svc::g_stageModule,
+            &svc::g_itemModule,
+            &svc::g_flowModule,
+            &svc::g_messageModule,
+            &svc::g_gamemodeModule,
+            &svc::g_actorModule,
         })
     {
         svc::register_module(*module);
@@ -215,29 +276,25 @@ void ModLoader::init_services() {
 }
 
 bool ModLoader::register_static_service_exports(LoadedMod& mod) {
-    if (!mod.native || mod.native->manifest == nullptr) {
+    if (!mod.native) {
         return true;
     }
 
-    const auto& manifest = *mod.native->manifest;
-    for (size_t i = 0; i < manifest.export_count; ++i) {
-        const auto& serviceExport = manifest.exports[i];
-        if (serviceExport.struct_size != sizeof(ServiceExport) ||
-            !svc::valid_service_id(serviceExport.service_id))
-        {
+    for (const auto* serviceExport : mod.native->parsed.exports) {
+        if (!svc::valid_service_id(serviceExport->service_id.chars)) {
             fail_mod(mod, MOD_INVALID_ARGUMENT, "Invalid service export descriptor");
             return false;
         }
 
-        const bool deferred = (serviceExport.flags & SERVICE_EXPORT_DEFERRED) != 0;
-        if (!deferred && serviceExport.service == nullptr) {
+        const bool deferred = (serviceExport->rec.flags & SERVICE_EXPORT_DEFERRED) != 0;
+        if (!deferred && serviceExport->service == nullptr) {
             fail_mod(mod, MOD_INVALID_ARGUMENT, "Static service export has null service pointer");
             return false;
         }
 
         const auto result =
-            svc::register_service(serviceExport.service_id, serviceExport.major_version,
-                serviceExport.minor_version, serviceExport.service, &mod, deferred);
+            svc::register_service(serviceExport->service_id.chars, serviceExport->major_version,
+                serviceExport->minor_version, serviceExport->service, &mod, deferred);
         if (result != MOD_OK) {
             fail_mod(mod, result, "Service export registration failed");
             return false;
@@ -249,6 +306,9 @@ bool ModLoader::register_static_service_exports(LoadedMod& mod) {
 
 std::string ModLoader::describe_missing_import(
     const char* serviceId, const uint16_t majorVersion, const uint16_t minMinorVersion) const {
+    if (std::string_view{serviceId}.starts_with(DUSKLIGHT_SERVICE_ID_PREFIX)) {
+        return svc::describe_missing_service(serviceId, majorVersion, minMinorVersion);
+    }
     if (const auto* record = svc::find_service_record(serviceId, majorVersion)) {
         if (record->service == nullptr) {
             return fmt::format("Required service {}@{} was never published by provider '{}'",
@@ -260,18 +320,13 @@ std::string ModLoader::describe_missing_import(
 
     // No record can also mean the provider failed or is disabled and its services were removed.
     for (const auto& other : mods()) {
-        if ((other.active && !other.loadFailed) || !other.native ||
-            other.native->manifest == nullptr)
-        {
+        if ((other.active && !other.loadFailed) || !other.native) {
             continue;
         }
-        const auto& manifest = *other.native->manifest;
-        for (size_t i = 0; i < manifest.export_count; ++i) {
-            const auto& serviceExport = manifest.exports[i];
-            if (serviceExport.struct_size == sizeof(ServiceExport) &&
-                svc::valid_service_id(serviceExport.service_id) &&
-                std::string_view{serviceExport.service_id} == serviceId &&
-                serviceExport.major_version == majorVersion)
+        for (const auto* serviceExport : other.native->parsed.exports) {
+            if (svc::valid_service_id(serviceExport->service_id.chars) &&
+                std::string_view{serviceExport->service_id.chars} == serviceId &&
+                serviceExport->major_version == majorVersion)
             {
                 return fmt::format("Required service {}@{} unavailable: provider '{}' {}",
                     serviceId, majorVersion, other.metadata.id,
@@ -280,39 +335,37 @@ std::string ModLoader::describe_missing_import(
         }
     }
 
-    return fmt::format("Required service unavailable: {}@{}", serviceId, majorVersion);
+    return svc::describe_missing_service(serviceId, majorVersion, minMinorVersion);
 }
 
 bool ModLoader::resolve_service_imports(LoadedMod& mod) {
-    if (!mod.native || mod.native->manifest == nullptr) {
+    if (!mod.native) {
         return true;
     }
 
-    const auto& manifest = *mod.native->manifest;
-    for (size_t i = 0; i < manifest.import_count; ++i) {
-        const auto& serviceImport = manifest.imports[i];
-        if (serviceImport.struct_size != sizeof(ServiceImport) ||
-            !svc::valid_service_id(serviceImport.service_id) || serviceImport.slot == nullptr)
+    for (const auto* serviceImport : mod.native->parsed.imports) {
+        if (!svc::valid_service_id(serviceImport->service_id.chars) ||
+            serviceImport->slot == nullptr)
         {
             fail_mod(mod, MOD_INVALID_ARGUMENT, "Invalid service import descriptor");
             return false;
         }
 
-        const auto* service = svc::find_service(
-            serviceImport.service_id, serviceImport.major_version, serviceImport.min_minor_version);
+        const auto* service = svc::find_service(serviceImport->service_id.chars,
+            serviceImport->major_version, serviceImport->min_minor_version);
         if (service == nullptr) {
-            *static_cast<const void**>(serviceImport.slot) = nullptr;
-            if ((serviceImport.flags & SERVICE_IMPORT_OPTIONAL) != 0) {
+            *static_cast<const void**>(serviceImport->slot) = nullptr;
+            if ((serviceImport->rec.flags & SERVICE_IMPORT_OPTIONAL) != 0) {
                 continue;
             }
 
             fail_mod(mod, MOD_UNAVAILABLE,
-                describe_missing_import(serviceImport.service_id, serviceImport.major_version,
-                    serviceImport.min_minor_version));
+                describe_missing_import(serviceImport->service_id.chars,
+                    serviceImport->major_version, serviceImport->min_minor_version));
             return false;
         }
 
-        *static_cast<const void**>(serviceImport.slot) = service->service;
+        *static_cast<const void**>(serviceImport->slot) = service->service;
     }
 
     return true;
diff --git a/src/dusk/mods/svc/registry.hpp b/src/dusk/mods/svc/registry.hpp
index 71fda98abd..ac524384f3 100644
--- a/src/dusk/mods/svc/registry.hpp
+++ b/src/dusk/mods/svc/registry.hpp
@@ -19,15 +19,20 @@ struct ServiceRecord {
 };
 
 // A host service and its lifecycle hooks. Every hook is optional. Frame and lifecycle hooks run in
-// registration order, modDetached in reverse registration order.
+// registration order, teardown hooks in reverse registration order.
 struct ServiceModule {
     const char* id = nullptr;
     uint16_t majorVersion = 0;
     uint16_t minorVersion = 0;
     const void* service = nullptr;
 
+    // False prevents registration when a platform dependency is unavailable.
+    bool (*available)() = nullptr;
     // One-time setup, at registration (ModLoader::init_services).
     void (*initialize)() = nullptr;
+    // A mod is beginning deactivation: stop callbacks that may execute concurrently. Service state
+    // remains registered so mod_shutdown may release it normally.
+    void (*modDeactivating)(LoadedMod& mod) = nullptr;
     // A mod is going away (deactivation or failed activation): drop all state held for it.
     // Runs after the mod's mod_shutdown and before its library unloads, so pointers into
     // the mod are still valid but must not be called.
@@ -53,8 +58,11 @@ const ServiceRecord* find_service(
     const char* serviceId, uint16_t majorVersion, uint16_t minMinorVersion);
 // Unlike find_service, also returns deferred records that have not been published yet.
 const ServiceRecord* find_service_record(const char* serviceId, uint16_t majorVersion);
+std::string describe_missing_service(const char* serviceId, uint16_t majorVersion,
+    uint16_t minMinorVersion);
 
 ModResult register_module(const ServiceModule& module);
+void modules_mod_deactivating(LoadedMod& mod);
 void modules_mod_detached(LoadedMod& mod);
 void modules_lifecycle_applied();
 void modules_frame_begin();
@@ -64,11 +72,26 @@ void modules_shutdown();
 extern const ServiceModule g_hostModule;
 extern const ServiceModule g_logModule;
 extern const ServiceModule g_resourceModule;
+extern const ServiceModule g_fileModule;
+extern const ServiceModule g_httpModule;
+extern const ServiceModule g_netModule;
+extern const ServiceModule g_websocketModule;
 extern const ServiceModule g_hookModule;
 extern const ServiceModule g_overlayModule;
 extern const ServiceModule g_textureModule;
 extern const ServiceModule g_configModule;
+extern const ServiceModule g_uiModule_v1;
 extern const ServiceModule g_uiModule;
 extern const ServiceModule g_gameModule;
+extern const ServiceModule g_cameraModule;
+extern const ServiceModule g_windowModule;
+extern const ServiceModule g_gfxModule;
+extern const ServiceModule g_saveModule;
+extern const ServiceModule g_stageModule;
+extern const ServiceModule g_itemModule;
+extern const ServiceModule g_flowModule;
+extern const ServiceModule g_messageModule;
+extern const ServiceModule g_gamemodeModule;
+extern const ServiceModule g_actorModule;
 
 }  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/resource.cpp b/src/dusk/mods/svc/resource.cpp
index b03934560f..d92630317e 100644
--- a/src/dusk/mods/svc/resource.cpp
+++ b/src/dusk/mods/svc/resource.cpp
@@ -1,6 +1,6 @@
 #include "registry.hpp"
 
-#include "aurora/lib/logging.hpp"
+#include <borealis/log.hpp>
 #include "dusk/mods/loader/loader.hpp"
 #include "mods/svc/resource.h"
 
@@ -14,7 +14,7 @@
 namespace dusk::mods::svc {
 namespace {
 
-aurora::Module Log("dusk::mods::resource");
+constexpr borealis::Log Log{"dusk::mods::resource"};
 
 // Allocations by owning mod, so buffers still live when a mod detaches can be freed.
 std::unordered_map<void*, const LoadedMod*> s_buffers;
diff --git a/src/dusk/mods/svc/save.cpp b/src/dusk/mods/svc/save.cpp
new file mode 100644
index 0000000000..b09b3999cc
--- /dev/null
+++ b/src/dusk/mods/svc/save.cpp
@@ -0,0 +1,441 @@
+#include "save.hpp"
+
+#include "item.hpp"
+#include "registry.hpp"
+
+#include "dusk/main.h"
+#include "dusk/mods/loader/loader.hpp"
+#include "dusk/utilities.hpp"
+#include "mods/svc/save.h"
+
+#include "d/d_save.h"
+
+#include <aurora/lib/logging.hpp>
+
+#include <fstream>
+#include <string_view>
+
+namespace dusk::mods::svc {
+namespace {
+
+aurora::Module Log("dusk::mods::save");
+
+constexpr uint32_t kSlotCount = 3;
+constexpr size_t kQuestLogSize = 0xA94;
+static_assert(kQuestLogSize == QUEST_LOG_SIZE);
+constexpr int kSidecarVersion = 1;
+constexpr const char* kSidecarName = "mod_saves.json";
+constexpr size_t kMaxBlobNameLength = 256;
+
+using BlobMap = std::map<std::string, std::vector<uint8_t>>;
+
+struct SlotStore {
+    bool snapshotValid = false;
+    uint32_t snapshotCrc = 0;
+    std::map<std::string, BlobMap> mods;
+};
+
+struct SaveObserverRecord {
+    uint64_t handle = 0;
+    LoadedMod* mod = nullptr;
+    SaveEventFn onNewSave = nullptr;
+    SaveEventFn onLoaded = nullptr;
+    SaveEventFn onWritten = nullptr;
+    void* userData = nullptr;
+};
+
+std::array<SlotStore, kSlotCount> s_slots;
+int32_t s_currentSlot = -1;
+bool s_sidecarLoaded = false;
+std::vector<SaveObserverRecord> s_observers;
+uint64_t s_nextHandle = 1;
+
+std::filesystem::path sidecar_path() {
+    return dusk::ConfigPath / kSidecarName;
+}
+
+void load_sidecar() {
+    if (s_sidecarLoaded) {
+        return;
+    }
+    s_sidecarLoaded = true;
+    std::ifstream in{sidecar_path()};
+    if (!in.is_open()) {
+        return;
+    }
+    try {
+        const auto json = nlohmann::json::parse(in);
+        if (json.value("version", 0) != kSidecarVersion) {
+            Log.warn(
+                "mod save sidecar has unknown version {}; ignoring it", json.value("version", 0));
+            return;
+        }
+        const auto& slots = json.at("slots");
+        for (uint32_t slot = 0; slot < kSlotCount && slot < slots.size(); ++slot) {
+            auto& store = s_slots[slot];
+            const auto& slotJson = slots[slot];
+            if (slotJson.contains("snapshot_crc32")) {
+                store.snapshotValid = true;
+                store.snapshotCrc = slotJson["snapshot_crc32"].get<uint32_t>();
+            }
+            const auto modsJson = slotJson.value("mods", nlohmann::json::object());
+            for (const auto& [modId, blobs] : modsJson.items()) {
+                for (const auto& [name, encoded] : blobs.items()) {
+                    std::vector<uint8_t> bytes;
+                    if (!utils::base64_decode(encoded.get<std::string>(), bytes)) {
+                        Log.warn("mod save sidecar: bad blob '{}/{}' in slot {}; dropped", modId,
+                            name, slot);
+                        continue;
+                    }
+                    s_slots[slot].mods[modId][name] = std::move(bytes);
+                }
+            }
+        }
+    } catch (const std::exception& e) {
+        Log.error("failed to read mod save sidecar: {}", e.what());
+    }
+}
+
+void flush_sidecar() {
+    nlohmann::json slots = nlohmann::json::array();
+    for (const auto& store : s_slots) {
+        nlohmann::json slotJson = nlohmann::json::object();
+        if (store.snapshotValid) {
+            slotJson["snapshot_crc32"] = store.snapshotCrc;
+        }
+        nlohmann::json mods = nlohmann::json::object();
+        for (const auto& [modId, blobs] : store.mods) {
+            if (blobs.empty()) {
+                continue;
+            }
+            nlohmann::json blobsJson = nlohmann::json::object();
+            for (const auto& [name, bytes] : blobs) {
+                blobsJson[name] = utils::base64_encode(bytes);
+            }
+            mods[modId] = std::move(blobsJson);
+        }
+        slotJson["mods"] = std::move(mods);
+        slots.push_back(std::move(slotJson));
+    }
+    const nlohmann::json json{{"version", kSidecarVersion}, {"slots", std::move(slots)}};
+
+    const auto path = sidecar_path();
+    const auto tempPath = path.string() + ".tmp";
+    try {
+        {
+            std::ofstream out{tempPath, std::ios::trunc};
+            out << json.dump(2);
+            if (!out.good()) {
+                throw std::runtime_error("write failed");
+            }
+        }
+        std::filesystem::rename(tempPath, path);
+    } catch (const std::exception& e) {
+        Log.error("failed to write mod save sidecar: {}", e.what());
+        std::error_code ec;
+        std::filesystem::remove(tempPath, ec);
+    }
+}
+
+void notify(uint32_t slot, SaveEventFn SaveObserverRecord::* which, const char* what) {
+    // Callbacks may unregister observers.
+    const auto observers = s_observers;
+    for (const auto& observer : observers) {
+        if (!observer.mod->active || observer.*which == nullptr) {
+            continue;
+        }
+        try {
+            (observer.*which)(observer.mod->context.get(), slot, observer.userData);
+        } catch (const std::exception& e) {
+            fail_mod(*observer.mod, MOD_ERROR,
+                fmt::format("exception in {} save callback: {}", what, e.what()));
+        } catch (...) {
+            fail_mod(*observer.mod, MOD_ERROR,
+                fmt::format("unknown exception in {} save callback", what));
+        }
+    }
+}
+
+}  // namespace
+
+void save_slot_new(uint32_t slot) {
+    if (slot >= kSlotCount) {
+        return;
+    }
+    load_sidecar();
+    auto& store = s_slots[slot];
+    store.mods.clear();
+    store.snapshotValid = false;
+    s_currentSlot = static_cast<int32_t>(slot);
+    item_gives_clear();
+    Log.info("new save in slot {}; mod blob store cleared", slot);
+    notify(slot, &SaveObserverRecord::onNewSave, "new-save");
+}
+
+void save_slot_loaded(uint32_t slot, const void* slotData) {
+    if (slot >= kSlotCount) {
+        return;
+    }
+    load_sidecar();
+    auto& store = s_slots[slot];
+    if (store.snapshotValid && slotData != nullptr) {
+        const auto crc = utils::crc32(slotData, kQuestLogSize);
+        if (crc != store.snapshotCrc) {
+            Log.warn("slot {} save data does not match the mod sidecar snapshot; mod save "
+                     "data may be stale (card file changed externally?)",
+                slot);
+        }
+    }
+    s_currentSlot = static_cast<int32_t>(slot);
+    item_gives_clear();
+    notify(slot, &SaveObserverRecord::onLoaded, "save-loaded");
+}
+
+void save_slot_written(uint32_t slot, const void* slotData) {
+    if (slot >= kSlotCount) {
+        return;
+    }
+    s_currentSlot = static_cast<int32_t>(slot);
+    notify(slot, &SaveObserverRecord::onWritten, "save-written");
+    load_sidecar();
+    auto& store = s_slots[slot];
+    if (slotData != nullptr) {
+        store.snapshotValid = true;
+        store.snapshotCrc = utils::crc32(slotData, kQuestLogSize);
+    }
+    flush_sidecar();
+}
+
+void save_slot_copied(uint32_t fromSlot, uint32_t toSlot) {
+    if (fromSlot >= kSlotCount || toSlot >= kSlotCount || fromSlot == toSlot) {
+        return;
+    }
+    load_sidecar();
+    s_slots[toSlot] = s_slots[fromSlot];
+    flush_sidecar();
+    Log.info("mod save data copied with slot {} -> {}", fromSlot, toSlot);
+}
+
+void save_slot_erased(uint32_t slot) {
+    if (slot >= kSlotCount) {
+        return;
+    }
+    load_sidecar();
+    s_slots[slot] = SlotStore{};
+    flush_sidecar();
+    Log.info("mod save data erased with slot {}", slot);
+}
+
+void save_no_slot() {
+    s_currentSlot = -1;
+    item_gives_clear();
+}
+
+namespace {
+
+BlobMap* current_blobs(const LoadedMod& mod, bool create) {
+    if (s_currentSlot < 0) {
+        return nullptr;
+    }
+    load_sidecar();
+    auto& mods = s_slots[s_currentSlot].mods;
+    if (!create) {
+        const auto it = mods.find(mod.metadata.id);
+        return it != mods.end() ? &it->second : nullptr;
+    }
+    return &mods[mod.metadata.id];
+}
+
+}  // namespace
+
+ModResult save_set_blob(LoadedMod& mod, const char* name, const void* data, size_t size) {
+    auto* blobs = current_blobs(mod, true);
+    if (blobs == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    size_t total = size;
+    for (const auto& [blobName, bytes] : *blobs) {
+        if (blobName != name) {
+            total += bytes.size();
+        }
+    }
+    if (total > SAVE_BLOB_BUDGET_BYTES) {
+        Log.error("[{}] save blob '{}' rejected: {} bytes would exceed the {}-byte budget",
+            mod.metadata.id, name, total, SAVE_BLOB_BUDGET_BYTES);
+        return MOD_UNAVAILABLE;
+    }
+    const auto* bytes = static_cast<const uint8_t*>(data);
+    (*blobs)[name] = std::vector<uint8_t>{bytes, bytes + size};
+    return MOD_OK;
+}
+
+ModResult save_get_blob(LoadedMod& mod, const char* name, void* buf, size_t& inoutSize) {
+    auto* blobs = current_blobs(mod, false);
+    if (blobs == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    const auto it = blobs->find(name);
+    if (it == blobs->end()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (buf == nullptr) {
+        inoutSize = it->second.size();
+        return MOD_OK;
+    }
+    if (inoutSize < it->second.size()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    std::memcpy(buf, it->second.data(), it->second.size());
+    inoutSize = it->second.size();
+    return MOD_OK;
+}
+
+ModResult save_delete_blob(LoadedMod& mod, const char* name) {
+    auto* blobs = current_blobs(mod, false);
+    if (blobs == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    return blobs->erase(name) != 0 ? MOD_OK : MOD_INVALID_ARGUMENT;
+}
+
+ModResult save_observe(LoadedMod& mod, SaveEventFn onNewSave, SaveEventFn onLoaded,
+    SaveEventFn onWritten, void* userData, uint64_t& outHandle) {
+    auto& observer = s_observers.emplace_back();
+    observer.handle = s_nextHandle++;
+    observer.mod = &mod;
+    observer.onNewSave = onNewSave;
+    observer.onLoaded = onLoaded;
+    observer.onWritten = onWritten;
+    observer.userData = userData;
+    outHandle = observer.handle;
+    return MOD_OK;
+}
+
+ModResult save_unobserve(LoadedMod& mod, uint64_t handle) {
+    const auto removed = std::erase_if(s_observers,
+        [&](const auto& observer) { return observer.handle == handle && observer.mod == &mod; });
+    return removed != 0 ? MOD_OK : MOD_INVALID_ARGUMENT;
+}
+
+ModResult save_peek_blob(
+    LoadedMod& mod, uint32_t slot, const char* name, void* buf, size_t& inoutSize) {
+    if (slot >= kSlotCount) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    load_sidecar();
+    const auto& mods = s_slots[slot].mods;
+    const auto modIt = mods.find(mod.metadata.id);
+    if (modIt == mods.end()) {
+        return MOD_UNAVAILABLE;
+    }
+    const auto it = modIt->second.find(name);
+    if (it == modIt->second.end()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (buf == nullptr) {
+        inoutSize = it->second.size();
+        return MOD_OK;
+    }
+    if (inoutSize < it->second.size()) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    std::memcpy(buf, it->second.data(), it->second.size());
+    inoutSize = it->second.size();
+    return MOD_OK;
+}
+
+void save_remove_mod(LoadedMod& mod) {
+    std::erase_if(s_observers, [&](const auto& observer) { return observer.mod == &mod; });
+    // Blob data persists across mod reloads.
+}
+
+namespace {
+bool is_valid_blob_name(const char* name) {
+    if (name == nullptr) {
+        return false;
+    }
+    const std::string_view view{name};
+    return !view.empty() && view.size() <= kMaxBlobNameLength;
+}
+
+ModResult save_set_blob_(ModContext* context, const char* name, const void* data, size_t size) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_blob_name(name) || (data == nullptr && size != 0) ||
+        size > SAVE_BLOB_BUDGET_BYTES)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return save_set_blob(*mod, name, data, size);
+}
+
+ModResult save_get_blob_(ModContext* context, const char* name, void* buf, size_t* inoutSize) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_blob_name(name) || inoutSize == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return save_get_blob(*mod, name, buf, *inoutSize);
+}
+
+ModResult save_delete_blob_(ModContext* context, const char* name) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_blob_name(name)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return save_delete_blob(*mod, name);
+}
+
+ModResult save_observe_saves_(ModContext* context, SaveEventFn onNewSave, SaveEventFn onLoaded,
+    SaveEventFn onWritten, void* userData, SaveObserverHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || (onNewSave == nullptr && onLoaded == nullptr && onWritten == nullptr)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    uint64_t handle = 0;
+    const auto result = save_observe(*mod, onNewSave, onLoaded, onWritten, userData, handle);
+    if (outHandle != nullptr) {
+        *outHandle = handle;
+    }
+    return result;
+}
+
+ModResult save_unobserve_saves_(ModContext* context, SaveObserverHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return save_unobserve(*mod, handle);
+}
+
+ModResult save_peek_blob_(
+    ModContext* context, uint32_t slot, const char* name, void* buf, size_t* inoutSize) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_blob_name(name) || inoutSize == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return save_peek_blob(*mod, slot, name, buf, *inoutSize);
+}
+
+constexpr SaveService s_saveService{
+    .header = SERVICE_HEADER(SaveService, SAVE_SERVICE_MAJOR, SAVE_SERVICE_MINOR),
+    .set_blob = save_set_blob_,
+    .get_blob = save_get_blob_,
+    .delete_blob = save_delete_blob_,
+    .observe_saves = save_observe_saves_,
+    .unobserve_saves = save_unobserve_saves_,
+    .peek_blob = save_peek_blob_,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_saveModule{
+    .id = SAVE_SERVICE_ID,
+    .majorVersion = SAVE_SERVICE_MAJOR,
+    .minorVersion = SAVE_SERVICE_MINOR,
+    .service = &s_saveService,
+    .modDetached = save_remove_mod,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/save.hpp b/src/dusk/mods/svc/save.hpp
new file mode 100644
index 0000000000..89460af146
--- /dev/null
+++ b/src/dusk/mods/svc/save.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstdint>
+
+namespace dusk::mods::svc {
+
+void save_slot_new(uint32_t slot);
+void save_slot_loaded(uint32_t slot, const void* slotData);
+void save_slot_written(uint32_t slot, const void* slotData);
+void save_slot_copied(uint32_t fromSlot, uint32_t toSlot);
+void save_slot_erased(uint32_t slot);
+void save_no_slot();
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/stage.cpp b/src/dusk/mods/svc/stage.cpp
new file mode 100644
index 0000000000..f20634e8ec
--- /dev/null
+++ b/src/dusk/mods/svc/stage.cpp
@@ -0,0 +1,326 @@
+#include "stage.hpp"
+
+#include "registry.hpp"
+
+#include "dusk/mods/loader/loader.hpp"
+#include "dusk/utilities.hpp"
+#include "mods/svc/stage.h"
+
+#include "d/d_com_inf_game.h"
+
+#include <aurora/lib/logging.hpp>
+
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace dusk::mods::svc {
+namespace {
+
+aurora::Module Log{"dusk::mods::stage"};
+
+constexpr size_t kActrEntrySize = 0x20;
+constexpr size_t kTgscEntrySize = 0x23;
+constexpr uint8_t kRoomDefault = 0xFF;
+constexpr int8_t kLayerDefault = -1;
+
+enum class EditKind : uint8_t { Patch, Delete, Add };
+
+struct ActorEditRecord {
+    uint64_t handle = 0;
+    LoadedMod* mod = nullptr;
+    uint64_t seq = 0;
+    uint8_t room = 0;
+    int8_t layer = kLayerDefault;
+    EditKind kind = EditKind::Patch;
+    uint32_t crc = 0;
+    std::vector<uint8_t> record;
+};
+
+std::unordered_map<std::string, std::vector<ActorEditRecord>> s_edits;
+uint64_t s_nextHandle = 1;
+uint64_t s_nextSeq = 1;
+std::unordered_set<uint32_t> s_warnedRecords;
+
+int32_t compute_mod_priority(const LoadedMod& mod) {
+    int32_t index = 0;
+    for (const auto& other : ModLoader::instance().mods()) {
+        ++index;
+        if (&other == &mod) {
+            return index;
+        }
+    }
+    return index + 1;
+}
+
+const std::vector<ActorEditRecord>* current_stage_edits() {
+    if (s_edits.empty()) {
+        return nullptr;
+    }
+    const char* stageName = dComIfGp_getStartStageName();
+    if (stageName == nullptr) {
+        return nullptr;
+    }
+    const auto it = s_edits.find(stageName);
+    return it != s_edits.end() ? &it->second : nullptr;
+}
+
+bool room_matches(const ActorEditRecord& record, uint8_t roomNo) {
+    return record.room == roomNo || record.room == kRoomDefault;
+}
+
+bool layer_matches(const ActorEditRecord& record, int8_t layer) {
+    return record.layer == layer || record.layer == kLayerDefault;
+}
+
+}  // namespace
+
+bool stage_apply_actor_edits(void* actorData, void* actorPrm, size_t recordSize, int8_t roomNo) {
+    const auto* edits = current_stage_edits();
+    if (edits == nullptr) {
+        return true;
+    }
+
+    uint8_t room = static_cast<uint8_t>(roomNo);
+    if (roomNo == -1) {
+        room = static_cast<uint8_t>(dComIfGp_getStartStageRoomNo());
+    }
+
+    const auto layer = static_cast<int8_t>(dComIfG_play_c::getLayerNo(0));
+    const auto crc = utils::crc32(actorData, recordSize);
+
+    const ActorEditRecord* winner = nullptr;
+    int32_t winnerPriority = 0;
+    const LoadedMod* firstOwner = nullptr;
+    for (const auto& record : *edits) {
+        if (record.kind == EditKind::Add || !record.mod->active || !layer_matches(record, layer) ||
+            !room_matches(record, room))
+        {
+            continue;
+        }
+
+        const bool matches = record.crc == crc && (record.kind == EditKind::Delete ||
+                                                      record.record.size() == recordSize);
+        if (!matches) {
+            continue;
+        }
+
+        if (firstOwner == nullptr) {
+            firstOwner = record.mod;
+        } else if (firstOwner != record.mod && s_warnedRecords.insert(record.crc).second) {
+            Log.warn("actor record {:#010x} edited by multiple mods; the later-loaded one wins",
+                record.crc);
+        }
+
+        const auto priority = compute_mod_priority(*record.mod);
+        if (winner == nullptr || priority > winnerPriority ||
+            (priority == winnerPriority && record.seq > winner->seq))
+        {
+            winner = &record;
+            winnerPriority = priority;
+        }
+    }
+
+    if (winner == nullptr) {
+        return true;
+    }
+    if (winner->kind == EditKind::Delete) {
+        return false;
+    }
+
+    std::memcpy(actorData, winner->record.data(), winner->record.size());
+    if (actorPrm) {
+        std::memcpy(actorPrm, winner->record.data() + 8, winner->record.size() - 8);
+    }
+    return true;
+}
+
+void stage_create_new_actors(
+    int8_t roomNo, void (*createFn)(void* user, const void* record, size_t size), void* user) {
+    const auto* edits = current_stage_edits();
+    if (edits == nullptr) {
+        return;
+    }
+
+    const auto layer = static_cast<int8_t>(dComIfG_play_c::getLayerNo(0));
+    for (const auto& record : *edits) {
+        if (record.kind == EditKind::Add && record.mod->active &&
+            record.room == static_cast<uint8_t>(roomNo) && layer_matches(record, layer))
+        {
+            createFn(user, record.record.data(), record.record.size());
+        }
+    }
+}
+
+namespace {
+
+ModResult register_edit(
+    LoadedMod& mod, const char* stage, ActorEditRecord&& record, uint64_t& outHandle) {
+    record.handle = s_nextHandle++;
+    record.mod = &mod;
+    record.seq = s_nextSeq++;
+    outHandle = record.handle;
+    s_edits[stage].push_back(std::move(record));
+    return MOD_OK;
+}
+
+}  // namespace
+
+ModResult stage_patch_actor(LoadedMod& mod, const char* stage, uint8_t room, int8_t layer,
+    uint32_t crc, const void* record, size_t recordSize, uint64_t& outHandle) {
+    const auto* bytes = static_cast<const uint8_t*>(record);
+    return register_edit(mod, stage,
+        ActorEditRecord{.room = room,
+            .layer = layer,
+            .kind = EditKind::Patch,
+            .crc = crc,
+            .record = {bytes, bytes + recordSize}},
+        outHandle);
+}
+
+ModResult stage_delete_actor(LoadedMod& mod, const char* stage, uint8_t room, int8_t layer,
+    uint32_t crc, uint64_t& outHandle) {
+    return register_edit(mod, stage,
+        ActorEditRecord{.room = room, .layer = layer, .kind = EditKind::Delete, .crc = crc},
+        outHandle);
+}
+
+ModResult stage_add_actor(LoadedMod& mod, const char* stage, uint8_t room, int8_t layer,
+    const void* record, size_t recordSize, uint64_t& outHandle) {
+    const auto* bytes = static_cast<const uint8_t*>(record);
+    return register_edit(mod, stage,
+        ActorEditRecord{.room = room,
+            .layer = layer,
+            .kind = EditKind::Add,
+            .record = {bytes, bytes + recordSize}},
+        outHandle);
+}
+
+ModResult stage_remove_actor_edit(LoadedMod& mod, uint64_t handle) {
+    for (auto it = s_edits.begin(); it != s_edits.end(); ++it) {
+        const auto removed = std::erase_if(it->second,
+            [&](const auto& record) { return record.handle == handle && record.mod == &mod; });
+        if (removed != 0) {
+            if (it->second.empty()) {
+                s_edits.erase(it);
+            }
+            return MOD_OK;
+        }
+    }
+    return MOD_INVALID_ARGUMENT;
+}
+
+void stage_remove_mod(LoadedMod& mod) {
+    for (auto it = s_edits.begin(); it != s_edits.end();) {
+        std::erase_if(it->second, [&](const auto& record) { return record.mod == &mod; });
+        it = it->second.empty() ? s_edits.erase(it) : std::next(it);
+    }
+}
+
+namespace {
+constexpr size_t kMaxStageNameLength = 8;
+
+bool is_valid_stage_name(const char* stage) {
+    if (stage == nullptr) {
+        return false;
+    }
+    const std::string_view view{stage};
+    return !view.empty() && view.size() <= kMaxStageNameLength;
+}
+
+bool is_valid_record_size(size_t size) {
+    return size == kActrEntrySize || size == kTgscEntrySize;
+}
+
+ModResult stage_patch_actor_(ModContext* context, const char* stage, uint8_t room, int8_t layer,
+    uint32_t recordCrc, const void* record, size_t recordSize, StageActorHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_stage_name(stage) || record == nullptr ||
+        !is_valid_record_size(recordSize))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    uint64_t handle = 0;
+    const auto result =
+        stage_patch_actor(*mod, stage, room, layer, recordCrc, record, recordSize, handle);
+    if (outHandle != nullptr) {
+        *outHandle = handle;
+    }
+
+    return result;
+}
+
+ModResult stage_delete_actor_(ModContext* context, const char* stage, uint8_t room, int8_t layer,
+    uint32_t recordCrc, StageActorHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_stage_name(stage)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    uint64_t handle = 0;
+    const auto result = stage_delete_actor(*mod, stage, room, layer, recordCrc, handle);
+    if (outHandle != nullptr) {
+        *outHandle = handle;
+    }
+    return result;
+}
+
+ModResult stage_add_actor_(ModContext* context, const char* stage, uint8_t room, int8_t layer,
+    const void* record, size_t recordSize, StageActorHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || !is_valid_stage_name(stage) || room == kRoomDefault ||
+        record == nullptr || !is_valid_record_size(recordSize))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    uint64_t handle = 0;
+    const auto result = stage_add_actor(*mod, stage, room, layer, record, recordSize, handle);
+    if (outHandle != nullptr) {
+        *outHandle = handle;
+    }
+    return result;
+}
+
+ModResult stage_remove_actor_edit_(ModContext* context, StageActorHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || handle == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return stage_remove_actor_edit(*mod, handle);
+}
+
+constexpr StageService s_stageService{
+    .header = SERVICE_HEADER(StageService, STAGE_SERVICE_MAJOR, STAGE_SERVICE_MINOR),
+    .patch_actor = stage_patch_actor_,
+    .delete_actor = stage_delete_actor_,
+    .add_actor = stage_add_actor_,
+    .remove_actor_edit = stage_remove_actor_edit_,
+};
+
+}  // namespace
+
+constinit const ServiceModule g_stageModule{
+    .id = STAGE_SERVICE_ID,
+    .majorVersion = STAGE_SERVICE_MAJOR,
+    .minorVersion = STAGE_SERVICE_MINOR,
+    .service = &s_stageService,
+    .modDetached = stage_remove_mod,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/stage.hpp b/src/dusk/mods/svc/stage.hpp
new file mode 100644
index 0000000000..f27f70e646
--- /dev/null
+++ b/src/dusk/mods/svc/stage.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace dusk::mods::svc {
+
+bool stage_apply_actor_edits(void* actorData, void* actorPrm, size_t recordSize, int8_t roomNo);
+
+void stage_create_new_actors(
+    int8_t roomNo, void (*createFn)(void* user, const void* record, size_t size), void* user);
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/texture.cpp b/src/dusk/mods/svc/texture.cpp
index 63c8ba822b..90b3bfff94 100644
--- a/src/dusk/mods/svc/texture.cpp
+++ b/src/dusk/mods/svc/texture.cpp
@@ -1,6 +1,6 @@
 #include "registry.hpp"
 
-#include "aurora/lib/logging.hpp"
+#include <borealis/log.hpp>
 #include "dusk/mods/loader/loader.hpp"
 #include "mods/svc/texture.h"
 
@@ -29,7 +29,7 @@ struct TextureRawData {
     uint32_t gxFormat = 0;
 };
 
-aurora::Module Log("dusk::mods::textures");
+constexpr borealis::Log Log{"dusk::mods::textures"};
 
 // Referenced by Aurora's lazy virtual-file reads (from arbitrary threads, under Aurora's registry
 // lock) and by raw-entry spans. Immutable after construction; freed only after the corresponding
diff --git a/src/dusk/mods/svc/ui.cpp b/src/dusk/mods/svc/ui.cpp
index 72366aaab7..77f792b73c 100644
--- a/src/dusk/mods/svc/ui.cpp
+++ b/src/dusk/mods/svc/ui.cpp
@@ -1,45 +1,67 @@
 #include "ui.hpp"
 
 #include "config.hpp"
+#include "internal.hpp"
 #include "registry.hpp"
+#include "ui_v1.hpp"
 
-#include "aurora/lib/logging.hpp"
 #include "dusk/mod_loader.hpp"
 #include "dusk/mods/loader/loader.hpp"
+#include "dusk/mods/log_buffer.hpp"
+#include "dusk/ui/list.hpp"
 #include "dusk/ui/menu_bar.hpp"
 #include "dusk/ui/mod_window.hpp"
 #include "dusk/ui/modal.hpp"
 #include "dusk/ui/ui.hpp"
 #include "mods/svc/ui.h"
 
-#include <RmlUi/Core.h>
 #include <aurora/rmlui.hpp>
+#include <borealis/log.hpp>
 #include <fmt/format.h>
+#include <SDL3/SDL_clipboard.h>
+#include <RmlUi/Core.h>
 
 #include <algorithm>
+#include <chrono>
 #include <climits>
-#include <cstdint>
+#include <cstddef>
 #include <functional>
+#include <limits>
 #include <memory>
+#include <optional>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
+namespace {
+
+constexpr size_t kUiControlSelectedSize =
+    offsetof(UiControlDesc, is_selected) + sizeof(UiPredicateFn);
+constexpr size_t kUiControlStringSetModeSize =
+    offsetof(UiControlDesc, string_set_mode) + sizeof(UiStringSetMode);
+constexpr size_t kUiControlFilePickerSize = offsetof(UiControlDesc, directory_mode) + sizeof(bool);
+constexpr size_t kUiListItemV21Size = offsetof(UiListItem, label) + sizeof(const char*);
+constexpr size_t kUiListDescV21Size = offsetof(UiListDesc, user_data) + sizeof(void*);
+
+}  // namespace
+
 namespace dusk::mods::svc::ui_impl {
 namespace {
 
-aurora::Module Log("dusk::mods::ui");
+constexpr borealis::Log Log{"dusk::mods::ui"};
 
 enum class UiSlotKind : u8 {
-    Free,
     Window,
     Dialog,
     Pane,
     Text,
     Progress,
     Control,
+    List,
     Style,
     MenuTab,
 };
@@ -58,27 +80,28 @@ const char* slot_kind_name(UiSlotKind kind) {
         return "progress";
     case UiSlotKind::Control:
         return "control";
+    case UiSlotKind::List:
+        return "list";
     case UiSlotKind::Style:
         return "style";
     case UiSlotKind::MenuTab:
         return "menu tab";
     default:
-        return "free";
+        return "unknown";
     }
 }
 
-// Generation-checked handle slots. Game thread only: all mutations happen in service calls made
-// from mod code, in UI callbacks (ui::update), or in the loader's deactivate paths.
+// Game thread only: all mutations happen in service calls made from mod code, in UI callbacks
+// (ui::update), or in the loader's deactivate paths.
 struct UiSlot {
-    // Bumped on free, which invalidates every outstanding handle to this slot.
-    uint32_t generation = 1;
-    UiSlotKind kind = UiSlotKind::Free;
-    LoadedMod* owner = nullptr;
+    UiSlotKind kind = UiSlotKind::Window;
     // Pane/Text/Progress/Control: freed automatically when the element is destroyed
     Rml::Element* element = nullptr;
     // Pane payload
     ui::Pane* pane = nullptr;
     ui::Pane* helpPane = nullptr;
+    // List payload
+    ui::List* list = nullptr;
     // Window/Dialog payload (non-owning; the document stack owns the document)
     ui::Document* document = nullptr;
     UiWindowClosedFn onClosed = nullptr;
@@ -88,13 +111,13 @@ struct UiSlot {
     std::string styleId;
     // Cached rendered values for element setters. These make the natural "set every update"
     // style cheap when the displayed value has not changed.
-    std::string elementRml;
+    std::string elementValue;
     float elementFloat = 0.0f;
     bool hasElementValue = false;
+    bool elementValueIsRml = false;
 };
 
-std::vector<UiSlot> s_slots;
-std::vector<uint32_t> s_freeSlots;
+SlotMap<UiSlot> s_slots;
 
 struct ModUiPanel {
     UiPanelBuildFn build = nullptr;
@@ -112,71 +135,26 @@ struct ModMenuTab {
 std::unordered_map<const LoadedMod*, std::vector<ModMenuTab>> s_modMenuTabs;
 bool s_menuTabsDirty = false;
 
-uint64_t handle_for(uint32_t index) {
-    return (uint64_t{s_slots[index].generation} << 32) | index;
-}
-
-uint32_t slot_index(const UiSlot& slot) {
-    return static_cast<uint32_t>(&slot - s_slots.data());
-}
-
 UiSlot* slot_from_handle(uint64_t handle) {
-    const auto index = static_cast<uint32_t>(handle & 0xFFFFFFFFu);
-    const auto generation = static_cast<uint32_t>(handle >> 32);
-    if (index >= s_slots.size()) {
-        return nullptr;
-    }
-    auto& slot = s_slots[index];
-    if (slot.kind == UiSlotKind::Free || slot.generation != generation) {
-        return nullptr;
-    }
-    return &slot;
+    auto* entry = s_slots.find(handle);
+    return entry != nullptr ? &entry->value : nullptr;
 }
 
 // Note: s_slots may reallocate on any later allocation, so callers must not hold the returned
 // slot reference across calls that can allocate (e.g. mod build callbacks); re-resolve instead.
 UiSlot& alloc_slot(LoadedMod& mod, UiSlotKind kind, uint64_t& outHandle) {
-    uint32_t index;
-    if (!s_freeSlots.empty()) {
-        index = s_freeSlots.back();
-        s_freeSlots.pop_back();
-    } else {
-        index = static_cast<uint32_t>(s_slots.size());
-        s_slots.emplace_back();
-    }
-    auto& slot = s_slots[index];
-    slot.kind = kind;
-    slot.owner = &mod;
-    outHandle = handle_for(index);
-    return slot;
-}
-
-void free_slot(UiSlot& slot) {
-    slot.generation++;
-    slot.kind = UiSlotKind::Free;
-    slot.owner = nullptr;
-    slot.element = nullptr;
-    slot.pane = nullptr;
-    slot.helpPane = nullptr;
-    slot.document = nullptr;
-    slot.onClosed = nullptr;
-    slot.onClosedUserData = nullptr;
-    slot.styleScope = ui::DocumentScope::None;
-    slot.styleId.clear();
-    slot.elementRml.clear();
-    slot.elementFloat = 0.0f;
-    slot.hasElementValue = false;
-    s_freeSlots.push_back(slot_index(slot));
+    outHandle = s_slots.emplace(mod, UiSlot{.kind = kind});
+    return s_slots.find(outHandle)->value;
 }
 
 UiSlot* resolve(LoadedMod& mod, uint64_t handle, UiSlotKind kind, const char* what) {
-    auto* slot = slot_from_handle(handle);
-    if (slot == nullptr || slot->owner != &mod || slot->kind != kind) {
+    auto* entry = s_slots.find_owned(handle, mod);
+    if (entry == nullptr || entry->value.kind != kind) {
         Log.error("[{}] {}: stale or invalid {} handle {:#x}", mod.metadata.id, what,
             slot_kind_name(kind), handle);
         return nullptr;
     }
-    return slot;
+    return &entry->value;
 }
 
 // Whether the registration a callback was created under is still live. Callbacks captured by
@@ -184,7 +162,7 @@ UiSlot* resolve(LoadedMod& mod, uint64_t handle, UiSlotKind kind, const char* wh
 // once a reload completes, but captured fn pointers still target the unloaded image. Teardown
 // frees the slots (ui_remove_mod), which invalidates every callback built under them.
 bool slot_live(uint64_t handle) {
-    return slot_from_handle(handle) != nullptr;
+    return s_slots.find(handle) != nullptr;
 }
 
 bool dialog_open(uint64_t handle) {
@@ -197,30 +175,22 @@ bool dialog_open(uint64_t handle) {
 // The generation check makes a late detach of an already-recycled slot a no-op.
 class SlotDetachListener final : public Rml::EventListener {
 public:
-    SlotDetachListener(uint32_t index, uint32_t generation)
-        : m_index{index}, m_generation{generation} {}
+    explicit SlotDetachListener(uint64_t handle) : m_handle{handle} {}
 
     void ProcessEvent(Rml::Event&) override {}
 
     void OnDetach(Rml::Element*) override {
-        if (m_index < s_slots.size()) {
-            auto& slot = s_slots[m_index];
-            if (slot.kind != UiSlotKind::Free && slot.generation == m_generation) {
-                free_slot(slot);
-            }
-        }
+        s_slots.erase(m_handle);
         delete this;
     }
 
 private:
-    uint32_t m_index;
-    uint32_t m_generation;
+    uint64_t m_handle;
 };
 
-void track_element(UiSlot& slot, Rml::Element& element) {
+void track_element(uint64_t handle, UiSlot& slot, Rml::Element& element) {
     slot.element = &element;
-    element.AddEventListener(
-        Rml::EventId::Click, new SlotDetachListener(slot_index(slot), slot.generation));
+    element.AddEventListener(Rml::EventId::Click, new SlotDetachListener{handle});
 }
 
 template <typename T, typename Fn>
@@ -269,7 +239,7 @@ uint64_t wrap_pane(LoadedMod& mod, ui::Pane& pane, ui::Pane* helpPane) {
     auto& slot = alloc_slot(mod, UiSlotKind::Pane, handle);
     slot.pane = &pane;
     slot.helpPane = helpPane;
-    track_element(slot, *pane.root());
+    track_element(handle, slot, *pane.root());
     return handle;
 }
 
@@ -302,18 +272,16 @@ void wire_callback_binding(
         if (!slot_live(guardHandle)) {
             return value;
         }
-        guarded_call(*modPtr, "control getter", [&] {
-            get(modPtr->context.get(), userData, &value);
-        });
+        guarded_call(
+            *modPtr, "control getter", [&] { get(modPtr->context.get(), userData, &value); });
         return value;
     };
     const auto setValue = [modPtr, set, userData, guardHandle](const UiControlValue& value) {
         if (!slot_live(guardHandle)) {
             return;
         }
-        guarded_call(*modPtr, "control setter", [&] {
-            set(modPtr->context.get(), userData, &value);
-        });
+        guarded_call(
+            *modPtr, "control setter", [&] { set(modPtr->context.get(), userData, &value); });
     };
     switch (desc.kind) {
     case UI_CONTROL_TOGGLE:
@@ -334,6 +302,8 @@ void wire_callback_binding(
         };
         break;
     case UI_CONTROL_STRING:
+    case UI_CONTROL_COLOR:
+    case UI_CONTROL_FILE_PICKER:
         spec.getString = [getValue]() -> Rml::String {
             const UiControlValue value = getValue();
             return value.string_value != nullptr ? value.string_value : "";
@@ -412,7 +382,9 @@ bool wire_config_var_binding(LoadedMod& mod, const UiControlDesc& desc, ui::ModC
         }
         return true;
     }
-    case UI_CONTROL_STRING: {
+    case UI_CONTROL_STRING:
+    case UI_CONTROL_COLOR:
+    case UI_CONTROL_FILE_PICKER: {
         const auto find = [modPtr, varHandle] {
             return static_cast<ConfigVar<std::string>*>(
                 config_find_var(*modPtr, varHandle, CONFIG_VAR_STRING));
@@ -446,25 +418,24 @@ bool wire_config_var_binding(LoadedMod& mod, const UiControlDesc& desc, ui::ModC
 }
 
 void on_mod_window_destroyed(uint64_t handle) {
-    auto* slot = slot_from_handle(handle);
-    if (slot == nullptr || slot->kind != UiSlotKind::Window) {
+    const auto* entry = s_slots.find(handle);
+    if (entry == nullptr || entry->value.kind != UiSlotKind::Window) {
         return;
     }
-    LoadedMod* mod = slot->owner;
-    const UiWindowClosedFn onClosed = slot->onClosed;
-    void* userData = slot->onClosedUserData;
-    free_slot(*slot);
+    auto released = s_slots.take(handle);
+    auto* mod = released->owner;
+    const UiWindowClosedFn onClosed = released->value.onClosed;
+    void* userData = released->value.onClosedUserData;
     if (mod != nullptr && onClosed != nullptr) {
-        guarded_call(*mod, "window on_closed callback", [&] {
-            onClosed(mod->context.get(), handle, userData);
-        });
+        guarded_call(*mod, "window on_closed callback",
+            [&] { onClosed(mod->context.get(), handle, userData); });
     }
 }
 
 void on_mod_dialog_destroyed(uint64_t handle) {
     auto* slot = slot_from_handle(handle);
     if (slot != nullptr && slot->kind == UiSlotKind::Dialog) {
-        free_slot(*slot);
+        s_slots.erase(handle);
     }
 }
 
@@ -480,7 +451,6 @@ public:
     }
 
     void close() { pop(); }
-    void force_close() { Document::hide(true); }
 
 private:
     std::function<void()> m_onDestroyed;
@@ -494,10 +464,8 @@ void push_stacked_document(std::unique_ptr<ui::Document> document) {
     }
 }
 
-// Shared by dialog_push and dialog_add_action; the guard handle keeps a
-// pressed callback from calling into a torn-down mod.
 ui::ModalAction make_dialog_action(LoadedMod& mod, uint64_t handle, const UiDialogAction& action) {
-    return {
+    ui::ModalAction result{
         .label = action.label,
         .onPressed =
             [modPtr = &mod, handle, fn = action.on_pressed, userData = action.user_data,
@@ -506,9 +474,8 @@ ui::ModalAction make_dialog_action(LoadedMod& mod, uint64_t handle, const UiDial
                     return;  // already being torn down
                 }
                 if (fn != nullptr) {
-                    guarded_call(*modPtr, "dialog action callback", [&] {
-                        fn(modPtr->context.get(), handle, userData);
-                    });
+                    guarded_call(*modPtr, "dialog action callback",
+                        [&] { fn(modPtr->context.get(), handle, userData); });
                 }
                 // The callback may have closed the dialog already
                 if (!keepOpen && dialog_open(handle)) {
@@ -516,6 +483,17 @@ ui::ModalAction make_dialog_action(LoadedMod& mod, uint64_t handle, const UiDial
                 }
             },
     };
+    if (action.is_disabled != nullptr) {
+        result.isDisabled = [modPtr = &mod, handle, fn = action.is_disabled,
+                                userData = action.user_data] {
+            if (!dialog_open(handle)) {
+                return false;
+            }
+            return guarded_call(*modPtr, "dialog action is_disabled callback", false,
+                [&] { return fn(modPtr->context.get(), userData); });
+        };
+    }
+    return result;
 }
 
 }  // namespace
@@ -549,9 +527,8 @@ void ui_update_mods_panels(LoadedMod& mod) {
     if (!mod.active || panel.update == nullptr) {
         return;
     }
-    invoke_mod_ui_callback(mod, "mod UI panel update", [&](ModError* error) {
-        return panel.update(mod.context.get(), panel.userData, error);
-    });
+    invoke_mod_ui_callback(mod, "mod UI panel update",
+        [&](ModError* error) { return panel.update(mod.context.get(), panel.userData, error); });
 }
 
 ModResult ui_pane_add_section(LoadedMod& mod, uint64_t pane, const char* title) {
@@ -571,9 +548,9 @@ ModResult ui_pane_add_text(LoadedMod& mod, uint64_t pane, const char* text, uint
     auto* elem = slot->pane->add_text(text);
     if (outElem != nullptr) {
         auto& elemSlot = alloc_slot(mod, UiSlotKind::Text, *outElem);
-        elemSlot.elementRml = ui::escape(text);
+        elemSlot.elementValue = text;
         elemSlot.hasElementValue = true;
-        track_element(elemSlot, *elem);
+        track_element(*outElem, elemSlot, *elem);
     }
     return MOD_OK;
 }
@@ -586,9 +563,10 @@ ModResult ui_pane_add_rml(LoadedMod& mod, uint64_t pane, const char* rml, uint64
     auto* elem = slot->pane->add_rml(rml);
     if (outElem != nullptr) {
         auto& elemSlot = alloc_slot(mod, UiSlotKind::Text, *outElem);
-        elemSlot.elementRml = rml;
+        elemSlot.elementValue = rml;
         elemSlot.hasElementValue = true;
-        track_element(elemSlot, *elem);
+        elemSlot.elementValueIsRml = true;
+        track_element(*outElem, elemSlot, *elem);
     }
     return MOD_OK;
 }
@@ -604,7 +582,7 @@ ModResult ui_pane_add_progress(LoadedMod& mod, uint64_t pane, float value, uint6
         auto& elemSlot = alloc_slot(mod, UiSlotKind::Progress, *outElem);
         elemSlot.elementFloat = value;
         elemSlot.hasElementValue = true;
-        track_element(elemSlot, *elem);
+        track_element(*outElem, elemSlot, *elem);
     }
     return MOD_OK;
 }
@@ -623,15 +601,19 @@ ModResult ui_pane_add_control(
     spec.isModified = wrap_predicate(mod, desc.is_modified, desc.user_data, pane);
     switch (desc.kind) {
     case UI_CONTROL_BUTTON:
-        spec.kind = ui::ModControlSpec::Kind::Button;
+    case UI_CONTROL_GROUP:
+        spec.kind = desc.kind == UI_CONTROL_BUTTON ? ui::ModControlSpec::Kind::Button :
+                                                     ui::ModControlSpec::Kind::Group;
+        if (desc.struct_size >= kUiControlSelectedSize) {
+            spec.isSelected = wrap_predicate(mod, desc.is_selected, desc.user_data, pane);
+        }
         spec.onPressed = [modPtr = &mod, fn = desc.on_pressed, userData = desc.user_data,
                              guardHandle = pane] {
             if (!slot_live(guardHandle)) {
                 return;
             }
-            guarded_call(*modPtr, "control on_pressed callback", [&] {
-                fn(modPtr->context.get(), userData);
-            });
+            guarded_call(*modPtr, "control on_pressed callback",
+                [&] { fn(modPtr->context.get(), userData); });
         };
         break;
     case UI_CONTROL_TOGGLE:
@@ -653,6 +635,22 @@ ModResult ui_pane_add_control(
     case UI_CONTROL_STRING:
         spec.kind = ui::ModControlSpec::Kind::String;
         spec.maxLength = desc.max_length < 1 ? -1 : desc.max_length;
+        spec.stringSetOnChange = desc.struct_size >= kUiControlStringSetModeSize &&
+                                 desc.string_set_mode == UI_STRING_SET_ON_CHANGE;
+        break;
+    case UI_CONTROL_COLOR:
+        spec.kind = ui::ModControlSpec::Kind::Color;
+        spec.colorAlpha = desc.color_alpha;
+        for (size_t i = 0; i < desc.color_preset_count; ++i) {
+            spec.colorPresets.emplace_back(desc.color_presets[i]);
+        }
+        break;
+    case UI_CONTROL_FILE_PICKER:
+        spec.kind = ui::ModControlSpec::Kind::FilePicker;
+        spec.directoryMode = desc.directory_mode;
+        for (size_t i = 0; i < desc.file_filter_count; ++i) {
+            spec.fileFilters.push_back({desc.file_filters[i].name, desc.file_filters[i].pattern});
+        }
         break;
     case UI_CONTROL_SELECT:
         spec.kind = ui::ModControlSpec::Kind::Select;
@@ -669,7 +667,7 @@ ModResult ui_pane_add_control(
         return MOD_INVALID_ARGUMENT;
     }
 
-    if (desc.kind != UI_CONTROL_BUTTON) {
+    if (desc.kind != UI_CONTROL_BUTTON && desc.kind != UI_CONTROL_GROUP) {
         if (desc.binding == UI_BINDING_CONFIG_VAR) {
             if (!wire_config_var_binding(mod, desc, spec)) {
                 Log.error("[{}] pane_add_control: config var handle {:#x} is unknown or its type "
@@ -691,7 +689,103 @@ ModResult ui_pane_add_control(
     }
     if (outElem != nullptr) {
         auto& elemSlot = alloc_slot(mod, UiSlotKind::Control, *outElem);
-        track_element(elemSlot, *control->root());
+        track_element(*outElem, elemSlot, *control->root());
+    }
+    return MOD_OK;
+}
+
+ModResult ui_pane_add_list(LoadedMod& mod, uint64_t pane, const UiListDesc& desc,
+    std::vector<ui::List::Item> items, uint64_t& outHandle) {
+    outHandle = 0;
+    auto* paneSlot = resolve(mod, pane, UiSlotKind::Pane, "pane_add_list");
+    if (paneSlot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* paneComponent = paneSlot->pane;
+
+    uint64_t handle = 0;
+    alloc_slot(mod, UiSlotKind::List, handle);
+
+    ui::List::Props props;
+    props.items = std::move(items);
+    props.onPressed = [modPtr = &mod, handle, fn = desc.on_pressed, userData = desc.user_data](
+                          uint64_t key) {
+        if (!slot_live(handle)) {
+            return;
+        }
+        guarded_call(*modPtr, "list on_pressed callback",
+            [&] { fn(modPtr->context.get(), handle, key, userData); });
+    };
+    if (desc.is_selected != nullptr) {
+        props.isSelected = [modPtr = &mod, handle, fn = desc.is_selected,
+                               userData = desc.user_data](uint64_t key) {
+            if (!slot_live(handle)) {
+                return false;
+            }
+            return guarded_call(*modPtr, "list is_selected callback", false,
+                [&] { return fn(modPtr->context.get(), handle, key, userData); });
+        };
+    }
+    if (desc.is_disabled != nullptr) {
+        props.isDisabled = [modPtr = &mod, handle, fn = desc.is_disabled,
+                               userData = desc.user_data](uint64_t key) {
+            if (!slot_live(handle)) {
+                return false;
+            }
+            return guarded_call(*modPtr, "list is_disabled callback", false,
+                [&] { return fn(modPtr->context.get(), handle, key, userData); });
+        };
+    }
+
+    auto& list = paneComponent->add_child<ui::List>(std::move(props));
+    auto* listSlot = slot_from_handle(handle);
+    if (listSlot == nullptr) {
+        return MOD_ERROR;
+    }
+    listSlot->list = &list;
+    track_element(handle, *listSlot, *list.root());
+    outHandle = handle;
+    return MOD_OK;
+}
+
+ModResult ui_list_set_items(LoadedMod& mod, uint64_t handle, std::vector<ui::List::Item> items) {
+    auto* slot = resolve(mod, handle, UiSlotKind::List, "list_set_items");
+    if (slot == nullptr || slot->list == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    slot->list->set_items(std::move(items));
+    return MOD_OK;
+}
+
+ModResult ui_pane_add_group(LoadedMod& mod, uint64_t groupPaneHandle, uint64_t targetPaneHandle,
+    const UiGroupDesc& desc, uint64_t* outElem) {
+    auto* groupSlot = resolve(mod, groupPaneHandle, UiSlotKind::Pane, "pane_add_group");
+    auto* targetSlot = resolve(mod, targetPaneHandle, UiSlotKind::Pane, "pane_add_group");
+    if (groupSlot == nullptr || targetSlot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (groupSlot->helpPane != targetSlot->pane) {
+        Log.error("[{}] pane_add_group: panes are not a paired tab layout", mod.metadata.id);
+        return MOD_UNSUPPORTED;
+    }
+
+    auto* groupPane = groupSlot->pane;
+    auto* targetPane = targetSlot->pane;
+    auto& button = groupPane->add_group_button(ui::GroupButton::Props{.text = desc.label});
+    groupPane->register_control(button, *targetPane,
+        [modPtr = &mod, groupPaneHandle, targetPaneHandle, build = desc.build,
+            userData = desc.user_data](ui::Pane&) {
+            if (!slot_live(groupPaneHandle) || !slot_live(targetPaneHandle) || !modPtr->active) {
+                return;
+            }
+            invoke_mod_ui_callback(*modPtr, "mod UI group build", [&](ModError* error) {
+                return build(modPtr->context.get(), targetPaneHandle, userData, error);
+            });
+        });
+
+    if (outElem != nullptr) {
+        auto& elemSlot = alloc_slot(mod, UiSlotKind::Control, *outElem);
+        track_element(*outElem, elemSlot, *button.root());
     }
     return MOD_OK;
 }
@@ -701,13 +795,13 @@ ModResult ui_elem_set_text(LoadedMod& mod, uint64_t elem, const char* text) {
     if (slot == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    const std::string rml = ui::escape(text);
-    if (slot->hasElementValue && slot->elementRml == rml) {
+    if (slot->hasElementValue && !slot->elementValueIsRml && slot->elementValue == text) {
         return MOD_OK;
     }
-    slot->elementRml = rml;
+    slot->elementValue = text;
     slot->hasElementValue = true;
-    slot->element->SetInnerRML(slot->elementRml);
+    slot->elementValueIsRml = false;
+    ui::set_text_content(slot->element, slot->elementValue);
     return MOD_OK;
 }
 
@@ -716,11 +810,12 @@ ModResult ui_elem_set_rml(LoadedMod& mod, uint64_t elem, const char* rml) {
     if (slot == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    if (slot->hasElementValue && slot->elementRml == rml) {
+    if (slot->hasElementValue && slot->elementValueIsRml && slot->elementValue == rml) {
         return MOD_OK;
     }
-    slot->elementRml = rml;
+    slot->elementValue = rml;
     slot->hasElementValue = true;
+    slot->elementValueIsRml = true;
     slot->element->SetInnerRML(rml);
     return MOD_OK;
 }
@@ -740,13 +835,13 @@ ModResult ui_elem_set_progress(LoadedMod& mod, uint64_t elem, float value) {
 }
 
 ModResult ui_elem_set_class(LoadedMod& mod, uint64_t elem, const char* name, bool active) {
-    auto* slot = slot_from_handle(elem);
-    if (slot == nullptr || slot->owner != &mod || slot->element == nullptr) {
+    auto* entry = s_slots.find_owned(elem, mod);
+    if (entry == nullptr || entry->value.element == nullptr) {
         Log.error(
             "[{}] elem_set_class: stale or invalid element handle {:#x}", mod.metadata.id, elem);
         return MOD_INVALID_ARGUMENT;
     }
-    slot->element->SetClass(name, active);
+    entry->value.element->SetClass(name, active);
     return MOD_OK;
 }
 
@@ -819,7 +914,7 @@ ModResult ui_window_close(LoadedMod& mod, uint64_t handle) {
     if (slot == nullptr || slot->document == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    slot->document->hide(true);
+    slot->document->pop();
     return MOD_OK;
 }
 
@@ -844,7 +939,7 @@ ModResult ui_dialog_push(LoadedMod& mod, const UiDialogDesc& desc, uint64_t& out
     default:
         break;
     }
-    props.title = ui::escape(desc.title);
+    props.title = desc.title;
     props.bodyRml = desc.body_rml;
     props.icon = desc.icon != nullptr ? desc.icon : defaultIcon;
     props.onDismiss = [modPtr = &mod, handle, fn = desc.on_dismiss, userData = desc.user_data](
@@ -853,20 +948,32 @@ ModResult ui_dialog_push(LoadedMod& mod, const UiDialogDesc& desc, uint64_t& out
             return;  // already being torn down
         }
         if (fn != nullptr) {
-            guarded_call(*modPtr, "dialog on_dismiss callback", [&] {
-                fn(modPtr->context.get(), handle, userData);
-            });
+            guarded_call(*modPtr, "dialog on_dismiss callback",
+                [&] { fn(modPtr->context.get(), handle, userData); });
         }
         if (dialog_open(handle)) {
             static_cast<ModDialog&>(modal).close();
         }
     };
+    auto* actionData = reinterpret_cast<const std::byte*>(desc.actions);
     for (size_t i = 0; i < desc.action_count; ++i) {
-        props.actions.push_back(make_dialog_action(mod, handle, desc.actions[i]));
+        const auto& action = *reinterpret_cast<const UiDialogAction*>(actionData);
+        props.actions.push_back(make_dialog_action(mod, handle, action));
+        actionData += action.struct_size;
     }
 
-    auto dialog =
-        std::make_unique<ModDialog>(std::move(props), [handle] { on_mod_dialog_destroyed(handle); });
+    auto dialog = std::make_unique<ModDialog>(
+        std::move(props), [handle] { on_mod_dialog_destroyed(handle); });
+    if (desc.build != nullptr) {
+        auto& pane = dialog->content_pane();
+        const uint64_t paneHandle = wrap_pane(mod, pane, nullptr);
+        invoke_mod_ui_callback(mod, "mod UI dialog build", [&](ModError* error) {
+            return desc.build(mod.context.get(), paneHandle, desc.user_data, error);
+        });
+        if (!mod.active) {
+            return MOD_ERROR;
+        }
+    }
     if (auto* slot = slot_from_handle(handle)) {
         slot->document = dialog.get();
     }
@@ -903,15 +1010,6 @@ ModResult ui_dialog_set_icon(LoadedMod& mod, uint64_t handle, const char* icon)
     return MOD_OK;
 }
 
-ModResult ui_dialog_add_action(LoadedMod& mod, uint64_t handle, const UiDialogAction& action) {
-    auto* slot = resolve(mod, handle, UiSlotKind::Dialog, "dialog_add_action");
-    if (slot == nullptr || slot->document == nullptr) {
-        return MOD_INVALID_ARGUMENT;
-    }
-    static_cast<ModDialog*>(slot->document)->add_action(make_dialog_action(mod, handle, action));
-    return MOD_OK;
-}
-
 ModResult ui_register_menu_tab(LoadedMod& mod, const UiMenuTabDesc& desc, uint64_t& outHandle) {
     outHandle = 0;
     for (const auto& [owner, tabs] : s_modMenuTabs) {
@@ -945,7 +1043,7 @@ ModResult ui_unregister_menu_tab(LoadedMod& mod, uint64_t handle) {
             s_modMenuTabs.erase(it);
         }
     }
-    free_slot(*slot);
+    s_slots.erase_owned(handle, mod);
     s_menuTabsDirty = true;
     return MOD_OK;
 }
@@ -970,9 +1068,8 @@ std::vector<ModMenuTabEntry> ui_mod_menu_tabs() {
                     if (!slot_live(handle) || !modPtr->active) {
                         return;  // registered by a since-unloaded mod image
                     }
-                    guarded_call(*modPtr, "menu tab on_selected callback", [&] {
-                        fn(modPtr->context.get(), userData);
-                    });
+                    guarded_call(*modPtr, "menu tab on_selected callback",
+                        [&] { fn(modPtr->context.get(), userData); });
                 }});
         }
     }
@@ -985,7 +1082,7 @@ void ui_sync_menu_tabs() {
     }
     s_menuTabsDirty = false;
     if (aurora::rmlui::is_initialized()) {
-        ui::MenuBar::rebuild();
+        ui::MenuBar::refresh_tabs();
     }
 }
 
@@ -1026,7 +1123,7 @@ ModResult ui_register_styles(
     slot.styleId = fmt::format("{}:{:x}", mod.metadata.id, handle);
     if (!ui::register_scoped_styles(docScope, slot.styleId, rcss)) {
         Log.error("[{}] register_styles: failed to parse RCSS", mod.metadata.id);
-        free_slot(slot);
+        s_slots.erase(handle);
         return MOD_INVALID_ARGUMENT;
     }
     outHandle = handle;
@@ -1056,8 +1153,8 @@ ModResult ui_unregister_styles(LoadedMod& mod, uint64_t handle) {
     if (slot == nullptr) {
         return MOD_INVALID_ARGUMENT;
     }
-    ui::unregister_scoped_styles(slot->styleScope, slot->styleId);
-    free_slot(*slot);
+    auto released = s_slots.take_owned(handle, mod);
+    ui::unregister_scoped_styles(released->value.styleScope, released->value.styleId);
     return MOD_OK;
 }
 
@@ -1066,36 +1163,75 @@ void ui_remove_mod(LoadedMod& mod) {
     if (s_modMenuTabs.erase(&mod) != 0) {
         s_menuTabsDirty = true;
     }
-    for (auto& slot : s_slots) {
-        if (slot.kind == UiSlotKind::Free || slot.owner != &mod) {
-            continue;
-        }
+    bool restoreCoveredDocument = false;
+    auto entries = s_slots.take_all(mod);
+    for (auto& entry : entries) {
+        auto& slot = entry.value;
         switch (slot.kind) {
         case UiSlotKind::Window: {
             auto* window = static_cast<ui::ModWindow*>(slot.document);
-            free_slot(slot);
             if (window != nullptr) {
-                window->force_close();
+                restoreCoveredDocument |= ui::top_document() == window;
+                window->force_hide(true);
             }
             break;
         }
         case UiSlotKind::Dialog: {
             auto* dialog = static_cast<ModDialog*>(slot.document);
-            free_slot(slot);
             if (dialog != nullptr) {
-                dialog->force_close();
+                restoreCoveredDocument |= ui::top_document() == dialog;
+                dialog->force_hide(true);
             }
             break;
         }
         case UiSlotKind::Style:
             ui::unregister_scoped_styles(slot.styleScope, slot.styleId);
-            free_slot(slot);
             break;
         default:
-            free_slot(slot);
             break;
         }
     }
+    if (restoreCoveredDocument) {
+        ui::uncover_top_document();
+    }
+}
+
+ModResult ui_get_clipboard_text(
+    LoadedMod& mod, char* buffer, size_t bufferSize, size_t* outLength) {
+    if (outLength != nullptr) {
+        *outLength = 0;
+    }
+
+    std::string text;
+    if (SDL_HasClipboardText()) {
+        char* textPtr = SDL_GetClipboardText();
+        text = textPtr != nullptr ? textPtr : "";
+        SDL_free(textPtr);
+        if (text.empty()) {
+            return MOD_ERROR;
+        }
+    }
+
+    if (outLength != nullptr) {
+        *outLength = text.size();
+    }
+
+    if (buffer == nullptr) {
+        return MOD_OK;
+    }
+    if (bufferSize < text.size() + 1) {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    memcpy(buffer, text.c_str(), text.size() + 1);
+    return MOD_OK;
+}
+
+ModResult ui_set_clipboard_text(LoadedMod& mod, const char* text) {
+    if (!SDL_SetClipboardText(text)) {
+        return MOD_ERROR;
+    }
+    return MOD_OK;
 }
 
 }  // namespace dusk::mods::svc::ui_impl
@@ -1105,21 +1241,60 @@ namespace {
 
 // Validation of the tagged control descriptor: required fields per kind/binding. Value
 // translation and cvar wiring live in loader/ui.cpp.
+bool valid_color_preset(const char* value, bool alpha) {
+    const std::string_view text{value};
+    if (text == "rainbow") {
+        return true;
+    }
+    if (text.size() != 6 && (!alpha || text.size() != 8)) {
+        return false;
+    }
+    return std::ranges::all_of(text, [](char c) {
+        return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+    });
+}
+
 bool valid_control_desc(const UiControlDesc& desc) {
-    if (desc.struct_size < sizeof(UiControlDesc) || desc.label == nullptr) {
+    constexpr size_t kLegacyDescSize = offsetof(UiControlDesc, color_presets);
+    constexpr size_t kColorDescSize = offsetof(UiControlDesc, is_selected);
+    if (desc.struct_size < kLegacyDescSize || desc.label == nullptr) {
         return false;
     }
     switch (desc.kind) {
     case UI_CONTROL_BUTTON:
+    case UI_CONTROL_GROUP:
         return desc.on_pressed != nullptr;
     case UI_CONTROL_TOGGLE:
     case UI_CONTROL_NUMBER:
     case UI_CONTROL_STRING:
     case UI_CONTROL_SELECT:
         break;
+    case UI_CONTROL_COLOR:
+        if (desc.struct_size < kColorDescSize) {
+            return false;
+        }
+        break;
+    case UI_CONTROL_FILE_PICKER:
+        if (desc.struct_size < kUiControlFilePickerSize ||
+            (desc.file_filter_count != 0 && desc.file_filters == nullptr))
+        {
+            return false;
+        }
+        for (size_t i = 0; i < desc.file_filter_count; ++i) {
+            if (desc.file_filters[i].name == nullptr || desc.file_filters[i].pattern == nullptr) {
+                return false;
+            }
+        }
+        break;
     default:
         return false;
     }
+    if (desc.kind == UI_CONTROL_STRING && desc.struct_size >= kUiControlStringSetModeSize &&
+        desc.string_set_mode != UI_STRING_SET_ON_COMMIT &&
+        desc.string_set_mode != UI_STRING_SET_ON_CHANGE)
+    {
+        return false;
+    }
     if (desc.kind == UI_CONTROL_SELECT) {
         if (desc.options == nullptr || desc.option_count == 0) {
             return false;
@@ -1130,6 +1305,18 @@ bool valid_control_desc(const UiControlDesc& desc) {
             }
         }
     }
+    if (desc.kind == UI_CONTROL_COLOR && desc.color_preset_count != 0) {
+        if (desc.color_presets == nullptr) {
+            return false;
+        }
+        for (size_t i = 0; i < desc.color_preset_count; ++i) {
+            if (desc.color_presets[i] == nullptr ||
+                !valid_color_preset(desc.color_presets[i], desc.color_alpha))
+            {
+                return false;
+            }
+        }
+    }
     switch (desc.binding) {
     case UI_BINDING_CALLBACKS:
         return desc.get != nullptr && desc.set != nullptr;
@@ -1140,6 +1327,36 @@ bool valid_control_desc(const UiControlDesc& desc) {
     }
 }
 
+bool copy_list_items(
+    const UiListItem* items, size_t itemCount, std::vector<ui::List::Item>& outItems) {
+    if (itemCount != 0 && items == nullptr) {
+        return false;
+    }
+
+    std::vector<ui::List::Item> copy;
+    copy.reserve(itemCount);
+    std::unordered_set<uint64_t> keys;
+    keys.reserve(itemCount);
+    auto cursor = reinterpret_cast<uintptr_t>(items);
+    for (size_t i = 0; i < itemCount; ++i) {
+        const auto* item = reinterpret_cast<const UiListItem*>(cursor);
+        const size_t recordSize = item->struct_size;
+        if (recordSize < kUiListItemV21Size || recordSize % alignof(UiListItem) != 0 ||
+            cursor > std::numeric_limits<uintptr_t>::max() - recordSize)
+        {
+            return false;
+        }
+        if (item->label == nullptr || !keys.insert(item->key).second) {
+            return false;
+        }
+        copy.push_back({.key = item->key, .label = item->label});
+        cursor += recordSize;
+    }
+
+    outItems = std::move(copy);
+    return true;
+}
+
 ModResult ui_register_mods_panel(ModContext* context, const UiModsPanelDesc* desc) {
     auto* mod = mod_from_context(context);
     if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(UiModsPanelDesc) ||
@@ -1206,6 +1423,59 @@ ModResult ui_pane_add_control(ModContext* context, UiElementHandle pane, const U
     return ui_impl::ui_pane_add_control(*mod, pane, *desc, outElem);
 }
 
+ModResult ui_pane_add_list(
+    ModContext* context, UiElementHandle pane, const UiListDesc* desc, UiListHandle* outList) {
+    if (outList != nullptr) {
+        *outList = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || pane == 0 || desc == nullptr || desc->struct_size < kUiListDescV21Size ||
+        desc->on_pressed == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    std::vector<ui::List::Item> items;
+    if ((desc->items != nullptr || desc->item_count > 0) &&
+        !copy_list_items(desc->items, desc->item_count, items))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    uint64_t handle = 0;
+    const ModResult result = ui_impl::ui_pane_add_list(*mod, pane, *desc, std::move(items), handle);
+    if (result == MOD_OK && outList != nullptr) {
+        *outList = handle;
+    }
+    return result;
+}
+
+ModResult ui_list_set_items(
+    ModContext* context, UiListHandle list, const UiListItem* items, size_t itemCount) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || list == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    std::vector<ui::List::Item> copiedItems;
+    if (!copy_list_items(items, itemCount, copiedItems)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return ui_impl::ui_list_set_items(*mod, list, std::move(copiedItems));
+}
+
+ModResult ui_pane_add_group(ModContext* context, UiElementHandle groupPane,
+    UiElementHandle targetPane, const UiGroupDesc* desc, UiElementHandle* outElem) {
+    if (outElem != nullptr) {
+        *outElem = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || groupPane == 0 || targetPane == 0 || desc == nullptr ||
+        desc->struct_size < sizeof(UiGroupDesc) || desc->label == nullptr || desc->build == nullptr)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return ui_impl::ui_pane_add_group(*mod, groupPane, targetPane, *desc, outElem);
+}
+
 ModResult ui_elem_set_text(ModContext* context, UiElementHandle elem, const char* text) {
     auto* mod = mod_from_context(context);
     if (mod == nullptr || elem == 0 || text == nullptr) {
@@ -1282,10 +1552,15 @@ ModResult ui_dialog_push(ModContext* context, const UiDialogDesc* desc, UiDialog
     {
         return MOD_INVALID_ARGUMENT;
     }
+    auto* actionData = reinterpret_cast<const std::byte*>(desc->actions);
     for (size_t i = 0; i < desc->action_count; ++i) {
-        if (desc->actions[i].label == nullptr) {
+        const auto* action = reinterpret_cast<const UiDialogAction*>(actionData);
+        if (action->struct_size < sizeof(UiDialogAction) ||
+            action->struct_size % alignof(UiDialogAction) != 0 || action->label == nullptr)
+        {
             return MOD_INVALID_ARGUMENT;
         }
+        actionData += action->struct_size;
     }
     uint64_t handle = 0;
     const auto result = ui_impl::ui_dialog_push(*mod, *desc, handle);
@@ -1383,6 +1658,27 @@ ModResult ui_unregister_menu_tab(ModContext* context, UiMenuTabHandle tab) {
     return ui_impl::ui_unregister_menu_tab(*mod, tab);
 }
 
+ModResult ui_push_toast(ModContext* context, const UiToastDesc* desc) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(UiToastDesc) ||
+        ((desc->title_rml == nullptr || desc->title_rml[0] == '\0') &&
+            (desc->body_rml == nullptr || desc->body_rml[0] == '\0')))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    constexpr uint32_t kDefaultDurationMs = 5000;
+    const uint32_t durationMs = desc->duration_ms == 0 ? kDefaultDurationMs : desc->duration_ms;
+    ui::push_toast({
+        .type = desc->type != nullptr ? desc->type : "",
+        .title = desc->title_rml != nullptr ? desc->title_rml : "",
+        .content = desc->body_rml != nullptr ? desc->body_rml : "",
+        .duration = std::chrono::milliseconds{durationMs},
+        .modId = mod->metadata.id,
+    });
+    return MOD_OK;
+}
+
 ModResult ui_dialog_set_body(ModContext* context, UiDialogHandle dialog, const char* bodyRml) {
     auto* mod = mod_from_context(context);
     if (mod == nullptr || dialog == 0 || bodyRml == nullptr) {
@@ -1399,17 +1695,73 @@ ModResult ui_dialog_set_icon(ModContext* context, UiDialogHandle dialog, const c
     return ui_impl::ui_dialog_set_icon(*mod, dialog, icon);
 }
 
-ModResult ui_dialog_add_action(
-    ModContext* context, UiDialogHandle dialog, const UiDialogAction* action) {
-    auto* mod = mod_from_context(context);
-    if (mod == nullptr || dialog == 0 || action == nullptr || action->label == nullptr) {
+ModResult ui_get_clipboard_text(
+    ModContext* ctx, char* buffer, size_t bufferSize, size_t* outLength) {
+    auto* mod = mod_from_context(ctx);
+    if (mod == nullptr || (buffer == nullptr && bufferSize != 0)) {
         return MOD_INVALID_ARGUMENT;
     }
-    return ui_impl::ui_dialog_add_action(*mod, dialog, *action);
+
+    return ui_impl::ui_get_clipboard_text(*mod, buffer, bufferSize, outLength);
 }
 
-constexpr UiService s_uiService{
-    .header = SERVICE_HEADER(UiService, UI_SERVICE_MAJOR, UI_SERVICE_MINOR),
+ModResult ui_set_clipboard_text(ModContext* ctx, const char* text) {
+    auto* mod = mod_from_context(ctx);
+    if (mod == nullptr || text == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return ui_impl::ui_set_clipboard_text(*mod, text);
+}
+
+ModResult ui_v1_dialog_push(
+    ModContext* context, const ui_v1::UiDialogDesc* desc, UiDialogHandle* outDialog) {
+    if (outDialog != nullptr) {
+        *outDialog = 0;
+    }
+    constexpr size_t kLegacyDescSize = offsetof(ui_v1::UiDialogDesc, build);
+    if (desc == nullptr || desc->struct_size < kLegacyDescSize || desc->actions == nullptr ||
+        desc->action_count == 0)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    std::vector<UiDialogAction> actions;
+    actions.reserve(desc->action_count);
+    for (size_t i = 0; i < desc->action_count; ++i) {
+        UiDialogAction action = UI_DIALOG_ACTION_INIT;
+        action.label = desc->actions[i].label;
+        action.on_pressed = desc->actions[i].on_pressed;
+        action.user_data = desc->actions[i].user_data;
+        action.keep_open = desc->actions[i].keep_open;
+        actions.push_back(action);
+    }
+
+    UiDialogDesc translated = UI_DIALOG_DESC_INIT;
+    translated.title = desc->title;
+    translated.body_rml = desc->body_rml;
+    translated.variant = desc->variant;
+    translated.icon = desc->icon;
+    translated.actions = actions.data();
+    translated.action_count = actions.size();
+    translated.on_dismiss = desc->on_dismiss;
+    translated.user_data = desc->user_data;
+    translated.build = desc->struct_size >= sizeof(ui_v1::UiDialogDesc) ? desc->build : nullptr;
+    return ui_dialog_push(context, &translated, outDialog);
+}
+
+ModResult ui_v1_dialog_add_action(
+    ModContext* context, UiDialogHandle, const ui_v1::UiDialogAction*) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    log::write(
+        mod->metadata.id, LOG_LEVEL_WARN, "UiService v1 dialog_add_action is no longer supported");
+    return MOD_UNSUPPORTED;
+}
+
+constexpr ui_v1::UiService s_uiService_v1{
+    .header = SERVICE_HEADER(ui_v1::UiService, ui_v1::kMajorVersion, ui_v1::kMinorVersion),
     .register_mods_panel = ui_register_mods_panel,
     .pane_add_section = ui_pane_add_section,
     .pane_add_text = ui_pane_add_text,
@@ -1422,17 +1774,53 @@ constexpr UiService s_uiService{
     .elem_set_class = ui_elem_set_class,
     .window_push = ui_window_push,
     .window_close = ui_window_close,
-    .dialog_push = ui_dialog_push,
+    .dialog_push = ui_v1_dialog_push,
     .dialog_close = ui_dialog_close,
     .dialog_set_body = ui_dialog_set_body,
     .dialog_set_icon = ui_dialog_set_icon,
-    .dialog_add_action = ui_dialog_add_action,
+    .dialog_add_action = ui_v1_dialog_add_action,
     .is_any_document_visible = ui_is_any_document_visible,
     .register_styles = ui_register_styles,
     .register_styles_file = ui_register_styles_file,
     .unregister_styles = ui_unregister_styles,
     .register_menu_tab = ui_register_menu_tab,
     .unregister_menu_tab = ui_unregister_menu_tab,
+    .push_toast = ui_push_toast,
+    .get_clipboard_text = ui_get_clipboard_text,
+    .set_clipboard_text = ui_set_clipboard_text,
+    .pane_add_group = ui_pane_add_group,
+};
+
+constexpr UiService s_uiService{
+    .header = SERVICE_HEADER(UiService, UI_SERVICE_MAJOR, UI_SERVICE_MINOR),
+    .register_mods_panel = ui_register_mods_panel,
+    .pane_add_section = ui_pane_add_section,
+    .pane_add_text = ui_pane_add_text,
+    .pane_add_rml = ui_pane_add_rml,
+    .pane_add_progress = ui_pane_add_progress,
+    .pane_add_control = ui_pane_add_control,
+    .pane_add_group = ui_pane_add_group,
+    .elem_set_text = ui_elem_set_text,
+    .elem_set_rml = ui_elem_set_rml,
+    .elem_set_progress = ui_elem_set_progress,
+    .elem_set_class = ui_elem_set_class,
+    .window_push = ui_window_push,
+    .window_close = ui_window_close,
+    .dialog_push = ui_dialog_push,
+    .dialog_close = ui_dialog_close,
+    .dialog_set_body = ui_dialog_set_body,
+    .dialog_set_icon = ui_dialog_set_icon,
+    .is_any_document_visible = ui_is_any_document_visible,
+    .register_styles = ui_register_styles,
+    .register_styles_file = ui_register_styles_file,
+    .unregister_styles = ui_unregister_styles,
+    .register_menu_tab = ui_register_menu_tab,
+    .unregister_menu_tab = ui_unregister_menu_tab,
+    .push_toast = ui_push_toast,
+    .get_clipboard_text = ui_get_clipboard_text,
+    .set_clipboard_text = ui_set_clipboard_text,
+    .pane_add_list = ui_pane_add_list,
+    .list_set_items = ui_list_set_items,
 };
 
 }  // namespace
@@ -1449,6 +1837,13 @@ std::vector<ModMenuTabEntry> ui_mod_menu_tabs() {
     return ui_impl::ui_mod_menu_tabs();
 }
 
+constinit const ServiceModule g_uiModule_v1{
+    .id = UI_SERVICE_ID,
+    .majorVersion = ui_v1::kMajorVersion,
+    .minorVersion = ui_v1::kMinorVersion,
+    .service = &s_uiService_v1,
+};
+
 constinit const ServiceModule g_uiModule{
     .id = UI_SERVICE_ID,
     .majorVersion = UI_SERVICE_MAJOR,
diff --git a/src/dusk/mods/svc/ui_v1.hpp b/src/dusk/mods/svc/ui_v1.hpp
new file mode 100644
index 0000000000..ef70479f8e
--- /dev/null
+++ b/src/dusk/mods/svc/ui_v1.hpp
@@ -0,0 +1,82 @@
+#pragma once
+
+#include "mods/svc/ui.h"
+
+namespace dusk::mods::svc::ui_v1 {
+
+constexpr uint16_t kMajorVersion = 1;
+constexpr uint16_t kMinorVersion = 5;
+
+struct UiDialogAction {
+    const char* label;
+    UiDialogActionFn on_pressed;
+    void* user_data;
+    bool keep_open;
+};
+
+struct UiDialogDesc {
+    uint32_t struct_size;
+    const char* title;
+    const char* body_rml;
+    UiDialogVariant variant;
+    const char* icon;
+    const UiDialogAction* actions;
+    size_t action_count;
+    UiDialogActionFn on_dismiss;
+    void* user_data;
+    UiPaneBuildFn build;
+};
+
+struct UiService {
+    ServiceHeader header;
+
+    ModResult (*register_mods_panel)(ModContext* ctx, const UiModsPanelDesc* desc);
+    ModResult (*pane_add_section)(ModContext* ctx, UiElementHandle pane, const char* title);
+    ModResult (*pane_add_text)(
+        ModContext* ctx, UiElementHandle pane, const char* text, UiElementHandle* out_elem);
+    ModResult (*pane_add_rml)(
+        ModContext* ctx, UiElementHandle pane, const char* rml, UiElementHandle* out_elem);
+    ModResult (*pane_add_progress)(
+        ModContext* ctx, UiElementHandle pane, float value, UiElementHandle* out_elem);
+    ModResult (*pane_add_control)(ModContext* ctx, UiElementHandle pane, const UiControlDesc* desc,
+        UiElementHandle* out_elem);
+
+    ModResult (*elem_set_text)(ModContext* ctx, UiElementHandle elem, const char* text);
+    ModResult (*elem_set_rml)(ModContext* ctx, UiElementHandle elem, const char* rml);
+    ModResult (*elem_set_progress)(ModContext* ctx, UiElementHandle elem, float value);
+    ModResult (*elem_set_class)(
+        ModContext* ctx, UiElementHandle elem, const char* name, bool active);
+
+    ModResult (*window_push)(ModContext* ctx, const UiWindowDesc* desc, UiWindowHandle* out_window);
+    ModResult (*window_close)(ModContext* ctx, UiWindowHandle window);
+
+    ModResult (*dialog_push)(ModContext* ctx, const UiDialogDesc* desc, UiDialogHandle* out_dialog);
+    ModResult (*dialog_close)(ModContext* ctx, UiDialogHandle dialog);
+    ModResult (*dialog_set_body)(ModContext* ctx, UiDialogHandle dialog, const char* body_rml);
+    ModResult (*dialog_set_icon)(ModContext* ctx, UiDialogHandle dialog, const char* icon);
+    ModResult (*dialog_add_action)(
+        ModContext* ctx, UiDialogHandle dialog, const UiDialogAction* action);
+
+    ModResult (*is_any_document_visible)(ModContext* ctx, bool* out_visible);
+
+    ModResult (*register_styles)(
+        ModContext* ctx, UiStyleScope scope, const char* rcss, UiStyleHandle* out_style);
+    ModResult (*register_styles_file)(
+        ModContext* ctx, UiStyleScope scope, const char* path, UiStyleHandle* out_style);
+    ModResult (*unregister_styles)(ModContext* ctx, UiStyleHandle style);
+
+    ModResult (*register_menu_tab)(
+        ModContext* ctx, const UiMenuTabDesc* desc, UiMenuTabHandle* out_tab);
+    ModResult (*unregister_menu_tab)(ModContext* ctx, UiMenuTabHandle tab);
+
+    ModResult (*push_toast)(ModContext* ctx, const UiToastDesc* desc);
+
+    ModResult (*get_clipboard_text)(
+        ModContext* ctx, char* buffer, size_t bufferSize, size_t* outLength);
+    ModResult (*set_clipboard_text)(ModContext* ctx, const char* text);
+
+    ModResult (*pane_add_group)(ModContext* ctx, UiElementHandle group_pane,
+        UiElementHandle target_pane, const UiGroupDesc* desc, UiElementHandle* out_elem);
+};
+
+}  // namespace dusk::mods::svc::ui_v1
diff --git a/src/dusk/mods/svc/websocket.cpp b/src/dusk/mods/svc/websocket.cpp
new file mode 100644
index 0000000000..a53c388b30
--- /dev/null
+++ b/src/dusk/mods/svc/websocket.cpp
@@ -0,0 +1,393 @@
+#include "registry.hpp"
+
+#include "internal.hpp"
+#include "net.hpp"
+
+#include "dusk/mods/loader/loader.hpp"
+#include "mods/svc/websocket.h"
+
+#include <borealis/url.hpp>
+#include <borealis/ws.hpp>
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr size_t MaxConnectionsPerMod = 4;
+constexpr size_t MaxUrlBytes = 8 * 1024;
+constexpr size_t MaxHeaders = 64;
+constexpr size_t MaxHeaderBytes = 16 * 1024;
+constexpr size_t MaxProtocols = 8;
+constexpr size_t DefaultMessageBytes = 1024 * 1024;
+constexpr size_t MaxMessageBytes = 16 * 1024 * 1024;
+constexpr std::chrono::milliseconds DefaultConnectTimeout{10000};
+constexpr std::chrono::milliseconds DefaultCloseTimeout{5000};
+constexpr std::string_view ReservedHeaders[]{
+    "User-Agent",
+    "Host",
+    "Connection",
+    "Upgrade",
+    "Sec-WebSocket-Key",
+    "Sec-WebSocket-Version",
+    "Sec-WebSocket-Extensions",
+    "Sec-WebSocket-Protocol",
+    "Content-Length",
+};
+
+struct ConnectionState {
+    borealis::ws::Connection connection;
+    void* userData = nullptr;
+    bool openPublished = false;
+};
+
+struct ModPollState {
+    borealis::ws::Event currentEvent;
+    std::vector<HttpHeader> headers;
+    size_t next = 0;
+};
+
+SlotMap<ConnectionState> s_connections;
+PerMod<ModPollState> s_pollStates;
+
+bool valid_url(std::string_view url, bool& allowPlaintext) {
+    allowPlaintext = false;
+    if (url.size() > MaxUrlBytes) {
+        return false;
+    }
+    const auto parsed = borealis::url::parse(url);
+    if (!parsed || (parsed->scheme != "wss" && parsed->scheme != "ws")) {
+        return false;
+    }
+    allowPlaintext = parsed->scheme == "ws";
+    if (!allowPlaintext) {
+        return true;
+    }
+    return parsed->host == "localhost" || parsed->host == "127.0.0.1" || parsed->host == "::1";
+}
+
+WebSocketError map_error(borealis::ws::Error error) {
+    switch (error) {
+    case borealis::ws::Error::None:
+        return WEBSOCKET_ERROR_NONE;
+    case borealis::ws::Error::InvalidUrl:
+        return WEBSOCKET_ERROR_INVALID_URL;
+    case borealis::ws::Error::UnsupportedScheme:
+        return WEBSOCKET_ERROR_UNSUPPORTED_SCHEME;
+    case borealis::ws::Error::Timeout:
+        return WEBSOCKET_ERROR_TIMEOUT;
+    case borealis::ws::Error::TooLarge:
+        return WEBSOCKET_ERROR_TOO_LARGE;
+    case borealis::ws::Error::Canceled:
+        return WEBSOCKET_ERROR_CANCELED;
+    case borealis::ws::Error::Protocol:
+        return WEBSOCKET_ERROR_PROTOCOL;
+    case borealis::ws::Error::Handshake:
+        return WEBSOCKET_ERROR_HANDSHAKE;
+    case borealis::ws::Error::NoBackend:
+    case borealis::ws::Error::Network:
+    default:
+        return WEBSOCKET_ERROR_NETWORK;
+    }
+}
+
+ModResult map_send_result(borealis::ws::SendResult result) {
+    switch (result) {
+    case borealis::ws::SendResult::Ok:
+        return MOD_OK;
+    case borealis::ws::SendResult::NotOpen:
+        return MOD_UNAVAILABLE;
+    case borealis::ws::SendResult::QueueFull:
+        return MOD_CONFLICT;
+    case borealis::ws::SendResult::TooLarge:
+    case borealis::ws::SendResult::InvalidText:
+        return MOD_INVALID_ARGUMENT;
+    }
+    return MOD_ERROR;
+}
+
+ModResult map_close_result(borealis::ws::CloseResult result) {
+    switch (result) {
+    case borealis::ws::CloseResult::Ok:
+        return MOD_OK;
+    case borealis::ws::CloseResult::NotOpen:
+        return MOD_UNAVAILABLE;
+    case borealis::ws::CloseResult::InvalidCode:
+    case borealis::ws::CloseResult::ReasonTooLarge:
+    case borealis::ws::CloseResult::InvalidText:
+        return MOD_INVALID_ARGUMENT;
+    }
+    return MOD_ERROR;
+}
+
+size_t connection_count(const LoadedMod& mod) {
+    size_t count = 0;
+    s_connections.for_each([&](WebSocketHandle, const auto& entry) {
+        if (entry.owner == &mod) {
+            ++count;
+        }
+    });
+    return count;
+}
+
+ModResult websocket_connect(
+    ModContext* context, const WebSocketConnectDesc* desc, WebSocketHandle* outHandle) {
+    if (outHandle != nullptr) {
+        *outHandle = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(WebSocketConnectDesc) ||
+        desc->url == nullptr || outHandle == nullptr ||
+        (desc->header_count != 0 && desc->headers == nullptr) ||
+        (desc->protocol_count != 0 && desc->protocols == nullptr))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (!declares_import(*mod, WEBSOCKET_SERVICE_ID)) {
+        return MOD_UNSUPPORTED;
+    }
+    bool allowPlaintext = false;
+    if (!valid_url(desc->url, allowPlaintext) || desc->header_count > MaxHeaders ||
+        desc->protocol_count > MaxProtocols || desc->max_message_bytes > MaxMessageBytes)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    size_t headerBytes = 0;
+    for (uint32_t index = 0; index < desc->header_count; ++index) {
+        const HttpHeader& header = desc->headers[index];
+        if (header.name == nullptr || header.value == nullptr) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        const std::string_view name{header.name};
+        const std::string_view value{header.value};
+        if (!valid_header(name, value, ReservedHeaders) ||
+            name.size() > MaxHeaderBytes - std::min(headerBytes, MaxHeaderBytes))
+        {
+            return MOD_INVALID_ARGUMENT;
+        }
+        headerBytes += name.size();
+        if (value.size() > MaxHeaderBytes - std::min(headerBytes, MaxHeaderBytes)) {
+            return MOD_INVALID_ARGUMENT;
+        }
+        headerBytes += value.size();
+    }
+    for (uint32_t index = 0; index < desc->protocol_count; ++index) {
+        if (desc->protocols[index] == nullptr || !valid_header_name(desc->protocols[index])) {
+            return MOD_INVALID_ARGUMENT;
+        }
+    }
+    if (!borealis::ws::available()) {
+        return MOD_UNAVAILABLE;
+    }
+    if (connection_count(*mod) >= MaxConnectionsPerMod) {
+        return MOD_CONFLICT;
+    }
+
+    const size_t maxMessageBytes =
+        desc->max_message_bytes != 0 ? desc->max_message_bytes : DefaultMessageBytes;
+    borealis::ws::Options options{
+        .url = desc->url,
+        .connectTimeout = desc->connect_timeout_ms != 0 ?
+                              std::chrono::milliseconds{desc->connect_timeout_ms} :
+                              DefaultConnectTimeout,
+        .closeTimeout = desc->close_timeout_ms != 0 ?
+                            std::chrono::milliseconds{desc->close_timeout_ms} :
+                            DefaultCloseTimeout,
+        .keepaliveInterval = std::chrono::milliseconds{desc->keepalive_interval_ms},
+        .maxMessageBytes = maxMessageBytes,
+        .maxQueuedBytes = 16 * 1024 * 1024,
+        .maxSendQueueBytes = 4 * 1024 * 1024,
+        .allowPlaintext = allowPlaintext,
+    };
+    options.headers.reserve(desc->header_count + 1);
+    for (uint32_t index = 0; index < desc->header_count; ++index) {
+        options.headers.push_back({desc->headers[index].name, desc->headers[index].value});
+    }
+    options.headers.push_back({
+        .name = "User-Agent",
+        .value = user_agent(*mod),
+    });
+    options.protocols.reserve(desc->protocol_count);
+    for (uint32_t index = 0; index < desc->protocol_count; ++index) {
+        options.protocols.emplace_back(desc->protocols[index]);
+    }
+    auto connection = borealis::ws::connect(std::move(options));
+    if (!connection) {
+        return MOD_UNAVAILABLE;
+    }
+    *outHandle = s_connections.emplace(*mod, ConnectionState{
+                                                 .connection = std::move(connection),
+                                                 .userData = desc->user_data,
+                                             });
+    return MOD_OK;
+}
+
+ModResult websocket_poll_event(ModContext* context, WebSocketEvent* outEvent) {
+    const uint32_t structSize = outEvent != nullptr ? outEvent->struct_size : 0;
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || outEvent == nullptr || structSize < sizeof(WebSocketEvent)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    WebSocketEvent output{
+        .struct_size = structSize,
+        .protocol = "",
+        .error_message = "",
+        .close_reason = "",
+    };
+
+    std::vector<WebSocketHandle> handles;
+    s_connections.for_each([&](WebSocketHandle handle, const auto& entry) {
+        if (entry.owner == mod) {
+            handles.push_back(handle);
+        }
+    });
+    auto& pollState = s_pollStates.get_or_create(*mod);
+    if (handles.empty()) {
+        pollState.next = 0;
+        std::memcpy(outEvent, &output, sizeof(output));
+        return MOD_OK;
+    }
+
+    const size_t start = pollState.next % handles.size();
+    WebSocketHandle selected = 0;
+    ConnectionState* selectedState = nullptr;
+    for (size_t offset = 0; offset < handles.size(); ++offset) {
+        const size_t index = (start + offset) % handles.size();
+        auto* entry = s_connections.find_owned(handles[index], *mod);
+        if (entry != nullptr && entry->value.connection.poll(pollState.currentEvent)) {
+            selected = handles[index];
+            selectedState = &entry->value;
+            pollState.next = index + 1;
+            break;
+        }
+    }
+    if (selectedState == nullptr) {
+        std::memcpy(outEvent, &output, sizeof(output));
+        return MOD_OK;
+    }
+
+    output.ws = selected;
+    output.user_data = selectedState->userData;
+    const auto& event = pollState.currentEvent;
+    pollState.headers.clear();
+    pollState.headers.reserve(event.headers.size());
+    for (const auto& header : event.headers) {
+        pollState.headers.push_back({header.name.c_str(), header.value.c_str()});
+    }
+    output.headers = pollState.headers.data();
+    output.header_count = static_cast<uint32_t>(pollState.headers.size());
+    if (event.kind == borealis::ws::Event::Kind::Open) {
+        output.type = WEBSOCKET_EVENT_OPEN;
+        output.protocol = event.protocol.c_str();
+        selectedState->openPublished = true;
+    } else if (event.kind == borealis::ws::Event::Kind::Message) {
+        output.type = WEBSOCKET_EVENT_MESSAGE;
+        output.message_kind = event.messageKind == borealis::ws::MessageKind::Text ?
+                                  WEBSOCKET_MESSAGE_TEXT :
+                                  WEBSOCKET_MESSAGE_BINARY;
+        output.data = event.data.data();
+        output.size = event.data.size();
+    } else {
+        output.type = WEBSOCKET_EVENT_CLOSED;
+        output.error = map_error(event.error);
+        output.error_message = event.message.c_str();
+        output.handshake_status = event.status;
+        output.close_code = event.code;
+        output.close_reason = event.reason.c_str();
+    }
+
+    std::memcpy(outEvent, &output, sizeof(output));
+    if (event.kind == borealis::ws::Event::Kind::Closed) {
+        s_connections.erase(selected);
+    }
+    return MOD_OK;
+}
+
+ModResult websocket_send(ModContext* context, WebSocketHandle handle, WebSocketMessageKind kind,
+    const void* data, size_t size) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || (size != 0 && data == nullptr) ||
+        (kind != WEBSOCKET_MESSAGE_TEXT && kind != WEBSOCKET_MESSAGE_BINARY))
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* entry = s_connections.find_owned(handle, *mod);
+    if (entry == nullptr || !entry->value.openPublished) {
+        return MOD_UNAVAILABLE;
+    }
+    const std::string_view bytes = data != nullptr ?
+                                       std::string_view{static_cast<const char*>(data), size} :
+                                       std::string_view{};
+    return map_send_result(entry->value.connection.send(kind == WEBSOCKET_MESSAGE_TEXT ?
+                                                            borealis::ws::MessageKind::Text :
+                                                            borealis::ws::MessageKind::Binary,
+        bytes));
+}
+
+ModResult websocket_close(
+    ModContext* context, WebSocketHandle handle, uint16_t code, const char* reason) {
+    auto* mod = mod_from_context(context);
+    const std::string_view reasonText =
+        reason != nullptr ? std::string_view{reason} : std::string_view{};
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* entry = s_connections.find_owned(handle, *mod);
+    if (entry == nullptr) {
+        return MOD_UNAVAILABLE;
+    }
+    return map_close_result(entry->value.connection.close(code != 0 ? code : 1000, reasonText));
+}
+
+void websocket_mod_deactivating(LoadedMod& mod) {
+    (void)s_connections.take_all(mod);
+    s_pollStates.erase(mod);
+}
+
+void websocket_mod_detached(LoadedMod& mod) {
+    bool found = false;
+    s_connections.for_each(
+        [&](WebSocketHandle, const auto& entry) { found = found || entry.owner == &mod; });
+    assert(!found);
+    assert(!s_pollStates.contains(mod));
+}
+
+void websocket_shutdown() {
+    s_connections = {};
+    s_pollStates.clear();
+}
+
+bool websocket_available() {
+    return borealis::ws::available();
+}
+
+constexpr WebSocketService s_websocketService{
+    .header = SERVICE_HEADER(WebSocketService, WEBSOCKET_SERVICE_MAJOR, WEBSOCKET_SERVICE_MINOR),
+    .connect = SERVICE_FUNCTION(websocket_connect),
+    .poll_event = SERVICE_FUNCTION(websocket_poll_event),
+    .send = SERVICE_FUNCTION(websocket_send),
+    .close = SERVICE_FUNCTION(websocket_close),
+};
+
+}  // namespace
+
+constinit const ServiceModule g_websocketModule{
+    .id = WEBSOCKET_SERVICE_ID,
+    .majorVersion = WEBSOCKET_SERVICE_MAJOR,
+    .minorVersion = WEBSOCKET_SERVICE_MINOR,
+    .service = &s_websocketService,
+    .available = websocket_available,
+    .modDeactivating = websocket_mod_deactivating,
+    .modDetached = websocket_mod_detached,
+    .shutdown = websocket_shutdown,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/window.cpp b/src/dusk/mods/svc/window.cpp
new file mode 100644
index 0000000000..5e61c43033
--- /dev/null
+++ b/src/dusk/mods/svc/window.cpp
@@ -0,0 +1,352 @@
+#include "window.hpp"
+
+#include "internal.hpp"
+#include "registry.hpp"
+
+#include <borealis/log.hpp>
+#include "dusk/mods/loader/loader.hpp"
+
+#include <SDL3/SDL_error.h>
+#include <SDL3/SDL_events.h>
+#include <SDL3/SDL_properties.h>
+#include <SDL3/SDL_video.h>
+#include <fmt/format.h>
+
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+
+namespace dusk::mods::svc {
+namespace {
+
+constexpr borealis::Log Log{"dusk::mods::window"};
+
+struct WindowSlot {
+    SDL_Window* window = nullptr;
+    SDL_WindowID windowId = 0;
+    WindowEventFn onEvent = nullptr;
+    void* userData = nullptr;
+    uint32_t graphicsRefs = 0;
+};
+
+SlotMap<WindowSlot> s_windows;
+std::unordered_map<SDL_WindowID, WindowHandle> s_windowsById;
+
+WindowSlot* resolve_window(LoadedMod& mod, WindowHandle handle) {
+    auto* entry = s_windows.find_owned(handle, mod);
+    return entry != nullptr ? &entry->value : nullptr;
+}
+
+bool populate_info(SDL_Window* window, WindowInfo& info) {
+    int x = 0;
+    int y = 0;
+    int width = 0;
+    int height = 0;
+    int pixelWidth = 0;
+    int pixelHeight = 0;
+    if (!SDL_GetWindowPosition(window, &x, &y) || !SDL_GetWindowSize(window, &width, &height) ||
+        !SDL_GetWindowSizeInPixels(window, &pixelWidth, &pixelHeight))
+    {
+        return false;
+    }
+    const auto flags = SDL_GetWindowFlags(window);
+    info.x = x;
+    info.y = y;
+    info.width = static_cast<uint32_t>(width);
+    info.height = static_cast<uint32_t>(height);
+    info.pixel_width = static_cast<uint32_t>(pixelWidth);
+    info.pixel_height = static_cast<uint32_t>(pixelHeight);
+    info.display_scale = SDL_GetWindowDisplayScale(window);
+    info.visible = (flags & SDL_WINDOW_HIDDEN) == 0u;
+    info.focused = (flags & SDL_WINDOW_INPUT_FOCUS) != 0u;
+    return true;
+}
+
+ModResult create_window_impl(ModContext* context, const WindowDesc* desc, WindowHandle* outWindow) {
+    if (outWindow != nullptr) {
+        *outWindow = 0;
+    }
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr || desc == nullptr || desc->struct_size < sizeof(WindowDesc) ||
+        outWindow == nullptr || desc->width == 0 || desc->height == 0)
+    {
+        return MOD_INVALID_ARGUMENT;
+    }
+
+    SDL_WindowFlags flags = SDL_WINDOW_HIGH_PIXEL_DENSITY;
+    if ((desc->flags & WINDOW_FLAG_RESIZABLE) != 0u) {
+        flags |= SDL_WINDOW_RESIZABLE;
+    }
+    if ((desc->flags & WINDOW_FLAG_HIDDEN) != 0u) {
+        flags |= SDL_WINDOW_HIDDEN;
+    }
+    if ((desc->flags & WINDOW_FLAG_BORDERLESS) != 0u) {
+        flags |= SDL_WINDOW_BORDERLESS;
+    }
+    if ((desc->flags & WINDOW_FLAG_ALWAYS_ON_TOP) != 0u) {
+        flags |= SDL_WINDOW_ALWAYS_ON_TOP;
+    }
+    if ((desc->flags & WINDOW_FLAG_TRANSPARENT) != 0u) {
+        flags |= SDL_WINDOW_TRANSPARENT;
+    }
+
+    const auto properties = SDL_CreateProperties();
+    if (properties == 0) {
+        Log.error("[{}] create_window: {}", mod->metadata.id, SDL_GetError());
+        return MOD_ERROR;
+    }
+
+    const char* title = desc->title != nullptr ? desc->title : mod->metadata.name.c_str();
+    const auto x = desc->x == WINDOW_POSITION_UNDEFINED ? SDL_WINDOWPOS_UNDEFINED : desc->x;
+    const auto y = desc->y == WINDOW_POSITION_UNDEFINED ? SDL_WINDOWPOS_UNDEFINED : desc->y;
+    const bool propertiesSet =
+        SDL_SetStringProperty(properties, SDL_PROP_WINDOW_CREATE_TITLE_STRING, title) &&
+        SDL_SetNumberProperty(properties, SDL_PROP_WINDOW_CREATE_X_NUMBER, x) &&
+        SDL_SetNumberProperty(properties, SDL_PROP_WINDOW_CREATE_Y_NUMBER, y) &&
+        SDL_SetNumberProperty(properties, SDL_PROP_WINDOW_CREATE_WIDTH_NUMBER, desc->width) &&
+        SDL_SetNumberProperty(properties, SDL_PROP_WINDOW_CREATE_HEIGHT_NUMBER, desc->height) &&
+        SDL_SetNumberProperty(properties, SDL_PROP_WINDOW_CREATE_FLAGS_NUMBER, flags) &&
+        SDL_SetBooleanProperty(
+            properties, SDL_PROP_WINDOW_CREATE_EXTERNAL_GRAPHICS_CONTEXT_BOOLEAN, true);
+    if (!propertiesSet) {
+        Log.error("[{}] create_window: {}", mod->metadata.id, SDL_GetError());
+        SDL_DestroyProperties(properties);
+        return MOD_ERROR;
+    }
+
+    SDL_Window* window = SDL_CreateWindowWithProperties(properties);
+    SDL_DestroyProperties(properties);
+    if (window == nullptr) {
+        Log.error("[{}] create_window: {}", mod->metadata.id, SDL_GetError());
+        return MOD_ERROR;
+    }
+
+    const auto windowId = SDL_GetWindowID(window);
+    const auto handle = s_windows.emplace(*mod, WindowSlot{
+                                                    .window = window,
+                                                    .windowId = windowId,
+                                                    .onEvent = desc->on_event,
+                                                    .userData = desc->user_data,
+                                                });
+    s_windowsById.emplace(windowId, handle);
+    *outWindow = handle;
+    return MOD_OK;
+}
+
+ModResult destroy_window_impl(ModContext* context, WindowHandle handle) {
+    auto* mod = mod_from_context(context);
+    if (mod == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    auto* slot = resolve_window(*mod, handle);
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (slot->graphicsRefs != 0) {
+        return MOD_CONFLICT;
+    }
+    const auto windowId = slot->windowId;
+    SDL_Window* window = slot->window;
+    s_windowsById.erase(windowId);
+    s_windows.erase_owned(handle, *mod);
+    SDL_DestroyWindow(window);
+    return MOD_OK;
+}
+
+ModResult show_window_impl(ModContext* context, WindowHandle handle) {
+    auto* mod = mod_from_context(context);
+    auto* slot = mod != nullptr ? resolve_window(*mod, handle) : nullptr;
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return SDL_ShowWindow(slot->window) ? MOD_OK : MOD_ERROR;
+}
+
+ModResult hide_window_impl(ModContext* context, WindowHandle handle) {
+    auto* mod = mod_from_context(context);
+    auto* slot = mod != nullptr ? resolve_window(*mod, handle) : nullptr;
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return SDL_HideWindow(slot->window) ? MOD_OK : MOD_ERROR;
+}
+
+ModResult set_title_impl(ModContext* context, WindowHandle handle, const char* title) {
+    auto* mod = mod_from_context(context);
+    auto* slot = mod != nullptr ? resolve_window(*mod, handle) : nullptr;
+    if (slot == nullptr || title == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return SDL_SetWindowTitle(slot->window, title) ? MOD_OK : MOD_ERROR;
+}
+
+ModResult set_size_impl(ModContext* context, WindowHandle handle, uint32_t width, uint32_t height) {
+    auto* mod = mod_from_context(context);
+    auto* slot = mod != nullptr ? resolve_window(*mod, handle) : nullptr;
+    if (slot == nullptr || width == 0 || height == 0) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return SDL_SetWindowSize(slot->window, static_cast<int>(width), static_cast<int>(height)) ?
+               MOD_OK :
+               MOD_ERROR;
+}
+
+ModResult get_info_impl(ModContext* context, WindowHandle handle, WindowInfo* outInfo) {
+    if (outInfo == nullptr || outInfo->struct_size < sizeof(WindowInfo)) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    const uint32_t structSize = outInfo->struct_size;
+    *outInfo = WindowInfo{.struct_size = structSize};
+    auto* mod = mod_from_context(context);
+    auto* slot = mod != nullptr ? resolve_window(*mod, handle) : nullptr;
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    return populate_info(slot->window, *outInfo) ? MOD_OK : MOD_ERROR;
+}
+
+void remove_mod_windows(LoadedMod& mod) {
+    auto entries = s_windows.take_all(mod);
+    for (auto& entry : entries) {
+        s_windowsById.erase(entry.value.windowId);
+        SDL_DestroyWindow(entry.value.window);
+    }
+}
+
+constexpr WindowService s_windowService{
+    .header = SERVICE_HEADER(WindowService, WINDOW_SERVICE_MAJOR, WINDOW_SERVICE_MINOR),
+    .create_window = create_window_impl,
+    .destroy_window = destroy_window_impl,
+    .show_window = show_window_impl,
+    .hide_window = hide_window_impl,
+    .set_title = set_title_impl,
+    .set_size = set_size_impl,
+    .get_info = get_info_impl,
+};
+
+}  // namespace
+
+bool window_dispatch_event(const SDL_Event& event) {
+    SDL_Window* eventWindow = SDL_GetWindowFromEvent(&event);
+    if (eventWindow == nullptr) {
+        return false;
+    }
+    const auto it = s_windowsById.find(SDL_GetWindowID(eventWindow));
+    if (it == s_windowsById.end()) {
+        return false;
+    }
+    const auto handle = it->second;
+    const auto* entry = s_windows.find(handle);
+    if (entry == nullptr) {
+        return true;
+    }
+
+    WindowEventType type;
+    bool exposed = true;
+    switch (event.type) {
+    case SDL_EVENT_WINDOW_CLOSE_REQUESTED:
+        type = WINDOW_EVENT_CLOSE_REQUESTED;
+        break;
+    case SDL_EVENT_WINDOW_RESIZED:
+    case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
+    case SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED:
+        type = WINDOW_EVENT_RESIZED;
+        break;
+    case SDL_EVENT_WINDOW_MOVED:
+        type = WINDOW_EVENT_MOVED;
+        break;
+    case SDL_EVENT_WINDOW_FOCUS_GAINED:
+        type = WINDOW_EVENT_FOCUS_GAINED;
+        break;
+    case SDL_EVENT_WINDOW_FOCUS_LOST:
+        type = WINDOW_EVENT_FOCUS_LOST;
+        break;
+    case SDL_EVENT_WINDOW_SHOWN:
+        type = WINDOW_EVENT_SHOWN;
+        break;
+    case SDL_EVENT_WINDOW_HIDDEN:
+        type = WINDOW_EVENT_HIDDEN;
+        break;
+    default:
+        exposed = false;
+        break;
+    }
+    if (!exposed || entry->value.onEvent == nullptr || !entry->owner->active) {
+        return true;
+    }
+
+    WindowInfo info = WINDOW_INFO_INIT;
+    populate_info(entry->value.window, info);
+    const WindowEvent windowEvent{
+        .struct_size = sizeof(WindowEvent),
+        .type = type,
+        .x = info.x,
+        .y = info.y,
+        .width = info.width,
+        .height = info.height,
+        .pixel_width = info.pixel_width,
+        .pixel_height = info.pixel_height,
+        .display_scale = info.display_scale,
+    };
+    auto* owner = entry->owner;
+    const auto callback = entry->value.onEvent;
+    void* userData = entry->value.userData;
+    try {
+        callback(owner->context.get(), handle, &windowEvent, userData);
+    } catch (const std::exception& e) {
+        fail_mod(
+            *owner, MOD_ERROR, fmt::format("Exception in window event callback: {}", e.what()));
+    } catch (...) {
+        fail_mod(*owner, MOD_ERROR, "Unknown exception in window event callback");
+    }
+    return true;
+}
+
+ModResult window_acquire_for_graphics(
+    LoadedMod& mod, WindowHandle handle, SDL_Window*& outWindow) {
+    outWindow = nullptr;
+    auto* slot = resolve_window(mod, handle);
+    if (slot == nullptr) {
+        return MOD_INVALID_ARGUMENT;
+    }
+    if (slot->graphicsRefs != 0) {
+        return MOD_CONFLICT;
+    }
+    ++slot->graphicsRefs;
+    outWindow = slot->window;
+    return MOD_OK;
+}
+
+void window_release_for_graphics(LoadedMod& mod, WindowHandle handle) {
+    auto* slot = resolve_window(mod, handle);
+    if (slot != nullptr && slot->graphicsRefs > 0) {
+        --slot->graphicsRefs;
+    }
+}
+
+bool window_get_pixel_size(LoadedMod& mod, WindowHandle handle, uint32_t& width, uint32_t& height) {
+    auto* slot = resolve_window(mod, handle);
+    if (slot == nullptr) {
+        return false;
+    }
+    int pixelWidth = 0;
+    int pixelHeight = 0;
+    if (!SDL_GetWindowSizeInPixels(slot->window, &pixelWidth, &pixelHeight) || pixelWidth <= 0 ||
+        pixelHeight <= 0)
+    {
+        return false;
+    }
+    width = static_cast<uint32_t>(pixelWidth);
+    height = static_cast<uint32_t>(pixelHeight);
+    return true;
+}
+
+constinit const ServiceModule g_windowModule{
+    .id = WINDOW_SERVICE_ID,
+    .majorVersion = WINDOW_SERVICE_MAJOR,
+    .minorVersion = WINDOW_SERVICE_MINOR,
+    .service = &s_windowService,
+    .modDetached = remove_mod_windows,
+};
+
+}  // namespace dusk::mods::svc
diff --git a/src/dusk/mods/svc/window.hpp b/src/dusk/mods/svc/window.hpp
new file mode 100644
index 0000000000..29b48c1b75
--- /dev/null
+++ b/src/dusk/mods/svc/window.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include "mods/svc/window.h"
+
+union SDL_Event;
+struct SDL_Window;
+
+namespace dusk::mods {
+struct LoadedMod;
+}
+
+namespace dusk::mods::svc {
+
+// Routes an SDL event for an auxiliary mod window.
+// Returns true when the event belongs to one.
+bool window_dispatch_event(const SDL_Event& event);
+ModResult window_acquire_for_graphics(LoadedMod& mod, WindowHandle handle, SDL_Window*& outWindow);
+void window_release_for_graphics(LoadedMod& mod, WindowHandle handle);
+bool window_get_pixel_size(LoadedMod& mod, WindowHandle handle, uint32_t& width, uint32_t& height);
+
+}  // namespace dusk::mods::svc
diff --git a/include/dusk/mouse.h b/src/dusk/mouse.h
similarity index 100%
rename from include/dusk/mouse.h
rename to src/dusk/mouse.h
diff --git a/include/dusk/os.h b/src/dusk/os.h
similarity index 62%
rename from include/dusk/os.h
rename to src/dusk/os.h
index 180bdb9b1a..46529d1e61 100644
--- a/include/dusk/os.h
+++ b/src/dusk/os.h
@@ -1,5 +1,4 @@
-#ifndef DUSK_OS_H
-#define DUSK_OS_H
+#pragma once
 
 #ifdef __cplusplus
 extern "C" {
@@ -9,6 +8,8 @@ void OSSetCurrentThreadName(const char* name);
 
 #ifdef __cplusplus
 }
-#endif
 
-#endif // DUSK_OS_H
\ No newline at end of file
+namespace dusk {
+extern bool OSReportReallyForceEnable;
+}
+#endif
diff --git a/src/dusk/presentation.cpp b/src/dusk/presentation.cpp
new file mode 100644
index 0000000000..1443ab85f9
--- /dev/null
+++ b/src/dusk/presentation.cpp
@@ -0,0 +1,34 @@
+#include "dusk/presentation.hpp"
+
+#include "dusk/settings.h"
+
+#include <borealis/presentation.hpp>
+
+#include <algorithm>
+
+namespace dusk::presentation {
+namespace {
+
+float preferred_frame_rate() {
+    if (getTransientSettings().turboMode) {
+        return 0.0f;
+    }
+
+    switch (getSettings().game.enableFrameInterpolation.getValue()) {
+    case FrameInterpMode::Off:
+        return 30.0f;
+    case FrameInterpMode::Capped:
+        return static_cast<float>(std::max(getSettings().video.maxFrameRate.getValue(), 1));
+    case FrameInterpMode::Unlimited:
+    default:
+        return 0.0f;
+    }
+}
+
+}  // namespace
+
+void update_frame_rate_preference() {
+    borealis::presentation::set_preferred_frame_rate(preferred_frame_rate());
+}
+
+}  // namespace dusk::presentation
diff --git a/src/dusk/presentation.hpp b/src/dusk/presentation.hpp
new file mode 100644
index 0000000000..d9e6f26f4d
--- /dev/null
+++ b/src/dusk/presentation.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+namespace dusk::presentation {
+
+void update_frame_rate_preference();
+
+}  // namespace dusk::presentation
diff --git a/include/dusk/scope_guard.hpp b/src/dusk/scope_guard.hpp
similarity index 79%
rename from include/dusk/scope_guard.hpp
rename to src/dusk/scope_guard.hpp
index 281d23434d..ac35334d5d 100644
--- a/include/dusk/scope_guard.hpp
+++ b/src/dusk/scope_guard.hpp
@@ -1,5 +1,4 @@
-#ifndef DUSK_SCOPE_GUARD_HPP
-#define DUSK_SCOPE_GUARD_HPP
+#pragma once
 
 #include <functional>
 
@@ -16,5 +15,3 @@ public:
 private:
     std::function<void()> m_func;
 };
-
-#endif //DUSK_SCOPE_GUARD_HPP
diff --git a/src/dusk/settings.cpp b/src/dusk/settings.cpp
index 24fd6cbc22..b8bbde4628 100644
--- a/src/dusk/settings.cpp
+++ b/src/dusk/settings.cpp
@@ -1,6 +1,12 @@
 #include "dusk/settings.h"
+
 #include "dusk/config.hpp"
+#include "dusk/game_mode.hpp"
+#include "dusk/texture_replacements.hpp"
+#include "dusk/ui/ui.hpp"
+
 #include <aurora/aurora.h>
+#include <dolphin/vi.h>
 
 namespace dusk {
 
@@ -15,16 +21,17 @@ UserSettings g_userSettings = {
         .rememberWindowSize {"video.rememberWindowSize", false},
         .lastWindowWidth {"video.lastWindowWidth", 0},
         .lastWindowHeight {"video.lastWindowHeight", 0},
+        .uiScale {"video.uiScale", 100},
     },
 
     .audio = {
+        .outputMode {"audio.outputMode", AudioOutputMode::StereoSpeakers},
         .masterVolume {"audio.masterVolume", 60},
         .mainMusicVolume {"audio.mainMusicVolume", 100},
         .subMusicVolume {"audio.subMusicVolume", 100},
         .soundEffectsVolume {"audio.soundEffectsVolume", 100},
         .fanfareVolume {"audio.fanfareVolume", 100},
         .enableReverb {"audio.enableReverb", true},
-        .enableHrtf {"audio.enableHrtf", false},
         .menuSounds {"audio.menuSounds", true},
     },
 
@@ -51,6 +58,7 @@ UserSettings g_userSettings = {
         .sunsSong {"game.sunsSong", false},
         .autoSave {"game.autoSave", false},
         .enhancedMapMenus {"game.enhancedMapMenus", false},
+        .aimingReticle {"game.aimingReticle", false},
 
         // Preferences
         .enableMirrorMode {"game.enableMirrorMode", false},
@@ -75,6 +83,7 @@ UserSettings g_userSettings = {
         .resampler {"game.resampler", Resampler::Bilinear},
         .enableMapBackground {"game.enableMapBackground", true},
         .disableCutscenePillarboxing {"game.disableCutscenePillarboxing", false},
+        .enableHighQualityMinimapTextures {"game.enableHighQualityMinimapTextures", true},
 
         // Audio
         .noLowHpSound {"game.noLowHpSound", false},
@@ -155,7 +164,10 @@ UserSettings g_userSettings = {
         .recordingMode {"game.recordingMode", false},
         .removeQuestMapMarkers {"game.removeQuestMapMarkers", false},
         .showInputViewer {"game.showInputViewer", false},
-        .showInputViewerGyro {"game.showInputViewerGyro", false}
+        .showInputViewerGyro {"game.showInputViewerGyro", false},
+        .enableMoveLinkCombo {"game.enableMoveLinkCombo", false},
+        .enableTeleportCombo {"game.enableTeleportCombo", false},
+        .lastSelectedGameModeId {"game.lastSelectedGameModeId", gamemode::kVanillaGameModeId}
     },
 
     .backend = {
@@ -214,6 +226,22 @@ UserSettings& getSettings() {
     return g_userSettings;
 }
 
+void applyInternalResolutionScale(int scale) {
+    VISetFrameBufferScale(static_cast<float>(scale));
+}
+
+void applyResampler(Resampler resampler) {
+    switch (resampler) {
+    case Resampler::Area:
+        aurora_set_resampler(SAMPLER_AREA);
+        break;
+    case Resampler::Bilinear:
+    default:
+        aurora_set_resampler(SAMPLER_BILINEAR);
+        break;
+    }
+}
+
 void registerSettings() {
     // Video
     Register(g_userSettings.video.enableFullscreen);
@@ -225,15 +253,17 @@ void registerSettings() {
     Register(g_userSettings.video.rememberWindowSize);
     Register(g_userSettings.video.lastWindowWidth);
     Register(g_userSettings.video.lastWindowHeight);
+    Register(g_userSettings.video.uiScale, 
+        [](const int&, const int&) { dusk::ui::apply_scale(); });
 
     // Audio
+    Register(g_userSettings.audio.outputMode);
     Register(g_userSettings.audio.masterVolume);
     Register(g_userSettings.audio.mainMusicVolume);
     Register(g_userSettings.audio.subMusicVolume);
     Register(g_userSettings.audio.soundEffectsVolume);
     Register(g_userSettings.audio.fanfareVolume);
     Register(g_userSettings.audio.enableReverb);
-    Register(g_userSettings.audio.enableHrtf);
     Register(g_userSettings.audio.menuSounds);
 
     // Game
@@ -256,6 +286,7 @@ void registerSettings() {
     Register(g_userSettings.game.sunsSong);
     Register(g_userSettings.game.autoSave);
     Register(g_userSettings.game.enhancedMapMenus);
+    Register(g_userSettings.game.aimingReticle);
     Register(g_userSettings.game.enableMirrorMode);
     Register(g_userSettings.game.invertCameraXAxis);
     Register(g_userSettings.game.invertCameraYAxis);
@@ -276,12 +307,16 @@ void registerSettings() {
     Register(g_userSettings.game.bloomMultiplier);
     Register(g_userSettings.game.depthOfFieldMode);
     Register(g_userSettings.game.disableWaterRefraction);
-    Register(g_userSettings.game.enableTextureReplacements);
-    Register(g_userSettings.game.internalResolutionScale);
-    Register(g_userSettings.game.resampler);
+    Register(g_userSettings.game.enableTextureReplacements,
+        [](const bool&, const bool&) { texture_replacements::reload(); });
+    Register(g_userSettings.game.internalResolutionScale,
+        [](const int& value, const int&) { applyInternalResolutionScale(value); });
+    Register(g_userSettings.game.resampler,
+        [](const Resampler& value, const Resampler&) { applyResampler(value); });
     Register(g_userSettings.game.shadowResolutionMultiplier);
     Register(g_userSettings.game.enableMapBackground);
     Register(g_userSettings.game.disableCutscenePillarboxing);
+    Register(g_userSettings.game.enableHighQualityMinimapTextures);
     Register(g_userSettings.game.enableFastIronBoots);
     Register(g_userSettings.game.canTransformAnywhere);
     Register(g_userSettings.game.fastRoll);
@@ -303,6 +338,9 @@ void registerSettings() {
     Register(g_userSettings.game.removeQuestMapMarkers);
     Register(g_userSettings.game.showInputViewer);
     Register(g_userSettings.game.showInputViewerGyro);
+    Register(g_userSettings.game.enableMoveLinkCombo);
+    Register(g_userSettings.game.enableTeleportCombo);
+    Register(g_userSettings.game.lastSelectedGameModeId);
     Register(g_userSettings.game.fastSpinner);
     Register(g_userSettings.game.infiniteHearts);
     Register(g_userSettings.game.infiniteArrows);
@@ -395,7 +433,22 @@ static TransientSettings g_transientSettings = {
         .colliderViewOpacity = 50.0f,
         .drawRange = 100.0f,
     },
-    .skipFrameRateLimit = false,
+    .triggerView = {
+        .loadZones = false,
+        .eventAreas = false,
+        .switchAreas = false,
+        .eventTags = false,
+        .midnaStops = false,
+        .twilightGates = false,
+        .checkpoints = false,
+        .paths = false,
+        .transformDists = false,
+        .attentionDists = false,
+        .purpleMistAvoid = false,
+        .leevers = false,
+        .opacity = 75.0f,
+    },
+    .turboMode = false,
 };
 
 TransientSettings& getTransientSettings() {
diff --git a/include/dusk/settings.h b/src/dusk/settings.h
similarity index 88%
rename from include/dusk/settings.h
rename to src/dusk/settings.h
index 6961efb387..3fadd7a528 100644
--- a/include/dusk/settings.h
+++ b/src/dusk/settings.h
@@ -33,6 +33,7 @@ enum class GameLanguage : u8 {
     French = OS_LANGUAGE_FRENCH,
     Spanish = OS_LANGUAGE_SPANISH,
     Italian = OS_LANGUAGE_ITALIAN,
+    Japanese = 6,
 };
 
 enum class DiscVerificationState : u8 {
@@ -67,6 +68,13 @@ enum class MagicArmorMode : u8 {
     COSMETIC = 4,
 };
 
+enum class AudioOutputMode : u8 {
+    StereoSpeakers = 0,
+    StereoHeadphones = 1,   // spatial audio
+    Surround6ch = 2,        // discrete 5.1
+    Surround8ch = 3,        // discrete 7.1
+};
+
 namespace config {
 template <>
 struct ConfigEnumRange<BloomMode> {
@@ -89,7 +97,7 @@ struct ConfigEnumRange<Resampler> {
 template <>
 struct ConfigEnumRange<GameLanguage> {
     static constexpr auto min = GameLanguage::English;
-    static constexpr auto max = GameLanguage::Italian;
+    static constexpr auto max = GameLanguage::Japanese;
 };
 
 template <>
@@ -122,6 +130,12 @@ struct ConfigEnumRange<MagicArmorMode> {
     static constexpr auto max = MagicArmorMode::COSMETIC;
 };
 
+template <>
+struct ConfigEnumRange<AudioOutputMode> {
+    static constexpr auto min = AudioOutputMode::StereoSpeakers;
+    static constexpr auto max = AudioOutputMode::Surround8ch;
+};
+
 template <>
 struct ConfigValueTraits<ui::ControlLayout> {
     static constexpr bool enabled = true;
@@ -144,17 +158,18 @@ struct UserSettings {
         ConfigVar<bool> rememberWindowSize;
         ConfigVar<int> lastWindowWidth;
         ConfigVar<int> lastWindowHeight;
+        ConfigVar<int> uiScale;
     } video;
 
     struct {
         // Audio
+        ConfigVar<AudioOutputMode> outputMode;
         ConfigVar<int> masterVolume;
         ConfigVar<int> mainMusicVolume;
         ConfigVar<int> subMusicVolume;
         ConfigVar<int> soundEffectsVolume;
         ConfigVar<int> fanfareVolume;
         ConfigVar<bool> enableReverb;
-        ConfigVar<bool> enableHrtf;
         ConfigVar<bool> menuSounds;
     } audio;
 
@@ -183,6 +198,7 @@ struct UserSettings {
         ConfigVar<bool> sunsSong;
         ConfigVar<bool> autoSave;
         ConfigVar<bool> enhancedMapMenus;
+        ConfigVar<bool> aimingReticle;
 
         // Preferences
         ConfigVar<bool> enableMirrorMode;
@@ -207,6 +223,7 @@ struct UserSettings {
         ConfigVar<Resampler> resampler;
         ConfigVar<bool> enableMapBackground;
         ConfigVar<bool> disableCutscenePillarboxing;
+        ConfigVar<bool> enableHighQualityMinimapTextures;
 
         // Audio
         ConfigVar<bool> noLowHpSound;
@@ -283,6 +300,10 @@ struct UserSettings {
         ConfigVar<bool> removeQuestMapMarkers;
         ConfigVar<bool> showInputViewer;
         ConfigVar<bool> showInputViewerGyro;
+        ConfigVar<bool> enableMoveLinkCombo;
+        ConfigVar<bool> enableTeleportCombo;
+
+        ConfigVar<std::string> lastSelectedGameModeId;
     } game;
 
     struct {
@@ -311,6 +332,9 @@ UserSettings& getSettings();
 
 void registerSettings();
 
+void applyInternalResolutionScale(int scale);
+void applyResampler(Resampler resampler);
+
 // Transient settings
 
 struct CollisionViewSettings {
@@ -324,9 +348,26 @@ struct CollisionViewSettings {
     float drawRange;
 };
 
+struct TriggerViewSettings {
+    bool loadZones;
+    bool eventAreas;
+    bool switchAreas;
+    bool eventTags;
+    bool midnaStops;
+    bool twilightGates;
+    bool checkpoints;
+    bool paths;
+    bool transformDists;
+    bool attentionDists;
+    bool purpleMistAvoid;
+    bool leevers;
+    float opacity;
+};
+
 struct TransientSettings {
     CollisionViewSettings collisionView;
-    bool skipFrameRateLimit;
+    TriggerViewSettings triggerView;
+    bool turboMode;
     bool moveLinkActive;
     bool stateShareLoadActive;
 };
diff --git a/src/dusk/speedrun.cpp b/src/dusk/speedrun.cpp
index e396197040..166ef70839 100644
--- a/src/dusk/speedrun.cpp
+++ b/src/dusk/speedrun.cpp
@@ -1,11 +1,54 @@
 #include "dusk/speedrun.h"
+#include <aurora/aurora.h>
+#include "dusk/config.hpp"
+#include "dusk/game_mode.hpp"
+#include "dusk/livesplit.h"
 #include "dusk/settings.h"
 #include "m_Do/m_Do_main.h"
-#include <aurora/aurora.h>
 
-namespace dusk {
+namespace dusk::speedrun {
 
-SpeedrunInfo m_speedrunInfo;
+SpeedrunInfo g_speedrunInfo;
+
+static void onSpeedrunModeActive() {
+    resetForSpeedrunMode();
+}
+
+static void onSpeedrunModeDeactive() {
+    restoreFromSpeedrunMode();
+    if (getSettings().game.liveSplitEnabled) {
+        speedrun::disconnectLiveSplit();
+    }
+    g_speedrunInfo.reset();
+    reset();
+}
+
+void registerSpeedrunGameMode() {
+    dusk::gamemode::GameMode speedrunGameMode{
+        kSpeedrunGameModeId, "Speedrun", "gczelda2-speedrun"};
+    speedrunGameMode.mOnSaveLoadedFunction = [] {
+        dusk::speedrun::start();
+        return true;
+    };
+    speedrunGameMode.mOnActivatedFunction = [] {
+        onSpeedrunModeActive();
+        return true;
+    };
+    speedrunGameMode.mOnDeactivatedFunction = [] {
+        onSpeedrunModeDeactive();
+        return true;
+    };
+    speedrunGameMode.mOnTickFunction = [] {
+        dusk::speedrun::onGameFrame();
+        return true;
+    };
+
+    dusk::gamemode::getGameModeManager().registerGameMode(speedrunGameMode);
+}
+
+void unregisterSpeedrunGameMode() {
+    dusk::gamemode::getGameModeManager().unregisterGameMode(kSpeedrunGameModeId);
+}
 
 void resetForSpeedrunMode() {
     mDoMain::developmentMode = -1;
@@ -41,6 +84,18 @@ void resetForSpeedrunMode() {
     getSettings().backend.enableAdvancedSettings.setSpeedrunValue(false);
     getSettings().game.recordingMode.setSpeedrunValue(false);
     getSettings().game.debugFlyCam.setSpeedrunValue(false);
+
+    getSettings().game.enableMoveLinkCombo.setSpeedrunValue(false);
+    getSettings().game.enableTeleportCombo.setSpeedrunValue(false);
 }
 
-}  // namespace dusk
+static void clearSpeedrunOverrides() {
+    config::EnumerateRegistered([](config::ConfigVarBase& cvar) { cvar.clearSpeedrunOverride(); });
+}
+
+void restoreFromSpeedrunMode() {
+    clearSpeedrunOverrides();
+    aurora_set_pause_on_focus_lost(getSettings().game.pauseOnFocusLost.getValue());
+}
+
+}  // namespace dusk::speedrun
diff --git a/src/dusk/speedrun.h b/src/dusk/speedrun.h
new file mode 100644
index 0000000000..add396726f
--- /dev/null
+++ b/src/dusk/speedrun.h
@@ -0,0 +1,58 @@
+#pragma once
+#include <aurora/aurora.h>
+#include "dusk/game_mode.hpp"
+
+namespace dusk::speedrun {
+
+constexpr const char* kSpeedrunGameModeId = "vanilla_speedrun";
+
+struct SpeedrunInfo {
+
+    void startRun() {
+        m_isRunStarted = true;
+        m_rtaStartTimestamp = OSGetNativeTime();
+        m_igtStartTimestamp = OSGetTime();
+    }
+
+    void stopRun() {
+        m_isRunStarted = false;
+        m_rtaTimer = OSGetNativeTime() - m_rtaStartTimestamp;
+        if (!m_isPauseIGT) {
+            m_igtTimer = OSGetTime() - m_igtStartTimestamp - m_totalLoadTime;
+        }
+    }
+
+    void reset() {
+        m_isRunStarted = false;
+        m_rtaStartTimestamp = 0;
+        m_rtaTimer = 0;
+        m_igtStartTimestamp = 0;
+        m_isPauseIGT = false;
+        m_loadStartTimestamp = 0;
+        m_totalLoadTime = 0;
+        m_igtTimer = 0;
+    }
+
+    bool m_isRunStarted = false;
+    OSTime m_rtaStartTimestamp = 0;
+    OSTime m_rtaTimer = 0;
+    OSTime m_igtStartTimestamp = 0;
+
+    bool m_isPauseIGT = false;
+    OSTime m_loadStartTimestamp = 0;
+    OSTime m_totalLoadTime = 0;
+    OSTime m_igtTimer = 0;
+};
+
+extern SpeedrunInfo g_speedrunInfo;
+
+void registerSpeedrunGameMode();
+void unregisterSpeedrunGameMode();
+void resetForSpeedrunMode();
+void restoreFromSpeedrunMode();
+
+inline bool isActive() {
+    return dusk::gamemode::getGameModeManager().isCurrentGameMode(kSpeedrunGameModeId);
+}
+
+}  // namespace dusk
diff --git a/src/dusk/stubs.cpp b/src/dusk/stubs.cpp
index b283eb43bf..fb6ef4cf41 100644
--- a/src/dusk/stubs.cpp
+++ b/src/dusk/stubs.cpp
@@ -1,19 +1,14 @@
+#include "dusk/logging.h"
+#include "dusk/main.h"
+
 #include <dolphin/dolphin.h>
 #include <dolphin/gx.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-#include <cstdlib>
-#include <cstdint>
+#include <tracy/Tracy.hpp>
+
+#include <condition_variable>
 #include <memory>
 #include <mutex>
-#include <condition_variable>
 #include <unordered_map>
-#include <memory>
-#include <dusk/logging.h>
-#include <dusk/main.h>
-
-#include "tracy/Tracy.hpp"
 
 #ifndef _WIN32
 #include <sys/time.h>
@@ -244,28 +239,6 @@ void SoundRevID(int a, int b) {
     STUB_LOG();
 }
 
-#pragma mark DC
-
-void DCFlushRange(void* addr, u32 nBytes) {
-    // Not needed on PC.
-}
-
-void DCFlushRangeNoSync(void* addr, u32 nBytes) {
-    // Not needed on PC.
-}
-
-void DCInvalidateRange(void* addr, u32 nBytes) {
-    // Not needed on PC.
-}
-
-void DCStoreRange(void* addr, u32 nBytes) {
-    // Not needed on PC.
-}
-
-void DCStoreRangeNoSync(void* addr, u32 nBytes) {
-    // Not needed on PC.
-}
-
 #pragma mark EXI
 
 BOOL EXIDeselect(int chan) {
@@ -303,12 +276,6 @@ BOOL EXIUnlock(int chan) {
     return FALSE;
 }
 
-#pragma mark LC
-
-void LCEnable() {
-    STUB_LOG();
-}
-
 // OS-related functions consolidated under "# pragma mark OS" further up
 
 #pragma mark VI
@@ -908,7 +875,7 @@ void AIInit(u8* stack) {
     // In a real scenario, it would set up the audio interface and prepare it for use.
 }
 
-void AIInitDMA(u32 start_addr, u32 length) {
+void AIInitDMA(uintptr_t start_addr, u32 length) {
     STUB_LOG();
 }
 
@@ -1041,11 +1008,6 @@ extern "C" void KPADEnableDPD(s32) {
     STUB_LOG();
 }
 
-// LC (consolidated above)
-void LCDisable(void) {
-    STUB_LOG();
-}
-
 #pragma mark PPC Arch
 // MSR stuff?
 void PPCHalt() {
diff --git a/src/dusk/texture_replacements.cpp b/src/dusk/texture_replacements.cpp
index 2866af855f..118989c6a7 100644
--- a/src/dusk/texture_replacements.cpp
+++ b/src/dusk/texture_replacements.cpp
@@ -26,11 +26,6 @@ void reload() {
                  s_directoryGroup.registrations.size());
 }
 
-void set_enabled(bool enabled) {
-    getSettings().game.enableTextureReplacements.setValue(enabled);
-    reload();
-}
-
 void shutdown() {
     aurora::texture::unregister_replacements(s_directoryGroup);
     s_directoryGroup.registrations.clear();
diff --git a/include/dusk/texture_replacements.hpp b/src/dusk/texture_replacements.hpp
similarity index 69%
rename from include/dusk/texture_replacements.hpp
rename to src/dusk/texture_replacements.hpp
index 85cb59b001..99801521aa 100644
--- a/include/dusk/texture_replacements.hpp
+++ b/src/dusk/texture_replacements.hpp
@@ -1,5 +1,4 @@
-#ifndef DUSK_TEXTURE_REPLACEMENTS_HPP
-#define DUSK_TEXTURE_REPLACEMENTS_HPP
+#pragma once
 
 #include <cstdint>
 
@@ -9,9 +8,6 @@ namespace dusk::texture_replacements {
 inline constexpr int32_t kUserTextureReplacementPriority = -1'000'000;
 
 void reload();
-void set_enabled(bool enabled);
 void shutdown();
 
 }
-
-#endif
diff --git a/include/dusk/time.h b/src/dusk/time.h
similarity index 98%
rename from include/dusk/time.h
rename to src/dusk/time.h
index ead946188b..6423e084cf 100644
--- a/include/dusk/time.h
+++ b/src/dusk/time.h
@@ -1,11 +1,10 @@
-#ifndef DUSK_TIME_H
-#define DUSK_TIME_H
+#pragma once
+
+#include <SDL3/SDL_timer.h>
 
 #include <array>
 #include <numeric>
 
-#include "SDL3/SDL_timer.h"
-
 #ifdef _WIN32
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
@@ -138,5 +137,3 @@ private:
   void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration); }
 #endif
 };
-
-#endif
diff --git a/include/dusk/touch_camera.h b/src/dusk/touch_camera.h
similarity index 100%
rename from include/dusk/touch_camera.h
rename to src/dusk/touch_camera.h
diff --git a/src/dusk/trigger_viewer.cpp b/src/dusk/trigger_viewer.cpp
new file mode 100644
index 0000000000..ef90bf0bc3
--- /dev/null
+++ b/src/dusk/trigger_viewer.cpp
@@ -0,0 +1,404 @@
+#include "JSystem/JMath/JMath.h"
+#include "SSystem/SComponent/c_list.h"
+#include "SSystem/SComponent/c_tag.h"
+#include "d/actor/d_a_alink.h"
+#include "d/actor/d_a_e_rb.h"
+#include "d/actor/d_a_e_rd.h"
+#include "d/actor/d_a_kytag08.h"
+#include "d/actor/d_a_scene_exit.h"
+#include "d/actor/d_a_swc00.h"
+#include "d/actor/d_a_tag_chgrestart.h"
+#include "d/actor/d_a_tag_mstop.h"
+#include "d/d_attention.h"
+#include "d/d_com_inf_game.h"
+#include "d/d_debug_viewer.h"
+#include "d/d_path.h"
+#include "d/d_stage.h"
+#include "dusk/settings.h"
+#include "dusk/trigger_viewer.h"
+#include "f_op/f_op_actor_mng.h"
+#include "f_op/f_op_actor_tag.h"
+#include "f_pc/f_pc_name.h"
+#include "m_Do/m_Do_mtx.h"
+
+namespace dusk {
+namespace TriggerView {
+
+static u8 s_opacity;
+
+typedef void (*DrawCallback)(fopAc_ac_c*);
+
+static void searchActorForCallback(s16 actorName, DrawCallback callback) {
+    node_class* node = g_fopAcTg_Queue.mpHead;
+
+    for (int i = 0; i < g_fopAcTg_Queue.mSize; i++) {
+        if (node != NULL) {
+            create_tag_class* tag = (create_tag_class*)node;
+            fopAc_ac_c* actorData = (fopAc_ac_c*)tag->mpTagData;
+
+            bool checkAll = actorName == -1;
+            if (actorData != NULL && (fopAcM_GetName(actorData) == actorName || checkAll)) {
+                callback(actorData);
+            }
+            node = node->mpNextNode;
+        }
+    }
+}
+
+static void drawSceneExit(fopAc_ac_c* actor) {
+    daScex_c* scex = (daScex_c*)actor;
+
+    cXyz points[8];
+    points[0].set(-actor->scale.x, actor->scale.y, -actor->scale.z);
+    points[1].set(actor->scale.x, actor->scale.y, -actor->scale.z);
+    points[2].set(-actor->scale.x, actor->scale.y, actor->scale.z);
+    points[3].set(actor->scale.x, actor->scale.y, actor->scale.z);
+    points[4].set(-actor->scale.x, 0.0f, -actor->scale.z);
+    points[5].set(actor->scale.x, 0.0f, -actor->scale.z);
+    points[6].set(-actor->scale.x, 0.0f, actor->scale.z);
+    points[7].set(actor->scale.x, 0.0f, actor->scale.z);
+
+    mDoMtx_inverse(scex->mMatrix, mDoMtx_stack_c::get());
+    mDoMtx_multVecArray(mDoMtx_stack_c::get(), points, points, 8);
+
+    GXColor color = {0xFF, 0x00, 0xFF, s_opacity};
+    dDbVw_drawCube8pXlu(points, color);
+}
+
+static void drawMidnaStop(fopAc_ac_c* actor) {
+    daTagMstop_c* mstop = (daTagMstop_c*)actor;
+
+    GXColor color = {0x4A, 0x36, 0xBA, s_opacity};
+    dDbVw_drawCylinderXlu(mstop->current.pos, mstop->scale.x * 100.0f, mstop->scale.y, color, 1);
+}
+
+static void drawPlumTag(fopAc_ac_c* actor) {
+    GXColor color = {0x00, 0xFF, 0x00, s_opacity};
+    dDbVw_drawCylinderXlu(actor->current.pos, actor->scale.x * 100.0f, 1000000.0f, color, 1);
+}
+
+static void drawPlumSearch(fopAc_ac_c* actor) {
+    GXColor color = {0xFF, 0x00, 0x00, s_opacity};
+    const f32 search_dist = 500.0f;
+    dDbVw_drawCircleXlu(actor->attention_info.position, search_dist + 160.0f, color, 1, 12);
+}
+
+static void drawSwitchArea(fopAc_ac_c* actor) {
+    daSwc00_c* swc = (daSwc00_c*)actor;
+    int shape_type = (fopAcM_GetParam(actor) >> 0x12) & 3;
+
+    GXColor color = {0x00, 0x00, 0xFF, s_opacity};
+    if (shape_type == 3) {
+        dDbVw_drawCylinderXlu(swc->current.pos, JMAFastSqrt(swc->scale.x) - 30.0f, swc->scale.y, color, 1);
+    } else if (shape_type == 0) {
+        cXyz size = swc->field_0x574 - swc->field_0x568;
+        size *= 0.5f;
+        cXyz pos = swc->field_0x568 + size;
+        csXyz angle(swc->current.angle.x, swc->current.angle.y, swc->current.angle.z);
+        dDbVw_drawCubeXlu(pos, size, angle, color);
+    }
+}
+
+static void drawEventArea(fopAc_ac_c* actor) {
+    u8 type = (actor->shape_angle.z & 0xFF);
+    if (type == 0xFF) {
+        type = 0;
+    }
+
+    if (type == 15 || type == 16) {
+        GXColor color = {0xFF, 0xFF, 0x00, s_opacity};
+        cXyz points[8];
+        points[0].set(-actor->scale.x, actor->scale.y, -actor->scale.z);
+        points[1].set(actor->scale.x, actor->scale.y, -actor->scale.z);
+        points[2].set(-actor->scale.x, actor->scale.y, actor->scale.z);
+        points[3].set(actor->scale.x, actor->scale.y, actor->scale.z);
+        points[4].set(-actor->scale.x, 0.0f, -actor->scale.z);
+        points[5].set(actor->scale.x, 0.0f, -actor->scale.z);
+        points[6].set(-actor->scale.x, 0.0f, actor->scale.z);
+        points[7].set(actor->scale.x, 0.0f, actor->scale.z);
+
+        mDoMtx_stack_c::transS(actor->home.pos.x, actor->home.pos.y, actor->home.pos.z);
+        mDoMtx_stack_c::YrotS(actor->current.angle.y);
+        mDoMtx_multVecArray(mDoMtx_stack_c::get(), points, points, 8);
+
+        dDbVw_drawCube8pXlu(points, color);
+    } else {
+        GXColor outer_color = {0xFF, 0x00, 0x00, s_opacity};
+        GXColor inner_color = {0x00, 0xFF, 0x00, s_opacity};
+        cXyz pos = actor->current.pos;
+
+        daAlink_c* player = (daAlink_c*)dComIfGp_getPlayer(0);
+        if (player != NULL && pos.y < player->mLinkAcch.GetGroundH()) {
+            pos.y = player->mLinkAcch.GetGroundH() + 100.0f;
+        }
+
+        const f32 inner_scale = 0.83f;
+        dDbVw_drawCircleXlu(pos, actor->scale.x * inner_scale, inner_color, 1, 20);
+        dDbVw_drawCircleXlu(pos, actor->scale.x, outer_color, 1, 20);
+    }
+}
+
+static void drawEventTag(fopAc_ac_c* actor) {
+    GXColor color = {0x00, 0xC8, 0xFF, s_opacity};
+    u16 area_type = actor->home.angle.x & 0x8000;
+
+    if (area_type == 0x8000) {
+        cXyz start(actor->current.pos.x - (actor->scale.x * 0.5f), actor->current.pos.y,
+                   actor->current.pos.z - (actor->scale.z * 0.5f));
+        cXyz end(actor->current.pos.x + (actor->scale.x * 0.5f),
+                 actor->current.pos.y + actor->scale.y,
+                 actor->current.pos.z + (actor->scale.z * 0.5f));
+
+        cXyz points[8];
+        points[0].set(start.x, start.y, start.z);
+        points[1].set(start.x, start.y, end.z);
+        points[2].set(end.x, start.y, end.z);
+        points[3].set(end.x, start.y, start.z);
+        points[4].set(start.x, end.y, start.z);
+        points[5].set(start.x, end.y, end.z);
+        points[6].set(end.x, end.y, end.z);
+        points[7].set(end.x, end.y, start.z);
+
+        dDbVw_drawCube8pXlu(points, color);
+    } else {
+        cXyz pos = actor->current.pos;
+        pos.y -= actor->scale.y;
+        dDbVw_drawCylinderXlu(pos, actor->scale.x, actor->scale.y * 2, color, 1);
+    }
+}
+
+static void drawTWGate(fopAc_ac_c* actor) {
+    GXColor color = {0xFF, 0xFF, 0xFF, s_opacity};
+    dDbVw_drawCylinderXlu(actor->current.pos, actor->scale.x * 100.0f, actor->scale.y * 100.0f, color, 1);
+}
+
+static u8 s_pathColorIndex = 0;
+
+static void drawPaths(dStage_dPath_c* paths) {
+    static const GXColor colors[8] = {
+        {0xFF, 0xFF, 0xFF}, {0x00, 0x00, 0x00}, {0xFF, 0x00, 0x00}, {0x00, 0xFF, 0x00},
+        {0x00, 0x00, 0xFF}, {0xFF, 0xFF, 0x00}, {0xFF, 0x00, 0xFF}, {0x00, 0xFF, 0xFF},
+    };
+
+    cXyz cubeSize = {30.0f, 30.0f, 30.0f};
+    csXyz cubeAngle = {0, 0, 0};
+
+    for (int i = 0; i < (int)paths->num; i++) {
+        dPath* path = &paths->m_path[i];
+        GXColor color = colors[(s_pathColorIndex++) & 7];
+        color.a = s_opacity;
+        cXyz a, b;
+
+        if (dPath_ChkClose(path) && path->m_num > 2) {
+            a = (Vec)path->m_points[0].m_position;
+            b = (Vec)path->m_points[(int)path->m_num - 1].m_position;
+            dDbVw_drawLineXlu(a, b, color, 1, 10);
+        }
+
+        for (int j = 0; j < (int)path->m_num - 1; j++) {
+            a = (Vec)path->m_points[j].m_position;
+            b = (Vec)path->m_points[j + 1].m_position;
+            dDbVw_drawLineXlu(a, b, color, 1, 10);
+            dDbVw_drawCubeXlu(a, cubeSize, cubeAngle, color);
+        }
+        dDbVw_drawCubeXlu(b, cubeSize, cubeAngle, color);
+    }
+}
+
+static void drawStagePaths() {
+    dStage_dPath_c* stagePaths = g_dComIfG_gameInfo.play.getStage().getPath2Inf();
+    if (stagePaths != nullptr) {
+        drawPaths(stagePaths);
+    }
+}
+
+static void drawCurrentRoomPaths() {
+    fopAc_ac_c* player = dComIfGp_getPlayer(0);
+    if (player == nullptr) {
+        return;
+    }
+
+    s32 roomNo = fopAcM_GetRoomNo(player);
+    if (roomNo < 0 || roomNo >= 64) {
+        return;
+    }
+
+    dStage_dPath_c* roomPaths = dStage_roomControl_c::mStatus[roomNo].mRoomDt.getPath2Inf();
+    if (roomPaths != nullptr) {
+        drawPaths(roomPaths);
+    }
+}
+
+static void drawCheckpointTag(fopAc_ac_c* actor) {
+    daTagChgRestart_c* chk = (daTagChgRestart_c*)actor;
+
+    GXColor color = {0x29, 0xF0, 0xFF, s_opacity};
+    cXyz points[8];
+
+    mDoMtx_stack_c::transS(actor->current.pos.x, actor->current.pos.y, actor->current.pos.z);
+    mDoMtx_stack_c::YrotM(actor->current.angle.y);
+
+    points[0] = chk->mVertices[0];
+    points[1] = chk->mVertices[1];
+    points[2] = chk->mVertices[3];
+    points[3] = chk->mVertices[2];
+    points[4] = chk->mVertices[0];
+    points[5] = chk->mVertices[1];
+    points[6] = chk->mVertices[3];
+    points[7] = chk->mVertices[2];
+
+    mDoMtx_multVecArray(mDoMtx_stack_c::get(), points, points, 8);
+
+    fopAc_ac_c* player = dComIfGp_getPlayer(0);
+    if (player != nullptr) {
+        for (int i = 0; i < 8; i++) {
+            points[i].y = player->current.pos.y;
+        }
+    }
+
+    for (int i = 0; i < 4; i++) {
+        points[i].y += 1000.0f;
+    }
+
+    dDbVw_drawCube8pXlu(points, color);
+}
+
+static void drawTransformDists(fopAc_ac_c* actor) {
+    if (fopAcM_GetGroup(actor) == 4 && !(actor->actor_status & fopAcStts_UNK_0x8000000_e)) {
+        GXColor near_color = {0x00, 0xFF, 0x00, s_opacity};
+        GXColor far_color = {0xFF, 0x00, 0x00, s_opacity};
+
+        const f32 near_dist = 400.0f;
+        const f32 far_dist = 5000.0f;
+
+        dDbVw_drawCircleXlu(actor->eyePos, near_dist, near_color, 1, 20);
+        dDbVw_drawCircleXlu(actor->eyePos, far_dist, far_color, 1, 20);
+
+        const s16 view_range = 0x4000;
+        cXyz offset(0.0f, 0.0f, far_dist);
+        cXyz endpos;
+
+        mDoMtx_stack_c::transS(actor->eyePos.x, actor->eyePos.y, actor->eyePos.z);
+        mDoMtx_stack_c::YrotM(actor->shape_angle.y);
+        mDoMtx_stack_c::YrotM(-view_range);
+        mDoMtx_stack_c::multVec(&offset, &endpos);
+        dDbVw_drawLineXlu(actor->eyePos, endpos, far_color, 1, 10);
+
+        mDoMtx_stack_c::transS(actor->eyePos.x, actor->eyePos.y, actor->eyePos.z);
+        mDoMtx_stack_c::YrotM(actor->shape_angle.y);
+        mDoMtx_stack_c::YrotM(view_range);
+        mDoMtx_stack_c::multVec(&offset, &endpos);
+        dDbVw_drawLineXlu(actor->eyePos, endpos, far_color, 1, 10);
+
+        mDoMtx_stack_c::transS(actor->eyePos.x, actor->eyePos.y, actor->eyePos.z);
+        mDoMtx_stack_c::YrotM(actor->shape_angle.y);
+        mDoMtx_stack_c::multVec(&offset, &endpos);
+        dDbVw_drawLineXlu(actor->eyePos, endpos, far_color, 1, 10);
+    }
+}
+
+static void drawAttentionDists(fopAc_ac_c* actor) {
+    if (fopAcM_GetGroup(actor) != 4) {
+        return;
+    }
+
+    GXColor lock_color = {0x00, 0x00, 0xFF, s_opacity};
+    GXColor talk_color = {0x00, 0xFF, 0x00, s_opacity};
+
+    dist_entry& lock_inf = dAttention_c::getDistTable(actor->attention_info.distances[fopAc_attn_LOCK_e]);
+    dist_entry& talk_inf = dAttention_c::getDistTable(actor->attention_info.distances[fopAc_attn_TALK_e]);
+
+    dDbVw_drawCircleXlu(actor->attention_info.position, lock_inf.mDistMax, lock_color, 1, 20);
+    dDbVw_drawCircleXlu(actor->attention_info.position, talk_inf.mDistMax, talk_color, 1, 20);
+}
+
+static void drawPurpleMistAvoid(fopAc_ac_c* actor) {
+    kytag08_class* tag = (kytag08_class*)actor;
+
+    GXColor avoidColor = {0x00, 0xFF, 0x00, s_opacity};
+    GXColor targetColor = {0xFF, 0x00, 0xFF, s_opacity};
+
+    dDbVw_drawCircleXlu(tag->mAvoidPos, tag->mSize.x * 45.0f * tag->mSizeScale, avoidColor, 1, 20);
+
+    cXyz cubeSize(10.0f, 10.0f, 10.0f);
+    csXyz cubeAngle(0, 0, 0);
+    dDbVw_drawCubeXlu(tag->mAvoidPos, cubeSize, cubeAngle, avoidColor);
+    dDbVw_drawCubeXlu(tag->mTargetAvoidPos, cubeSize, cubeAngle, targetColor);
+}
+
+static void drawLeeverData(fopAc_ac_c* actor) {
+    e_rb_class* leever = (e_rb_class*)actor;
+
+    if (leever->isChild) {
+        return;
+    }
+
+    GXColor color = {0xFF, 0x00, 0x00, s_opacity};
+    GXColor color2 = {0x00, 0x00, 0xFF, s_opacity};
+
+    cXyz pos = actor->current.pos;
+    daAlink_c* player = (daAlink_c*)dComIfGp_getPlayer(0);
+    if (player != nullptr && pos.y < player->mLinkAcch.GetGroundH()) {
+        pos.y = player->mLinkAcch.GetGroundH() + 100.0f;
+    }
+
+    dDbVw_drawCircleXlu(pos, leever->appearRange * 100.0f, color, 1, 20);
+    dDbVw_drawCircleXlu(pos, leever->field_0xa69 * 100.0f, color2, 1, 20);
+}
+
+void execute() {
+    const auto& settings = getTransientSettings().triggerView;
+    s_opacity = (u8)(255.0f * (settings.opacity / 100.0f));
+
+    if (settings.loadZones) {
+        searchActorForCallback(fpcNm_SCENE_EXIT_e, drawSceneExit);
+    }
+
+    if (settings.midnaStops) {
+        searchActorForCallback(fpcNm_Tag_Mstop_e, drawMidnaStop);
+    }
+
+    if (settings.switchAreas) {
+        searchActorForCallback(fpcNm_SWC00_e, drawSwitchArea);
+    }
+
+    if (settings.eventAreas) {
+        searchActorForCallback(fpcNm_TAG_EVENT_e, drawEventTag);
+        searchActorForCallback(fpcNm_TAG_EVTAREA_e, drawEventArea);
+        searchActorForCallback(fpcNm_TAG_MYNA2_e, drawPlumTag);
+        searchActorForCallback(fpcNm_MYNA2_e, drawPlumSearch);
+    }
+
+    if (settings.twilightGates) {
+        searchActorForCallback(fpcNm_Tag_TWGate_e, drawTWGate);
+    }
+
+    if (settings.paths) {
+        s_pathColorIndex = 0;
+        drawStagePaths();
+        drawCurrentRoomPaths();
+    }
+
+    if (settings.checkpoints) {
+        searchActorForCallback(fpcNm_Tag_ChgRestart_e, drawCheckpointTag);
+    }
+
+    if (settings.transformDists) {
+        searchActorForCallback(-1, drawTransformDists);
+    }
+
+    if (settings.attentionDists) {
+        searchActorForCallback(-1, drawAttentionDists);
+    }
+
+    if (settings.purpleMistAvoid) {
+        searchActorForCallback(fpcNm_KYTAG08_e, drawPurpleMistAvoid);
+    }
+
+    if (settings.leevers) {
+        searchActorForCallback(fpcNm_E_RB_e, drawLeeverData);
+    }
+}
+
+}  // namespace TriggerView
+}  // namespace dusk
diff --git a/src/dusk/trigger_viewer.h b/src/dusk/trigger_viewer.h
new file mode 100644
index 0000000000..598cb0bb20
--- /dev/null
+++ b/src/dusk/trigger_viewer.h
@@ -0,0 +1,7 @@
+#pragma once
+
+namespace dusk {
+namespace TriggerView {
+void execute();
+}
+}
diff --git a/src/dusk/ui/achievements.cpp b/src/dusk/ui/achievements.cpp
index 9d25f1d82a..29676f3a66 100644
--- a/src/dusk/ui/achievements.cpp
+++ b/src/dusk/ui/achievements.cpp
@@ -1,12 +1,14 @@
 #include "achievements.hpp"
 
-#include "Z2AudioLib/Z2SeMgr.h"
-#include "dusk/achievements.h"
-#include "fmt/format.h"
-#include "m_Do/m_Do_audio.h"
 #include "nav_types.hpp"
 #include "pane.hpp"
 
+#include "dusk/achievements.h"
+
+#include "m_Do/m_Do_audio.h"
+
+#include <fmt/format.h>
+
 namespace dusk::ui {
 namespace {
 
@@ -16,47 +18,39 @@ struct CategoryInfo {
 };
 
 constexpr CategoryInfo kCategories[] = {
-    {AchievementCategory::Challenge,  "Challenge"},
+    {AchievementCategory::Challenge, "Challenge"},
     {AchievementCategory::Collection, "Collection"},
-    {AchievementCategory::Minigame,   "Minigame"},
-    {AchievementCategory::Misc,       "Misc"},
-    {AchievementCategory::Glitched,   "Glitched"},
+    {AchievementCategory::Minigame, "Minigame"},
+    {AchievementCategory::Misc, "Misc"},
+    {AchievementCategory::Glitched, "Glitched"},
 };
 
-Rml::String build_achievement_info_rml(const Achievement& a) {
-    Rml::String s = fmt::format(
-        R"(<div class="achievement-header">)"
-        R"(<span class="achievement-name{}">{}</span>)"
-        R"(<span class="achievement-badge{}">{}</span>)"
-        R"(</div>)"
-        R"(<p class="achievement-desc">{}</p>)",
-        a.unlocked ? " unlocked" : "",
-        a.name,
-        a.unlocked ? " unlocked" : " locked",
-        a.unlocked ? "Unlocked" : "Locked",
-        a.description
-    );
+void append_achievement_info(Rml::Element* parent, const Achievement& a) {
+    auto* header = append(parent, "achievement-header");
+    auto* name = append(header, "achievement-name");
+    name->SetClass("unlocked", a.unlocked);
+    append_text(name, a.name);
+    auto* badge = append(header, "achievement-badge");
+    badge->SetClass(a.unlocked ? "unlocked" : "locked", true);
+    append_text(badge, a.unlocked ? "Unlocked" : "Locked");
 
+    auto* description = append(parent, "p");
+    description->SetClass("achievement-desc", true);
+    append_text(description, a.description);
     if (a.isCounter) {
-        float fraction = a.goal > 0 ? float(a.progress) / float(a.goal) : 1.0f;
-        s += fmt::format(
-            R"(<progress value="{:.3f}" class="{}"/>)"
-            R"(<span class="achievement-progress">{} / {}</span>)",
-            fraction,
-            a.unlocked ? "progress-done" : "progress-ongoing",
-            a.progress,
-            a.goal
-        );
+        const float fraction = a.goal > 0 ? float(a.progress) / float(a.goal) : 1.0f;
+        auto* progress = append(parent, "progress");
+        progress->SetAttribute("value", fraction);
+        progress->SetClass(a.unlocked ? "progress-done" : "progress-ongoing", true);
+        append_text(
+            append(parent, "achievement-progress"), fmt::format("{} / {}", a.progress, a.goal));
     }
-
-    return s;
 }
 
 class AchievementRow : public FluentComponent<AchievementRow> {
 public:
     AchievementRow(Rml::Element* parent, const Achievement& a)
-        : FluentComponent(createRowRoot(parent))
-    {
+        : FluentComponent(createRowRoot(parent)) {
         auto& btn = add_child<Button>(Button::Props{"×"});
         mClearButton = &btn;
         btn.root()->SetClass("achievement-clear", true);
@@ -80,13 +74,10 @@ public:
             return false;
         });
 
-        Component::listen(btn.root(), Rml::EventId::Blur, [this](Rml::Event&) {
-            resetConfirm();
-        });
+        Component::listen(btn.root(), Rml::EventId::Blur, [this](Rml::Event&) { resetConfirm(); });
 
-        auto* infoDiv = append(mRoot, "div");
-        infoDiv->SetClass("achievement-info", true);
-        infoDiv->SetInnerRML(build_achievement_info_rml(a));
+        auto* infoDiv = append(mRoot, "achievement-info");
+        append_achievement_info(infoDiv, a);
     }
 
     bool focus() override { return mClearButton->focus(); }
@@ -94,8 +85,7 @@ public:
 private:
     static Rml::Element* createRowRoot(Rml::Element* parent) {
         auto* doc = parent->GetOwnerDocument();
-        auto elem = doc->CreateElement("div");
-        elem->SetClass("achievement-row", true);
+        auto elem = doc->CreateElement("achievement-row");
         return parent->AppendChild(std::move(elem));
     }
 
@@ -114,8 +104,7 @@ AchievementsWindow::AchievementsWindow() {
     const auto all = AchievementSystem::get().getAchievements();
 
     {
-        auto elem = mDocument->CreateElement("div");
-        elem->SetClass("achievement-total", true);
+        auto elem = mDocument->CreateElement("achievement-total");
         mTotalEl = mRoot->AppendChild(std::move(elem));
         updateTotal();
     }
@@ -185,8 +174,6 @@ AchievementsWindow::AchievementsWindow() {
                 *confirmingAll = false;
                 clearAllPtr->set_text("Clear All Achievements");
             });
-
-            pane.finalize();
         });
     }
 }
@@ -217,7 +204,9 @@ void AchievementsWindow::updateTotal() {
         return;
     }
     const auto all = AchievementSystem::get().getAchievements();
-    const int total = std::count_if(all.begin(), all.end(), [](const Achievement& achievement){ return achievement.category != AchievementCategory::Glitched;});
+    const int total = std::count_if(all.begin(), all.end(), [](const Achievement& achievement) {
+        return achievement.category != AchievementCategory::Glitched;
+    });
     int unlocked = 0;
     for (const auto& a : all) {
         if (a.unlocked) {
@@ -225,7 +214,7 @@ void AchievementsWindow::updateTotal() {
         }
     }
     const int pct = total > 0 ? (unlocked * 100 / total) : 0;
-    mTotalEl->SetInnerRML(fmt::format("{}%", pct));
+    set_text_content(mTotalEl, fmt::format("{}%", pct));
 }
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/button.cpp b/src/dusk/ui/button.cpp
index 0d95db3791..1655243fcb 100644
--- a/src/dusk/ui/button.cpp
+++ b/src/dusk/ui/button.cpp
@@ -25,7 +25,7 @@ Button::Button(Rml::Element* parent, Props props, const Rml::String& tagName)
 
 void Button::set_text(const Rml::String& text) {
     if (mProps.text != text) {
-        mRoot->SetInnerRML(escape(text));
+        set_text_content(mRoot, text);
         mProps.text = text;
     }
 }
diff --git a/src/dusk/ui/color_input.cpp b/src/dusk/ui/color_input.cpp
new file mode 100644
index 0000000000..6c7ba1714e
--- /dev/null
+++ b/src/dusk/ui/color_input.cpp
@@ -0,0 +1,744 @@
+#include "color_input.hpp"
+
+#include "button.hpp"
+#include "input.hpp"
+#include "nav_group.hpp"
+
+#include "m_Do/m_Do_audio.h"
+
+#include <SDL3/SDL_clipboard.h>
+#include <fmt/format.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <optional>
+#include <string_view>
+
+namespace dusk::ui {
+namespace {
+
+// These dimensions must match the controls in res/rml/popover.rcss.
+constexpr float kSvWidthDp = 240.0f;
+constexpr float kSvHeightDp = 150.0f;
+constexpr float kBarHeightDp = 14.0f;
+constexpr float kCursorDp = 14.0f;
+
+constexpr size_t kHistoryLimit = 8;
+constexpr int kSwatchColumns = 8;
+constexpr float kSvAnalogRate = 0.7f;
+constexpr float kHueAnalogRate = 240.0f;
+constexpr float kAlphaAnalogRate = 0.7f;
+constexpr float kSvNudge = 1.0f / 255.0f;
+constexpr float kHueNudge = 1.0f;
+constexpr float kAlphaNudge = 1.0f / 255.0f;
+
+std::vector<Rml::String> sColorHistory;
+
+bool directional_command(NavCommand command) {
+    return command == NavCommand::Up || command == NavCommand::Down ||
+           command == NavCommand::Left || command == NavCommand::Right;
+}
+
+float analog_response(float value) {
+    return value * std::abs(value);
+}
+
+class AdjustmentRegion : public Component {
+public:
+    struct Props {
+        std::function<void()> begin;
+        std::function<void()> cancel;
+        std::function<void(NavCommand)> nudge;
+        std::function<void(float, float, float)> adjust;
+    };
+
+    AdjustmentRegion(Rml::Element* root, Props props) : Component{root}, mProps{std::move(props)} {
+        listen(mRoot, Rml::EventId::Keydown, [this](Rml::Event& event) {
+            const auto command = map_nav_event(event);
+            if (command == NavCommand::Confirm) {
+                if (mActive) {
+                    finish();
+                } else {
+                    if (mProps.begin) {
+                        mProps.begin();
+                    }
+                    mActive = true;
+                    mAnalogReady = mAxis.x == 0.0f && mAxis.y == 0.0f;
+                    mRoot->SetClass("adjusting", true);
+                }
+                event.StopPropagation();
+                return;
+            }
+            if (command == NavCommand::Cancel && mActive) {
+                if (mProps.cancel) {
+                    mProps.cancel();
+                }
+                finish();
+                event.StopPropagation();
+                return;
+            }
+            if (directional_command(command) && (mActive || mAwaitingNeutral)) {
+                if (mActive && mAxis.x == 0.0f && mAxis.y == 0.0f && mProps.nudge) {
+                    mProps.nudge(command);
+                }
+                event.StopPropagation();
+            }
+        });
+        listen(mRoot, Rml::String{input::kNavAxisEvent}, [this](Rml::Event& event) {
+            mAxis = {
+                event.GetParameter<float>("x", 0.0f),
+                event.GetParameter<float>("y", 0.0f),
+            };
+            if (mAxis.x == 0.0f && mAxis.y == 0.0f) {
+                mAwaitingNeutral = false;
+                mAnalogReady = true;
+            }
+            const float deltaSeconds = event.GetParameter<float>("dt", 0.0f);
+            if (mActive && mAnalogReady && deltaSeconds > 0.0f && mProps.adjust) {
+                mProps.adjust(mAxis.x, mAxis.y, deltaSeconds);
+            }
+        });
+        listen(mRoot, Rml::EventId::Blur, [this](Rml::Event&) {
+            if (mActive) {
+                finish();
+            }
+        });
+    }
+
+private:
+    void finish() {
+        mActive = false;
+        mAnalogReady = false;
+        mAwaitingNeutral = mAxis.x != 0.0f || mAxis.y != 0.0f;
+        mRoot->SetClass("adjusting", false);
+    }
+
+    Props mProps;
+    Rml::Vector2f mAxis;
+    bool mActive = false;
+    bool mAnalogReady = false;
+    bool mAwaitingNeutral = false;
+};
+
+const std::vector<Rml::String>& default_presets() {
+    static const std::vector<Rml::String> presets = {
+        "ff4d4d",
+        "ff8a3d",
+        "ffd43b",
+        "61c454",
+        "3dc7c2",
+        "4d88ff",
+        "8b5cf6",
+        "e56aa6",
+        "8b6a45",
+        "ffffff",
+        "888888",
+        "202020",
+    };
+    return presets;
+}
+
+int hex_digit(char value) {
+    if (value >= '0' && value <= '9') {
+        return value - '0';
+    }
+    if (value >= 'a' && value <= 'f') {
+        return value - 'a' + 10;
+    }
+    if (value >= 'A' && value <= 'F') {
+        return value - 'A' + 10;
+    }
+    return -1;
+}
+
+std::optional<Rml::Colourb> parse_color(std::string_view value, bool alpha) {
+    if (value.starts_with('#')) {
+        value.remove_prefix(1);
+    }
+    if (value.size() != 6 && (!alpha || value.size() != 8)) {
+        return std::nullopt;
+    }
+
+    uint8_t channels[4] = {0, 0, 0, 255};
+    for (size_t i = 0; i < value.size() / 2; ++i) {
+        const int high = hex_digit(value[i * 2]);
+        const int low = hex_digit(value[i * 2 + 1]);
+        if (high < 0 || low < 0) {
+            return std::nullopt;
+        }
+        channels[i] = static_cast<uint8_t>((high << 4) | low);
+    }
+    return Rml::Colourb{channels[0], channels[1], channels[2], channels[3]};
+}
+
+Rml::String normalize_value(Rml::String value, bool alpha) {
+    if (value == "rainbow") {
+        return value;
+    }
+    const auto color = parse_color(value, alpha);
+    if (!color.has_value()) {
+        return value;
+    }
+    if (alpha && color->alpha != 255) {
+        return fmt::format(
+            "{:02x}{:02x}{:02x}{:02x}", color->red, color->green, color->blue, color->alpha);
+    }
+    return fmt::format("{:02x}{:02x}{:02x}", color->red, color->green, color->blue);
+}
+
+Rml::String css_color(Rml::Colourb color) {
+    return fmt::format("rgba({},{},{},{})", color.red, color.green, color.blue, color.alpha);
+}
+
+Rml::String format_color(Rml::Colourb color, bool hex, bool alpha) {
+    if (hex) {
+        if (alpha && color.alpha != 255) {
+            return fmt::format(
+                "#{:02X}{:02X}{:02X}{:02X}", color.red, color.green, color.blue, color.alpha);
+        }
+        return fmt::format("#{:02X}{:02X}{:02X}", color.red, color.green, color.blue);
+    }
+    if (alpha) {
+        return fmt::format("rgba({}, {}, {}, {:.0f}%)", color.red, color.green, color.blue,
+            static_cast<float>(color.alpha) / 255.0f * 100.0f);
+    }
+    return fmt::format("rgb({}, {}, {})", color.red, color.green, color.blue);
+}
+
+Rml::Colourb hsv_to_rgb(float hue, float sat, float val, float alpha) {
+    hue -= 360.0f * std::floor(hue / 360.0f);
+    const float chroma = val * sat;
+    const float intermediate = chroma * (1.0f - std::abs(std::fmod(hue / 60.0f, 2.0f) - 1.0f));
+    const float offset = val - chroma;
+    float red = 0.0f;
+    float green = 0.0f;
+    float blue = 0.0f;
+    switch (static_cast<int>(hue / 60.0f) % 6) {
+    case 0:
+        red = chroma;
+        green = intermediate;
+        break;
+    case 1:
+        red = intermediate;
+        green = chroma;
+        break;
+    case 2:
+        green = chroma;
+        blue = intermediate;
+        break;
+    case 3:
+        green = intermediate;
+        blue = chroma;
+        break;
+    case 4:
+        red = intermediate;
+        blue = chroma;
+        break;
+    case 5:
+    default:
+        red = chroma;
+        blue = intermediate;
+        break;
+    }
+    const auto toByte = [](float value) {
+        return static_cast<Rml::byte>(std::clamp(value, 0.0f, 1.0f) * 255.0f + 0.5f);
+    };
+    return {toByte(red + offset), toByte(green + offset), toByte(blue + offset), toByte(alpha)};
+}
+
+void rgb_to_hsv(Rml::Colourb color, float& hue, float& sat, float& val) {
+    const float red = static_cast<float>(color.red) / 255.0f;
+    const float green = static_cast<float>(color.green) / 255.0f;
+    const float blue = static_cast<float>(color.blue) / 255.0f;
+    const float maxChannel = std::max({red, green, blue});
+    const float minChannel = std::min({red, green, blue});
+    const float delta = maxChannel - minChannel;
+
+    val = maxChannel;
+    sat = maxChannel > 0.0f ? delta / maxChannel : 0.0f;
+    if (delta <= 0.0f) {
+        hue = 0.0f;
+        return;
+    }
+    if (maxChannel == red) {
+        hue = 60.0f * std::fmod((green - blue) / delta + 6.0f, 6.0f);
+    } else if (maxChannel == green) {
+        hue = 60.0f * ((blue - red) / delta + 2.0f);
+    } else {
+        hue = 60.0f * ((red - green) / delta + 4.0f);
+    }
+}
+
+void apply_swatch(Rml::Element* element, const Rml::String& value, bool alpha) {
+    element->RemoveProperty("background-color");
+    element->RemoveProperty("decorator");
+    element->SetClass("empty", false);
+    element->SetClass("rainbow", value == "rainbow");
+    if (value == "rainbow") {
+        element->SetProperty("decorator", "linear-gradient(90deg, #ff4d4d, #ffd43b, #61c454, "
+                                          "#3dc7c2, #4d88ff, #8b5cf6, #e56aa6)");
+        return;
+    }
+    const auto color = parse_color(value, alpha);
+    if (!color.has_value()) {
+        element->SetClass("empty", true);
+        return;
+    }
+    element->SetProperty("background-color", css_color(*color));
+}
+
+void remember_color(Rml::String value, bool alpha) {
+    value = normalize_value(std::move(value), alpha);
+    if (value != "rainbow" && !parse_color(value, alpha).has_value()) {
+        return;
+    }
+    std::erase(sColorHistory, value);
+    sColorHistory.insert(sColorHistory.begin(), std::move(value));
+    if (sColorHistory.size() > kHistoryLimit) {
+        sColorHistory.resize(kHistoryLimit);
+    }
+}
+
+}  // namespace
+
+ColorInput::ColorInput(Rml::Element* parent, Props props)
+    : BaseControlledSelectButton{parent, {.key = props.key, .submit = false}},
+      mProps{std::move(props)} {
+    mRoot->SetClass("color-input", true);
+    mSwatch = append(mRoot, "color-swatch");
+    refresh_swatch();
+}
+
+ColorInput::~ColorInput() {
+    if (mPicker != nullptr) {
+        mPicker->on_close(nullptr);
+        mPicker->on_focus(nullptr);
+        mPicker->dismiss();
+    }
+}
+
+void ColorInput::update() {
+    refresh_swatch();
+    if (mPickerNavigation != nullptr) {
+        mPickerNavigation->update();
+    }
+    BaseControlledSelectButton::update();
+}
+
+bool ColorInput::modified() const {
+    return mProps.isModified ? mProps.isModified() : BaseControlledSelectButton::modified();
+}
+
+bool ColorInput::disabled() const {
+    return mProps.isDisabled ? mProps.isDisabled() : BaseControlledSelectButton::disabled();
+}
+
+Rml::String ColorInput::format_value() {
+    const Rml::String value = mProps.getValue ? mProps.getValue() : "";
+    if (value == "rainbow") {
+        return "Rainbow";
+    }
+    const auto color = parse_color(value, mProps.alpha);
+    if (color.has_value()) {
+        return format_color(*color, mHexFormat, mProps.alpha);
+    }
+    return value.empty() ? "Default" : value;
+}
+
+bool ColorInput::handle_nav_command(NavCommand cmd) {
+    if (cmd == NavCommand::Confirm) {
+        toggle_picker();
+        return true;
+    }
+    return false;
+}
+
+void ColorInput::toggle_picker() {
+    if (mPicker != nullptr) {
+        mPicker->dismiss();
+        return;
+    }
+
+    mInitialValue = mProps.getValue ? mProps.getValue() : "";
+    mInitialValueRemembered = false;
+    const auto initialColor = parse_color(mInitialValue, mProps.alpha);
+    const Rml::Colourb color = initialColor.value_or(Rml::Colourb{128, 128, 128, 255});
+    rgb_to_hsv(color, mHue, mSat, mVal);
+    mAlpha = static_cast<float>(color.alpha) / 255.0f;
+
+    auto picker = std::make_unique<Popover>(mRoot, mProps.side, "color-picker");
+    mPicker = picker.get();
+    mPicker->on_close([this] {
+        if (mInitialValueRemembered && mProps.getValue) {
+            remember_color(mProps.getValue(), mProps.alpha);
+        }
+        mPicker = nullptr;
+        mPickerNavigation.reset();
+        mPickerListeners.clear();
+        mSvArea = nullptr;
+        mSvCursor = nullptr;
+        mHueBar = nullptr;
+        mHueCursor = nullptr;
+        mAlphaBar = nullptr;
+        mAlphaCursor = nullptr;
+        mPickerValue = nullptr;
+    });
+    build_picker();
+    refresh_picker();
+    mPicker->on_focus(
+        [this] { return mPickerNavigation != nullptr && mPickerNavigation->focus(); });
+    push_document(std::move(picker));
+}
+
+void ColorInput::build_picker() {
+    auto* body = mPicker->body();
+    mPickerNavigation = std::make_unique<NavGroup>(
+        body, NavGroup::Props{
+                  .layout = NavGroup::Layout::Vertical,
+                  .horizontalBoundary = NavGroup::Boundary::Stop,
+                  .verticalBoundary = NavGroup::Boundary::Stop,
+              });
+
+    mSvArea = append(body, "color-sv");
+    mSvCursor = append(mSvArea, "color-cursor");
+    mPickerNavigation->add_existing_item<AdjustmentRegion>(
+        mSvArea, AdjustmentRegion::Props{
+                     .begin = [this] { begin_adjustment(); },
+                     .cancel = [this] { cancel_adjustment(); },
+                     .nudge = [this](NavCommand direction) { nudge_sv(direction); },
+                     .adjust = [this](float x, float y,
+                                   float deltaSeconds) { adjust_sv(x, y, deltaSeconds); },
+                 });
+
+    mHueBar = append(body, "color-hue");
+    mHueCursor = append(mHueBar, "color-cursor");
+    mPickerNavigation->add_existing_item<AdjustmentRegion>(mHueBar,
+        AdjustmentRegion::Props{
+            .begin = [this] { begin_adjustment(); },
+            .cancel = [this] { cancel_adjustment(); },
+            .nudge = [this](NavCommand direction) { nudge_hue(direction); },
+            .adjust = [this](float x, float, float deltaSeconds) { adjust_hue(x, deltaSeconds); },
+        });
+
+    if (mProps.alpha) {
+        mAlphaBar = append(body, "color-alpha");
+        mAlphaCursor = append(mAlphaBar, "color-cursor");
+        mPickerNavigation->add_existing_item<AdjustmentRegion>(
+            mAlphaBar, AdjustmentRegion::Props{
+                           .begin = [this] { begin_adjustment(); },
+                           .cancel = [this] { cancel_adjustment(); },
+                           .nudge = [this](NavCommand direction) { nudge_alpha(direction); },
+                           .adjust = [this](float x, float,
+                                         float deltaSeconds) { adjust_alpha(x, deltaSeconds); },
+                       });
+    }
+
+    add_presets(*mPickerNavigation);
+    add_history(*mPickerNavigation);
+
+    auto* footer = append(body, "color-footer");
+    auto& footerNavigation = mPickerNavigation->add_existing_item<NavGroup>(
+        footer, NavGroup::Props{
+                    .layout = NavGroup::Layout::Horizontal,
+                    .horizontalBoundary = NavGroup::Boundary::Stop,
+                    .verticalBoundary = NavGroup::Boundary::Bubble,
+                });
+    const auto formatLabel = [this] {
+        return mHexFormat ? "Hex" : (mProps.alpha ? "RGBA" : "RGB");
+    };
+    auto& formatButton = footerNavigation.add_item<Button>(formatLabel());
+    formatButton.on_pressed([this, formatButtonPtr = &formatButton, formatLabel] {
+        mHexFormat = !mHexFormat;
+        formatButtonPtr->set_text(formatLabel());
+        refresh_picker();
+    });
+
+    footerNavigation.add_item<Button>("Default").on_pressed([this] { commit_value(""); });
+
+    auto& valueButton = footerNavigation.add_item<Button>("", "color-value");
+    mPickerValue = valueButton.root();
+    mPickerValue->SetAttribute("title", "Copy color");
+    valueButton.on_pressed([this] {
+        SDL_SetClipboardText(format_color(current_color(), mHexFormat, mProps.alpha).c_str());
+        push_toast({
+            .type = "info",
+            .title = "Color",
+            .content = "Copied to clipboard",
+            .duration = std::chrono::seconds{2},
+        });
+    });
+
+    const auto track = [this](Rml::Element* element, float widthDp, float heightDp,
+                           std::function<void(float, float)> apply) {
+        const auto handler = [this, element, widthDp, heightDp, apply = std::move(apply)](
+                                 Rml::Event& event) {
+            const float dpRatio = element->GetContext()->GetDensityIndependentPixelRatio();
+            const auto origin = element->GetAbsoluteOffset(Rml::BoxArea::Border);
+            const float x =
+                (event.GetParameter<float>("mouse_x", 0.0f) - origin.x) / (widthDp * dpRatio);
+            const float y =
+                (event.GetParameter<float>("mouse_y", 0.0f) - origin.y) / (heightDp * dpRatio);
+            element->Focus(true);
+            apply(std::clamp(x, 0.0f, 1.0f), std::clamp(y, 0.0f, 1.0f));
+            commit_color();
+        };
+        mPickerListeners.push_back(
+            std::make_unique<ScopedEventListener>(element, Rml::EventId::Mousedown, handler));
+        mPickerListeners.push_back(
+            std::make_unique<ScopedEventListener>(element, Rml::EventId::Drag, handler));
+    };
+
+    track(mSvArea, kSvWidthDp, kSvHeightDp, [this](float x, float y) {
+        mSat = x;
+        mVal = 1.0f - y;
+    });
+    track(mHueBar, kSvWidthDp, kBarHeightDp,
+        [this](float x, float) { mHue = std::min(x * 360.0f, 359.9f); });
+    if (mAlphaBar != nullptr) {
+        track(mAlphaBar, kSvWidthDp, kBarHeightDp, [this](float x, float) { mAlpha = x; });
+    }
+}
+
+void ColorInput::add_presets(NavGroup& navigation) {
+    append_text(append(navigation.root(), "color-heading"), "Presets");
+    auto* gridElement = append(navigation.root(), "color-presets");
+    auto& grid = navigation.add_existing_item<NavGroup>(
+        gridElement, NavGroup::Props{
+                         .layout = NavGroup::Layout::Grid,
+                         .columns = kSwatchColumns,
+                         .horizontalBoundary = NavGroup::Boundary::Stop,
+                         .verticalBoundary = NavGroup::Boundary::Bubble,
+                     });
+    const auto& presets = mProps.presets.empty() ? default_presets() : mProps.presets;
+    for (const auto& preset : presets) {
+        add_swatch_button(grid, preset);
+    }
+}
+
+void ColorInput::add_history(NavGroup& navigation) {
+    const bool supportsRainbow =
+        std::ranges::any_of(mProps.presets, [](const auto& preset) { return preset == "rainbow"; });
+    std::vector<Rml::String> compatibleHistory;
+    for (const auto& value : sColorHistory) {
+        if (parse_color(value, mProps.alpha).has_value() || (value == "rainbow" && supportsRainbow))
+        {
+            compatibleHistory.push_back(value);
+        }
+    }
+    if (compatibleHistory.empty()) {
+        return;
+    }
+    append_text(append(navigation.root(), "color-heading"), "Recent");
+    auto* gridElement = append(navigation.root(), "color-history");
+    auto& grid = navigation.add_existing_item<NavGroup>(
+        gridElement, NavGroup::Props{
+                         .layout = NavGroup::Layout::Grid,
+                         .columns = kSwatchColumns,
+                         .horizontalBoundary = NavGroup::Boundary::Stop,
+                         .verticalBoundary = NavGroup::Boundary::Bubble,
+                     });
+    for (const auto& value : compatibleHistory) {
+        add_swatch_button(grid, value);
+    }
+}
+
+void ColorInput::add_swatch_button(NavGroup& navigation, const Rml::String& value) {
+    auto& button = navigation.add_item<Button>("");
+    button.root()->SetClass("color-swatch-button", true);
+    dusk::ui::clear_children(button.root());
+    auto* chip = append(button.root(), "color-chip");
+    apply_swatch(chip, value, mProps.alpha);
+    Rml::String title = value == "rainbow" ? "Rainbow" : value;
+    if (const auto color = parse_color(value, mProps.alpha)) {
+        title = format_color(*color, true, mProps.alpha);
+    }
+    button.root()->SetAttribute("title", title);
+    button.on_pressed([this, value] {
+        mDoAud_seStartMenu(kSoundItemChange);
+        commit_value(value);
+    });
+}
+
+void ColorInput::begin_adjustment() {
+    mAdjustmentStartValue = mProps.getValue ? mProps.getValue() : "";
+    mAdjustmentStartHue = mHue;
+    mAdjustmentStartSat = mSat;
+    mAdjustmentStartVal = mVal;
+    mAdjustmentStartAlpha = mAlpha;
+}
+
+void ColorInput::cancel_adjustment() {
+    mHue = mAdjustmentStartHue;
+    mSat = mAdjustmentStartSat;
+    mVal = mAdjustmentStartVal;
+    mAlpha = mAdjustmentStartAlpha;
+    commit_value(mAdjustmentStartValue);
+}
+
+void ColorInput::adjust_sv(float x, float y, float deltaSeconds) {
+    const float sat =
+        std::clamp(mSat + analog_response(x) * kSvAnalogRate * deltaSeconds, 0.0f, 1.0f);
+    const float val =
+        std::clamp(mVal - analog_response(y) * kSvAnalogRate * deltaSeconds, 0.0f, 1.0f);
+    if (sat == mSat && val == mVal) {
+        return;
+    }
+    mSat = sat;
+    mVal = val;
+    commit_color();
+}
+
+void ColorInput::adjust_hue(float x, float deltaSeconds) {
+    const float hue =
+        std::clamp(mHue + analog_response(x) * kHueAnalogRate * deltaSeconds, 0.0f, 359.9f);
+    if (hue == mHue) {
+        return;
+    }
+    mHue = hue;
+    commit_color();
+}
+
+void ColorInput::adjust_alpha(float x, float deltaSeconds) {
+    const float alpha =
+        std::clamp(mAlpha + analog_response(x) * kAlphaAnalogRate * deltaSeconds, 0.0f, 1.0f);
+    if (alpha == mAlpha) {
+        return;
+    }
+    mAlpha = alpha;
+    commit_color();
+}
+
+void ColorInput::nudge_sv(NavCommand direction) {
+    const float sat = std::clamp(mSat + (direction == NavCommand::Right   ? kSvNudge :
+                                            direction == NavCommand::Left ? -kSvNudge :
+                                                                            0.0f),
+        0.0f, 1.0f);
+    const float val = std::clamp(mVal + (direction == NavCommand::Up      ? kSvNudge :
+                                            direction == NavCommand::Down ? -kSvNudge :
+                                                                            0.0f),
+        0.0f, 1.0f);
+    if (sat == mSat && val == mVal) {
+        return;
+    }
+    mSat = sat;
+    mVal = val;
+    mDoAud_seStartMenu(kSoundItemChange);
+    commit_color();
+}
+
+void ColorInput::nudge_hue(NavCommand direction) {
+    const float hue = std::clamp(mHue + (direction == NavCommand::Right   ? kHueNudge :
+                                            direction == NavCommand::Left ? -kHueNudge :
+                                                                            0.0f),
+        0.0f, 359.9f);
+    if (hue == mHue) {
+        return;
+    }
+    mHue = hue;
+    mDoAud_seStartMenu(kSoundItemChange);
+    commit_color();
+}
+
+void ColorInput::nudge_alpha(NavCommand direction) {
+    const float alpha = std::clamp(mAlpha + (direction == NavCommand::Right   ? kAlphaNudge :
+                                                direction == NavCommand::Left ? -kAlphaNudge :
+                                                                                0.0f),
+        0.0f, 1.0f);
+    if (alpha == mAlpha) {
+        return;
+    }
+    mAlpha = alpha;
+    mDoAud_seStartMenu(kSoundItemChange);
+    commit_color();
+}
+
+void ColorInput::commit_color() {
+    const auto color = current_color();
+    Rml::String value;
+    if (mProps.alpha && color.alpha != 255) {
+        value = fmt::format(
+            "{:02x}{:02x}{:02x}{:02x}", color.red, color.green, color.blue, color.alpha);
+    } else {
+        value = fmt::format("{:02x}{:02x}{:02x}", color.red, color.green, color.blue);
+    }
+    const bool changed = !mProps.getValue || mProps.getValue() != value;
+    if (changed) {
+        remember_initial_value();
+        if (mProps.setValue) {
+            mProps.setValue(std::move(value));
+        }
+        refresh_swatch();
+    }
+    refresh_picker();
+}
+
+void ColorInput::commit_value(Rml::String value) {
+    remember_initial_value();
+    value = normalize_value(std::move(value), mProps.alpha);
+    if (const auto color = parse_color(value, mProps.alpha)) {
+        rgb_to_hsv(*color, mHue, mSat, mVal);
+        mAlpha = static_cast<float>(color->alpha) / 255.0f;
+    }
+    if (mProps.setValue) {
+        mProps.setValue(std::move(value));
+    }
+    refresh_swatch();
+    refresh_picker();
+}
+
+void ColorInput::remember_initial_value() {
+    if (mInitialValueRemembered) {
+        return;
+    }
+    remember_color(mInitialValue, mProps.alpha);
+    mInitialValueRemembered = true;
+}
+
+void ColorInput::refresh_swatch() {
+    const Rml::String value = mProps.getValue ? mProps.getValue() : "";
+    if (mHasDisplayedValue && value == mDisplayedValue) {
+        return;
+    }
+    mHasDisplayedValue = true;
+    mDisplayedValue = value;
+    apply_swatch(mSwatch, value, mProps.alpha);
+}
+
+void ColorInput::refresh_picker() {
+    if (mPicker == nullptr) {
+        return;
+    }
+
+    const float dpRatio = mSvArea->GetContext()->GetDensityIndependentPixelRatio();
+    const auto place = [dpRatio](Rml::Element* cursor, float xDp, float yDp) {
+        cursor->SetProperty(Rml::PropertyId::Left,
+            Rml::Property{(xDp - kCursorDp / 2.0f) * dpRatio, Rml::Unit::PX});
+        cursor->SetProperty(
+            Rml::PropertyId::Top, Rml::Property{(yDp - kCursorDp / 2.0f) * dpRatio, Rml::Unit::PX});
+    };
+
+    const Rml::Colourb hueColor = hsv_to_rgb(mHue, 1.0f, 1.0f, 1.0f);
+    const Rml::Colourb color = current_color();
+    const Rml::Colourb opaque{color.red, color.green, color.blue, 255};
+
+    mSvArea->SetProperty(
+        "decorator", fmt::format("linear-gradient(180deg, rgba(0,0,0,0), #000000), "
+                                 "linear-gradient(90deg, #ffffff, {})",
+                         css_color(hueColor)));
+    place(mSvCursor, mSat * kSvWidthDp, (1.0f - mVal) * kSvHeightDp);
+    place(mHueCursor, mHue / 360.0f * kSvWidthDp, kBarHeightDp / 2.0f);
+    if (mAlphaBar != nullptr) {
+        mAlphaBar->SetProperty(
+            "decorator", fmt::format("linear-gradient(90deg, rgba({0},{1},{2},0), {3})", opaque.red,
+                             opaque.green, opaque.blue, css_color(opaque)));
+        place(mAlphaCursor, mAlpha * kSvWidthDp, kBarHeightDp / 2.0f);
+    }
+    set_text_content(mPickerValue, format_color(color, mHexFormat, mProps.alpha));
+}
+
+Rml::Colourb ColorInput::current_color() const {
+    return hsv_to_rgb(mHue, mSat, mVal, mAlpha);
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/color_input.hpp b/src/dusk/ui/color_input.hpp
new file mode 100644
index 0000000000..17523a6ca3
--- /dev/null
+++ b/src/dusk/ui/color_input.hpp
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "popover.hpp"
+#include "select_button.hpp"
+
+namespace dusk::ui {
+
+class NavGroup;
+
+class ColorInput : public BaseControlledSelectButton {
+public:
+    struct Props {
+        Rml::String key;
+        Popover::Side side = Popover::Side::Left;
+        std::function<Rml::String()> getValue;
+        std::function<void(Rml::String)> setValue;
+        std::function<bool()> isDisabled;
+        std::function<bool()> isModified;
+        std::vector<Rml::String> presets;
+        bool alpha = false;
+    };
+
+    ColorInput(Rml::Element* parent, Props props);
+    ~ColorInput() override;
+
+    void update() override;
+    bool modified() const override;
+    bool disabled() const override;
+
+protected:
+    Rml::String format_value() override;
+    bool handle_nav_command(NavCommand cmd) override;
+
+private:
+    void toggle_picker();
+    void build_picker();
+    void add_presets(NavGroup& navigation);
+    void add_history(NavGroup& navigation);
+    void add_swatch_button(NavGroup& navigation, const Rml::String& value);
+    void begin_adjustment();
+    void cancel_adjustment();
+    void adjust_sv(float x, float y, float deltaSeconds);
+    void adjust_hue(float x, float deltaSeconds);
+    void adjust_alpha(float x, float deltaSeconds);
+    void nudge_sv(NavCommand direction);
+    void nudge_hue(NavCommand direction);
+    void nudge_alpha(NavCommand direction);
+    void commit_color();
+    void commit_value(Rml::String value);
+    void remember_initial_value();
+    void refresh_swatch();
+    void refresh_picker();
+    Rml::Colourb current_color() const;
+
+    Props mProps;
+    Rml::Element* mSwatch = nullptr;
+    Rml::String mDisplayedValue;
+    Rml::String mInitialValue;
+    Rml::String mAdjustmentStartValue;
+    bool mHasDisplayedValue = false;
+
+    Popover* mPicker = nullptr;
+    Rml::Element* mSvArea = nullptr;
+    Rml::Element* mSvCursor = nullptr;
+    Rml::Element* mHueBar = nullptr;
+    Rml::Element* mHueCursor = nullptr;
+    Rml::Element* mAlphaBar = nullptr;
+    Rml::Element* mAlphaCursor = nullptr;
+    Rml::Element* mPickerValue = nullptr;
+    std::unique_ptr<NavGroup> mPickerNavigation;
+    std::vector<std::unique_ptr<ScopedEventListener>> mPickerListeners;
+
+    float mHue = 0.0f;
+    float mSat = 0.0f;
+    float mVal = 0.0f;
+    float mAlpha = 1.0f;
+    float mAdjustmentStartHue = 0.0f;
+    float mAdjustmentStartSat = 0.0f;
+    float mAdjustmentStartVal = 0.0f;
+    float mAdjustmentStartAlpha = 1.0f;
+    bool mHexFormat = true;
+    bool mInitialValueRemembered = false;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/command_console.cpp b/src/dusk/ui/command_console.cpp
new file mode 100644
index 0000000000..ae3eb4c1d4
--- /dev/null
+++ b/src/dusk/ui/command_console.cpp
@@ -0,0 +1,305 @@
+#include "command_console.hpp"
+
+#include <RmlUi/Core.h>
+#include <RmlUi/Core/Elements/ElementFormControlInput.h>
+#include <aurora/rmlui.hpp>
+
+#include "dusk/settings.h"
+
+#include <algorithm>
+#include <string>
+#include <string_view>
+
+#include "ui.hpp"
+
+namespace dusk::ui {
+namespace {
+
+const Rml::String kDocumentSource = R"RML(
+<rml>
+<head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
+    <link type="text/rcss" href="res/rml/command_console.rcss" />
+</head>
+<body>
+    <console id="console">
+        <output id="console-output"></output>
+        <input id="console-input" type="text" maxlength="255" />
+    </console>
+</body>
+</rml>
+)RML";
+
+bool is_command(std::string_view text) {
+    return text.size() >= 2 && text[0] == '>' && text[1] == ' ';
+}
+
+}  // namespace
+
+CommandConsole::CommandConsole() : Document(kDocumentSource, false, DocumentScope::CommandConsole) {
+    mConsole = mDocument ? mDocument->GetElementById("console") : nullptr;
+    mOutput = mDocument ? mDocument->GetElementById("console-output") : nullptr;
+    auto* rawInput = mDocument ? mDocument->GetElementById("console-input") : nullptr;
+    mInput = rmlui_dynamic_cast<Rml::ElementFormControlInput*>(rawInput);
+
+    listen(
+        Rml::EventId::Keydown,
+        [this](Rml::Event& event) {
+            if (!mInputActive) {
+                return;
+            }
+            const auto key = static_cast<Rml::Input::KeyIdentifier>(
+                event.GetParameter<int>("key_identifier", Rml::Input::KI_UNKNOWN));
+            if (key == Rml::Input::KI_RETURN) {
+                execute_from_input();
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_ESCAPE) {
+                hide(false);
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_UP) {
+                navigate_history(-1);
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_DOWN) {
+                navigate_history(1);
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_PRIOR) {
+                scroll_messages(-1);
+                event.StopImmediatePropagation();
+            } else if (key == Rml::Input::KI_NEXT) {
+                scroll_messages(1);
+                event.StopImmediatePropagation();
+            }
+        },
+        true);
+
+    listen(mOutput, Rml::EventId::Scroll, [this](Rml::Event&) {
+        const float bottom =
+            std::max(0.0f, mOutput->GetScrollHeight() - mOutput->GetClientHeight());
+        mStickToBottom = mOutput->GetScrollTop() >= bottom - 4.0f;
+    });
+}
+
+bool CommandConsole::handle_nav_command(Rml::Event&, NavCommand) {
+    return false;
+}
+
+void CommandConsole::update() {
+    if (!getSettings().backend.enableAdvancedSettings || is_prelaunch_open()) {
+        close_input();
+        Document::hide(false);
+        return;
+    }
+
+    update_message_lifetimes();
+    if (!mInputActive && !has_onscreen_messages()) {
+        Document::hide(false);
+        return;
+    }
+
+    if (!Document::visible()) {
+        Document::show();
+    }
+    if (mInputActive && mStickToBottom && mOutput != nullptr) {
+        mOutput->SetScrollTop(mOutput->GetScrollHeight() - mOutput->GetClientHeight());
+    }
+}
+
+void CommandConsole::show() {
+    if (mInputActive || !getSettings().backend.enableAdvancedSettings || is_prelaunch_open()) {
+        return;
+    }
+    mInputActive = true;
+    mHistoryPos = -1;
+    mStickToBottom = true;
+    if (mConsole != nullptr) {
+        mConsole->SetAttribute("open", "");
+    }
+    if (mOutput != nullptr) {
+        mOutput->SetAttribute("open", "");
+    }
+    if (mInput != nullptr) {
+        mInput->SetValue("");
+    }
+    Document::show();
+    focus();
+}
+
+bool CommandConsole::focus() {
+    if (mInputActive && mInput != nullptr) {
+        aurora::rmlui::set_input_type(aurora::rmlui::InputType::Text);
+        return mInput->Focus(true);
+    }
+    return false;
+}
+
+void CommandConsole::hide(bool close) {
+    close_input();
+    if (close) {
+        Document::hide(true);
+    } else if (!has_onscreen_messages()) {
+        Document::hide(false);
+    }
+
+    if (auto* doc = top_document()) {
+        doc->focus();
+    }
+}
+
+bool CommandConsole::visible() const {
+    return mInputActive && Document::visible();
+}
+
+bool CommandConsole::active() const {
+    return mInputActive && Document::active();
+}
+
+void CommandConsole::close_input() {
+    if (!mInputActive) {
+        return;
+    }
+    mInputActive = false;
+    mHistoryPos = -1;
+    if (mConsole != nullptr) {
+        mConsole->RemoveAttribute("open");
+    }
+    if (mInput != nullptr) {
+        mInput->SetValue("");
+        mInput->Blur();
+    }
+    if (mOutput != nullptr) {
+        mOutput->RemoveAttribute("open");
+    }
+}
+
+void CommandConsole::execute_from_input() {
+    if (mInput == nullptr) {
+        return;
+    }
+    const Rml::String value = mInput->GetValue();
+    hide(false);
+    if (!value.empty()) {
+        runCommand(value, mState, [this](std::string text) { append_message(std::move(text)); });
+    }
+}
+
+void CommandConsole::navigate_history(int direction) {
+    if (mState.history.empty() || mInput == nullptr) {
+        return;
+    }
+    const int prev = mHistoryPos;
+    if (direction < 0) {
+        if (mHistoryPos == -1) {
+            mHistoryPos = (int)mState.history.size() - 1;
+        } else if (mHistoryPos > 0) {
+            --mHistoryPos;
+        }
+    } else {
+        if (mHistoryPos != -1 && ++mHistoryPos >= (int)mState.history.size()) {
+            mHistoryPos = -1;
+        }
+    }
+    if (prev != mHistoryPos) {
+        const char* str = mHistoryPos >= 0 ? mState.history[mHistoryPos].c_str() : "";
+        mInput->SetValue(str);
+        const int end = static_cast<int>(Rml::StringUtilities::LengthUTF8(mInput->GetValue()));
+        mInput->SetSelectionRange(end, end);
+    }
+}
+
+void CommandConsole::scroll_messages(int pages) {
+    if (mOutput == nullptr) {
+        return;
+    }
+    const float bottom = std::max(0.0f, mOutput->GetScrollHeight() - mOutput->GetClientHeight());
+    const float pageHeight = std::max(1.0f, mOutput->GetClientHeight() * 0.9f);
+    const float scrollTop =
+        std::clamp(mOutput->GetScrollTop() + static_cast<float>(pages) * pageHeight, 0.0f, bottom);
+    mOutput->SetScrollTop(scrollTop);
+    mStickToBottom = scrollTop >= bottom - 4.0f;
+}
+
+void CommandConsole::append_message(std::string text) {
+    auto* element = append(mOutput, "line");
+    if (element != nullptr) {
+        element->SetClass("cmd", is_command(text));
+        append_text(element, text);
+    }
+
+    const auto now = clock::now();
+    mMessages.push_back({
+        .text = std::move(text),
+        .element = element,
+        .fadeAt = now + kMessageDuration - kFadeDuration,
+        .hideAt = now + kMessageDuration,
+    });
+
+    while (mMessages.size() > kMaxMessageHistory) {
+        if (auto* oldElement = mMessages.front().element; oldElement != nullptr) {
+            if (auto* parent = oldElement->GetParentNode()) {
+                parent->RemoveChild(oldElement);
+            }
+        }
+        mMessages.pop_front();
+    }
+    limit_visible_messages();
+    if (mConsole != nullptr) {
+        mConsole->RemoveAttribute("fading");
+    }
+
+    if (getSettings().backend.enableAdvancedSettings && !is_prelaunch_open() &&
+        !Document::visible())
+    {
+        Document::show();
+    }
+}
+
+void CommandConsole::limit_visible_messages() {
+    size_t visibleCount = 0;
+    for (auto it = mMessages.rbegin(); it != mMessages.rend(); ++it) {
+        if (it->expired) {
+            continue;
+        }
+        if (++visibleCount <= kMaxVisibleLines) {
+            continue;
+        }
+        it->expired = true;
+        if (it->element != nullptr) {
+            it->element->SetAttribute("expired", "");
+        }
+    }
+}
+
+void CommandConsole::update_message_lifetimes() {
+    const auto now = clock::now();
+    for (auto& message : mMessages) {
+        if (!message.fading && now >= message.fadeAt) {
+            message.fading = true;
+            if (message.element != nullptr) {
+                message.element->SetAttribute("fading", "");
+            }
+        }
+        if (!message.expired && now >= message.hideAt) {
+            message.expired = true;
+            if (message.element != nullptr) {
+                message.element->SetAttribute("expired", "");
+            }
+        }
+    }
+
+    const bool hasVisibleMessages = has_onscreen_messages();
+    const bool hasOpaqueMessages = std::ranges::any_of(
+        mMessages, [](const auto& message) { return !message.fading && !message.expired; });
+    if (mConsole != nullptr) {
+        if (hasVisibleMessages && !hasOpaqueMessages) {
+            mConsole->SetAttribute("fading", "");
+        } else {
+            mConsole->RemoveAttribute("fading");
+        }
+    }
+}
+
+bool CommandConsole::has_onscreen_messages() const {
+    return std::ranges::any_of(mMessages, [](const auto& message) { return !message.expired; });
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/command_console.hpp b/src/dusk/ui/command_console.hpp
new file mode 100644
index 0000000000..ef2f91ff90
--- /dev/null
+++ b/src/dusk/ui/command_console.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include "document.hpp"
+#include "dusk/commands.hpp"
+
+#include <chrono>
+#include <deque>
+#include <string>
+
+namespace Rml {
+class ElementFormControlInput;
+}
+
+namespace dusk::ui {
+
+class CommandConsole : public Document {
+public:
+    CommandConsole();
+
+    void update() override;
+    void show() override;
+    bool focus() override;
+    void hide(bool close) override;
+    bool visible() const override;
+    bool active() const override;
+    bool permanent() const override { return true; }
+
+    bool input_active() const { return mInputActive; }
+
+private:
+    struct MessageLine {
+        std::string text;
+        Rml::Element* element = nullptr;
+        clock::time_point fadeAt;
+        clock::time_point hideAt;
+        bool fading = false;
+        bool expired = false;
+    };
+
+    static constexpr auto kMessageDuration = std::chrono::seconds{6};
+    static constexpr auto kFadeDuration = std::chrono::milliseconds{800};
+    static constexpr size_t kMaxVisibleLines = 24;
+    static constexpr size_t kMaxMessageHistory = 500;
+
+    Rml::Element* mConsole = nullptr;
+    Rml::Element* mOutput = nullptr;
+    Rml::ElementFormControlInput* mInput = nullptr;
+
+    std::deque<MessageLine> mMessages;
+    int mHistoryPos = -1;
+    bool mInputActive = false;
+    bool mStickToBottom = true;
+
+    CommandState mState;
+
+    bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
+
+    void append_message(std::string text);
+    void close_input();
+    void execute_from_input();
+    bool has_onscreen_messages() const;
+    void limit_visible_messages();
+    void navigate_history(int direction);
+    void scroll_messages(int pages);
+    void update_message_lifetimes();
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/component.cpp b/src/dusk/ui/component.cpp
index 748df848be..ae49f7a8c3 100644
--- a/src/dusk/ui/component.cpp
+++ b/src/dusk/ui/component.cpp
@@ -49,13 +49,24 @@ void Component::set_disabled(bool value) {
     if (Component::disabled() == value) {
         return;
     }
+    auto* context = mRoot->GetContext();
     if (value) {
+        if (context != nullptr && context->GetFocusElement() == mRoot) {
+            // RmlUi moves focus to the parent when a focused control is disabled.
+            mDisabledFocusFallback = mRoot->GetParentNode();
+        }
         mRoot->SetAttribute("disabled", "");
         mRoot->SetPseudoClass("disabled", true);
         mRoot->Blur();
     } else {
+        const bool restoreFocus = mDisabledFocusFallback != nullptr && context != nullptr &&
+                                  context->GetFocusElement() == mDisabledFocusFallback;
         mRoot->RemoveAttribute("disabled");
         mRoot->SetPseudoClass("disabled", false);
+        mDisabledFocusFallback = nullptr;
+        if (restoreFocus) {
+            focus();
+        }
     }
 }
 
@@ -68,6 +79,15 @@ void Component::listen(Rml::Element* element, Rml::EventId event,
         std::make_unique<ScopedEventListener>(element, event, std::move(callback), capture));
 }
 
+void Component::listen(Rml::Element* element, const Rml::String& event,
+    ScopedEventListener::Callback callback, bool capture) {
+    if (element == nullptr) {
+        element = mRoot;
+    }
+    mListeners.emplace_back(
+        std::make_unique<ScopedEventListener>(element, event, std::move(callback), capture));
+}
+
 bool Component::contains(Rml::Element* element) const {
     for (const auto* node = element; node != nullptr; node = node->GetParentNode()) {
         if (node == mRoot) {
@@ -84,4 +104,4 @@ void Component::clear_children() {
     }
 }
 
-}  // namespace dusk::ui
\ No newline at end of file
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/component.hpp b/src/dusk/ui/component.hpp
index e0a602e7fd..f45bbf6a56 100644
--- a/src/dusk/ui/component.hpp
+++ b/src/dusk/ui/component.hpp
@@ -26,6 +26,7 @@ public:
 
     virtual void update();
     virtual bool focus();
+    virtual bool focus_from(NavCommand direction) { return focus(); }
 
     virtual bool selected() const { return mRoot->IsPseudoClassSet("selected"); }
     virtual void set_selected(bool selected);
@@ -34,10 +35,13 @@ public:
 
     void listen(Rml::Element* element, Rml::EventId event, ScopedEventListener::Callback callback,
         bool capture = false);
+    void listen(Rml::Element* element, const Rml::String& event,
+        ScopedEventListener::Callback callback, bool capture = false);
     bool contains(Rml::Element* element) const;
 
     template <typename T, typename... Args>
-    requires std::is_base_of_v<Component, T> T& add_child(Args&&... args) {
+        requires std::is_base_of_v<Component, T>
+    T& add_child(Args&&... args) {
         auto child = std::make_unique<T>(mRoot, std::forward<Args>(args)...);
         T& ref = *child;
         mChildren.emplace_back(std::move(child));
@@ -50,8 +54,9 @@ protected:
     void clear_children();
 
     Rml::Element* mRoot = nullptr;
-    std::vector<std::unique_ptr<Component> > mChildren;
-    std::vector<std::unique_ptr<ScopedEventListener> > mListeners;
+    Rml::Element* mDisabledFocusFallback = nullptr;
+    std::vector<std::unique_ptr<Component>> mChildren;
+    std::vector<std::unique_ptr<ScopedEventListener>> mListeners;
 };
 
 template <class Derived>
diff --git a/src/dusk/ui/context_menu.cpp b/src/dusk/ui/context_menu.cpp
new file mode 100644
index 0000000000..1799b4a6ad
--- /dev/null
+++ b/src/dusk/ui/context_menu.cpp
@@ -0,0 +1,76 @@
+#include "context_menu.hpp"
+
+#include "button.hpp"
+#include "icon_button.hpp"
+
+namespace dusk::ui {
+
+ContextMenu::Binding::Binding(Document& owner, Rml::Element* root, Rml::String selector,
+    std::function<std::vector<Item>(Rml::Element*)> items)
+    : mMouseDown{root, Rml::EventId::Mousedown,
+          [this, &owner, root, selector = std::move(selector), items = std::move(items)](
+              Rml::Event& event) {
+              if (event.GetParameter<int>("button", -1) != 1 || !owner.active()) {
+                  return;
+              }
+              auto* target = event.GetTargetElement()->Closest(selector);
+              if (target == nullptr || !root->Contains(target)) {
+                  return;
+              }
+              auto menuItems = items(target);
+              if (menuItems.empty()) {
+                  return;
+              }
+              dismiss();
+              auto menu = std::make_unique<ContextMenu>(target, std::move(menuItems),
+                  Rml::Vector2f{
+                      event.GetParameter<float>("mouse_x", 0),
+                      event.GetParameter<float>("mouse_y", 0),
+                  });
+              mMenu = menu.get();
+              mMenu->on_close([this] { mMenu = nullptr; });
+              push_document(std::move(menu));
+              event.StopPropagation();
+          }} {}
+
+ContextMenu::Binding::~Binding() {
+    dismiss();
+}
+
+void ContextMenu::Binding::dismiss() {
+    if (mMenu != nullptr) {
+        mMenu->on_close(nullptr);
+        mMenu->dismiss();
+        mMenu = nullptr;
+    }
+}
+
+ContextMenu::ContextMenu(
+    Rml::Element* anchor, std::vector<Item> items, std::optional<Rml::Vector2f> position)
+    : Popover{anchor, Side::Below, "context-menu"},
+      mNavigation{body(), {.horizontalBoundary = NavGroup::Boundary::Stop,
+                              .verticalBoundary = NavGroup::Boundary::Stop}} {
+    if (position) {
+        set_position(*position);
+    }
+    for (auto& item : items) {
+        if (item.separatorBefore && body()->GetNumChildren() != 0) {
+            append(body(), "menu-separator");
+        }
+        auto& button = mNavigation.add_item<Button>(Rml::String{});
+        append_text(append(button.root(), "icon"), material_icon(item.icon));
+        append_text_element(button.root(), "span", item.text);
+        button.root()->SetClass("destructive", item.destructive);
+        button.set_disabled(!item.enabled || !item.onPressed);
+        button.on_pressed([this, callback = std::move(item.onPressed)] {
+            dismiss();
+            callback();
+        });
+    }
+}
+
+bool ContextMenu::focus() {
+    return mNavigation.focus() || Popover::focus();
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/context_menu.hpp b/src/dusk/ui/context_menu.hpp
new file mode 100644
index 0000000000..700b9369be
--- /dev/null
+++ b/src/dusk/ui/context_menu.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "nav_group.hpp"
+#include "popover.hpp"
+
+namespace dusk::ui {
+
+class ContextMenu : public Popover {
+public:
+    struct Item {
+        Rml::String text;
+        Rml::String icon;
+        std::function<void()> onPressed;
+        bool enabled = true;
+        bool destructive = false;
+        bool separatorBefore = false;
+    };
+
+    class Binding {
+    public:
+        Binding(Document& owner, Rml::Element* root, Rml::String selector,
+            std::function<std::vector<Item>(Rml::Element*)> items);
+        ~Binding();
+
+        void dismiss();
+
+    private:
+        ContextMenu* mMenu = nullptr;
+        ScopedEventListener mMouseDown;
+    };
+
+    ContextMenu(Rml::Element* anchor, std::vector<Item> items,
+        std::optional<Rml::Vector2f> position = std::nullopt);
+
+    bool focus() override;
+
+private:
+    NavGroup mNavigation;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/controller_config.cpp b/src/dusk/ui/controller_config.cpp
index b57b16eba5..ad85d85c55 100644
--- a/src/dusk/ui/controller_config.cpp
+++ b/src/dusk/ui/controller_config.cpp
@@ -291,10 +291,9 @@ void ControllerConfigWindow::build_port_tab(Rml::Element* content, int port) {
     mActivePort = port;
 
     auto addPageButton = [this, &leftPane, &rightPane, port](
-                             Page page, Rml::String key, auto getValue, auto isDisabled) {
-        leftPane.register_control(leftPane.add_select_button({
-                                      .key = std::move(key),
-                                      .getValue = std::move(getValue),
+                             Page page, Rml::String text, std::function<bool()> isDisabled = {}) {
+        leftPane.register_control(leftPane.add_group_button({
+                                      .text = std::move(text),
                                       .isDisabled = std::move(isDisabled),
                                   }),
             rightPane, [this, port, page](Pane& pane) {
@@ -303,12 +302,20 @@ void ControllerConfigWindow::build_port_tab(Rml::Element* content, int port) {
             });
     };
 
-    addPageButton(Page::Controller, "Device", [port] { return current_controller_name(port); }, [] { return false; });
-    addPageButton(Page::Buttons, "Buttons", [] { return Rml::String(">"); }, [] { return false; });
-    addPageButton(Page::Triggers, "Triggers", [] { return Rml::String(">"); }, [] { return false; });
-    addPageButton(Page::Sticks, "Sticks", [] { return Rml::String(">"); }, [] { return false; });
-    addPageButton(Page::Rumble, "Rumble", [] { return Rml::String(">"); }, [port] { return !PADSupportsRumbleIntensity(static_cast<u32>(port)); });
-    addPageButton(Page::Actions, "Custom Action Bindings", [] {return Rml::String(">"); }, [] { return false; });
+    leftPane.register_control(leftPane.add_select_button({
+                                  .key = "Device",
+                                  .getValue = [port] { return current_controller_name(port); },
+                              }),
+        rightPane, [this, port](Pane& pane) {
+            mPage = Page::Controller;
+            render_page(pane, port, Page::Controller);
+        });
+    addPageButton(Page::Buttons, "Buttons");
+    addPageButton(Page::Triggers, "Triggers");
+    addPageButton(Page::Sticks, "Sticks");
+    addPageButton(Page::Rumble, "Rumble",
+        [port] { return !PADSupportsRumbleIntensity(static_cast<u32>(port)); });
+    addPageButton(Page::Actions, "Custom Action Bindings");
 
     leftPane.add_section("Options");
     leftPane.register_control(leftPane.add_child<BoolButton>(BoolButton::Props{
diff --git a/src/dusk/ui/document.cpp b/src/dusk/ui/document.cpp
index 2b387f3fe9..3278361f83 100644
--- a/src/dusk/ui/document.cpp
+++ b/src/dusk/ui/document.cpp
@@ -1,10 +1,11 @@
 #include "document.hpp"
 
-#include "aurora/rmlui.hpp"
 #include "ui.hpp"
 
 #include "m_Do/m_Do_audio.h"
 
+#include <aurora/rmlui.hpp>
+
 #include <algorithm>
 
 namespace dusk::ui {
@@ -84,6 +85,7 @@ void Document::show() {
             focus();
         }
     }
+    mPendingClose = false;
 }
 
 void Document::hide(bool close) {
@@ -101,6 +103,15 @@ bool Document::focus() {
     return false;
 }
 
+bool Document::has_focus() const {
+    if (mDocument == nullptr) {
+        return false;
+    }
+    auto* context = mDocument->GetContext();
+    const auto* focused = context != nullptr ? context->GetFocusElement() : nullptr;
+    return focused != nullptr && focused->GetOwnerDocument() == mDocument;
+}
+
 bool Document::set_document_styles(const Rml::String& rcss) {
     if (rcss.empty()) {
         mDocumentStyleSheets = nullptr;
diff --git a/src/dusk/ui/document.hpp b/src/dusk/ui/document.hpp
index e7bd35947d..99bde20c18 100644
--- a/src/dusk/ui/document.hpp
+++ b/src/dusk/ui/document.hpp
@@ -20,8 +20,10 @@ public:
     virtual void hide(bool close);
     virtual void update();
     virtual bool focus();
+    bool has_focus() const;
     virtual bool visible() const;
     virtual bool active() const;
+    virtual bool permanent() const { return false; }
     virtual bool obscures_game() const { return false; }
     virtual void cover() {
         mWasVisible = visible();
@@ -64,7 +66,12 @@ public:
         hide(true);
         uncover_top_document();
     }
+    void force_hide(bool close) {
+        hide(close);
+        Document::hide(close);
+    }
 
+    bool pending_close() const { return mPendingClose; }
     bool closed() const { return mClosed; }
 
     bool handle_nav_event(Rml::Event& event);
diff --git a/src/dusk/ui/drop_install_modal.cpp b/src/dusk/ui/drop_install_modal.cpp
new file mode 100644
index 0000000000..6049db5aeb
--- /dev/null
+++ b/src/dusk/ui/drop_install_modal.cpp
@@ -0,0 +1,158 @@
+#include "drop_install_modal.hpp"
+
+#include "dusk/mods/loader/loader.hpp"
+#include "dusk/mods/loader/packages.hpp"
+#include "dusk/mods/queue.hpp"
+#include "format.hpp"
+#include "package_row.hpp"
+#include "queue_window.hpp"
+
+#include <borealis/io.hpp>
+#include <borealis/update.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+
+namespace dusk::ui {
+namespace {
+
+size_t valid_count(const std::vector<DropPackage>& packages) {
+    return std::ranges::count(packages, true, &DropPackage::valid);
+}
+
+std::vector<DropPackage> prepare_packages(std::vector<DropPackage> packages) {
+    std::vector<std::string> batchIds;
+    for (auto& package : packages) {
+        if (!package.error.empty()) {
+            package.status = package.error;
+        } else if (std::ranges::find(batchIds, package.metadata.id) != batchIds.end()) {
+            package.status = "Duplicate package in this drop";
+        } else if (!borealis::update::parse_version(package.metadata.version)) {
+            package.status = "Invalid package version";
+        } else if (package.hasNative && !mods::EnableCodeMods) {
+            package.status = "Native mods cannot be installed on this platform";
+        } else if (const auto queued = mods::queue::find_by_mod_id(package.metadata.id);
+            queued && !mods::queue::is_terminal(queued->state))
+        {
+            package.status = "Already in the install queue";
+        } else if (const auto* installed =
+                       mods::ModLoader::instance().find_mod(package.metadata.id))
+        {
+            if (!mods::ModLoader::instance().can_update(*installed)) {
+                package.status = "A development directory cannot be replaced";
+            } else if (mods::compare_package_versions(
+                           package.metadata.version, installed->metadata.version) < 0) {
+                package.status = "A newer version is already installed";
+            } else if (mods::compare_package_versions(
+                           package.metadata.version, installed->metadata.version) == 0) {
+                package.status = fmt::format("Reinstall {}", package.metadata.version);
+                package.valid = true;
+            } else {
+                package.status = fmt::format("Update from {}", installed->metadata.version);
+                package.valid = true;
+            }
+        } else {
+            package.status = "New";
+            package.valid = true;
+        }
+        batchIds.push_back(package.metadata.id);
+    }
+    return packages;
+}
+
+}  // namespace
+
+std::vector<DropPackage> inspect_drop_packages(
+    const std::vector<std::filesystem::path>& paths, borealis::TaskContext& context) {
+    std::vector<DropPackage> packages;
+    packages.reserve(paths.size());
+    for (const auto& path : paths) {
+        if (context.cancel_requested()) {
+            break;
+        }
+        DropPackage package{.path = path};
+        std::error_code error;
+        package.size = std::filesystem::file_size(path, error);
+        if (error) {
+            package.error = fmt::format("Could not read package: {}", error.message());
+        } else if (!mods::inspect_mod_bundle(
+                       path, package.metadata, package.error, &package.hasNative))
+        {
+            package.error = fmt::format("Invalid package: {}", package.error);
+        }
+        packages.push_back(std::move(package));
+        context.report_progress(packages.size(), paths.size());
+    }
+    return packages;
+}
+
+DropInstallModal::DropInstallModal(std::vector<DropPackage> packages)
+    : DropInstallModal{prepare_packages(std::move(packages)), PreparedTag{}} {}
+
+DropInstallModal::DropInstallModal(std::vector<DropPackage> packages, PreparedTag)
+    : Modal{Props{
+          .title = "Install mods?",
+          .bodyText = "Only install mods from trusted authors.",
+          .actions =
+              {
+                  ModalAction{
+                      .label = "Cancel",
+                      .onPressed = [](Modal& modal) { modal.pop(); },
+                      .isDisabled = {},
+                  },
+                  ModalAction{
+                      .label = fmt::format("Install {}", valid_count(packages)),
+                      .onPressed = [this](Modal&) { install(); },
+                      .isDisabled = [this] { return valid_count(mPackages) == 0; },
+                  },
+              },
+          .variant = "drop-install",
+      }},
+      mPackages{std::move(packages)} {
+    auto& pane = content_pane();
+    for (auto& package : mPackages) {
+        auto& row = pane.add_child<PackageRow>();
+        const auto name = package.metadata.name.empty() ?
+                              borealis::io::fs_path_to_string(package.path.filename()) :
+                              package.metadata.name;
+        const auto version =
+            package.metadata.name.empty() ? std::string{} : package.metadata.version;
+        const auto detail =
+            package.metadata.author.empty() ?
+                format_bytes(package.size) :
+                fmt::format("{} · {}", package.metadata.author, format_bytes(package.size));
+        row.set_package(name, version, package.status, detail, package.valid ? "queued" : "failed");
+        row.set_disabled(!package.valid);
+    }
+}
+
+void DropInstallModal::install() {
+    std::string firstKey;
+    for (const auto& package : mPackages) {
+        if (!package.valid) {
+            continue;
+        }
+        std::string key;
+        if (mods::queue::enqueue(
+                {
+                    .id = package.metadata.id,
+                    .name = package.metadata.name,
+                    .version = package.metadata.version,
+                    .source = mods::queue::LocalFile{package.path},
+                },
+                &key) &&
+            firstKey.empty())
+        {
+            firstKey = std::move(key);
+        }
+    }
+    pop();
+    if (!firstKey.empty()) {
+        if (auto* current = top_document()) {
+            current->cover();
+        }
+        push_document(std::make_unique<QueueWindow>(std::move(firstKey)));
+    }
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/drop_install_modal.hpp b/src/dusk/ui/drop_install_modal.hpp
new file mode 100644
index 0000000000..06d6389f61
--- /dev/null
+++ b/src/dusk/ui/drop_install_modal.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include "dusk/mod_loader.hpp"
+#include "modal.hpp"
+
+#include <borealis/task.hpp>
+
+#include <cstdint>
+#include <filesystem>
+#include <string>
+#include <vector>
+
+namespace dusk::ui {
+
+struct DropPackage {
+    std::filesystem::path path;
+    mods::ModMetadata metadata;
+    uint64_t size = 0;
+    std::string error;
+    std::string status;
+    bool hasNative = false;
+    bool valid = false;
+};
+
+std::vector<DropPackage> inspect_drop_packages(
+    const std::vector<std::filesystem::path>& paths, borealis::TaskContext& context);
+
+class DropInstallModal final : public Modal {
+public:
+    explicit DropInstallModal(std::vector<DropPackage> packages);
+
+private:
+    struct PreparedTag {};
+    DropInstallModal(std::vector<DropPackage> packages, PreparedTag);
+    void install();
+
+    std::vector<DropPackage> mPackages;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/editor.cpp b/src/dusk/ui/editor.cpp
index 8aa3c3894d..d4373e059a 100644
--- a/src/dusk/ui/editor.cpp
+++ b/src/dusk/ui/editor.cpp
@@ -275,7 +275,7 @@ std::map<int, itemInfo> itemMap = {
     {dItemNo_WEAR_KOKIRI_e, {"Hero's Clothes"}},
     {dItemNo_ARMOR_e, {"Magic Armor"}},
     {dItemNo_WEAR_ZORA_e, {"Zora Armor"}},
-    {dItemNo_MAGIC_LV1_e, {"Magic Level 1"}},
+    {dItemNo_SHADOW_CRYSTAL_e, {"Shadow Crystal"}},
     {dItemNo_DUNGEON_EXIT_2_e, {"Ooccoo Sr.", ITEMTYPE_EQUIP_e}},
     {dItemNo_WALLET_LV1_e, {"Wallet"}},
     {dItemNo_WALLET_LV2_e, {"Big Wallet"}},
diff --git a/src/dusk/ui/file_button.cpp b/src/dusk/ui/file_button.cpp
new file mode 100644
index 0000000000..0b5954512a
--- /dev/null
+++ b/src/dusk/ui/file_button.cpp
@@ -0,0 +1,71 @@
+#include "file_button.hpp"
+
+#include <aurora/lib/window.hpp>
+#include <borealis/io.hpp>
+
+#include <utility>
+
+namespace dusk::ui {
+
+FileButton::FileButton(Rml::Element* parent, Props props)
+    : BaseControlledSelectButton{parent, {.key = std::move(props.key)}},
+      mGetValue{std::move(props.getValue)}, mSetValue{std::move(props.setValue)},
+      mIsDisabled{std::move(props.isDisabled)}, mIsModified{std::move(props.isModified)},
+      mFilters{std::move(props.filters)}, mDirectoryMode{props.directoryMode} {}
+
+bool FileButton::modified() const {
+    return mIsModified ? mIsModified() : BaseControlledSelectButton::modified();
+}
+
+bool FileButton::disabled() const {
+    return borealis::file_select::busy() || (mIsDisabled && mIsDisabled());
+}
+
+Rml::String FileButton::format_value() {
+    const Rml::String location = mGetValue ? mGetValue() : "";
+    if (location.empty()) {
+        return "(none)";
+    }
+    const auto name = borealis::io::display_name(location);
+    return name.empty() ? location : name;
+}
+
+bool FileButton::handle_nav_command(NavCommand command) {
+    if (command != NavCommand::Confirm) {
+        return false;
+    }
+    open_picker();
+    return true;
+}
+
+void FileButton::open_picker() {
+    if (disabled()) {
+        return;
+    }
+    const std::string defaultLocation = mGetValue ? mGetValue() : "";
+    auto complete = [setValue = mSetValue](borealis::file_select::Result result) {
+        if (result.status == borealis::file_select::Status::Selected && !result.locations.empty() &&
+            setValue)
+        {
+            setValue(std::move(result.locations.front()));
+        }
+    };
+    if (mDirectoryMode) {
+        borealis::file_select::open_folder(
+            {
+                .parentWindow = aurora::window::get_sdl_window(),
+                .defaultLocation = defaultLocation,
+            },
+            std::move(complete));
+        return;
+    }
+    borealis::file_select::open_file(
+        {
+            .parentWindow = aurora::window::get_sdl_window(),
+            .filters = mFilters,
+            .defaultLocation = defaultLocation,
+        },
+        std::move(complete));
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/file_button.hpp b/src/dusk/ui/file_button.hpp
new file mode 100644
index 0000000000..487dd70724
--- /dev/null
+++ b/src/dusk/ui/file_button.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "select_button.hpp"
+
+#include <borealis/file_select.hpp>
+
+#include <functional>
+#include <vector>
+
+namespace dusk::ui {
+
+class FileButton : public BaseControlledSelectButton {
+public:
+    struct Props {
+        Rml::String key;
+        std::function<Rml::String()> getValue;
+        std::function<void(Rml::String)> setValue;
+        std::function<bool()> isDisabled;
+        std::function<bool()> isModified;
+        std::vector<borealis::file_select::Filter> filters;
+        bool directoryMode = false;
+    };
+
+    FileButton(Rml::Element* parent, Props props);
+    bool modified() const override;
+    bool disabled() const override;
+
+protected:
+    Rml::String format_value() override;
+    bool handle_nav_command(NavCommand command) override;
+
+private:
+    void open_picker();
+
+    std::function<Rml::String()> mGetValue;
+    std::function<void(Rml::String)> mSetValue;
+    std::function<bool()> mIsDisabled;
+    std::function<bool()> mIsModified;
+    std::vector<borealis::file_select::Filter> mFilters;
+    bool mDirectoryMode = false;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/format.hpp b/src/dusk/ui/format.hpp
new file mode 100644
index 0000000000..03a8dadf90
--- /dev/null
+++ b/src/dusk/ui/format.hpp
@@ -0,0 +1,111 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include <charconv>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+namespace dusk::ui {
+
+struct ByteFormat {
+    int gibFractionDigits = 1;
+    int mibFractionDigits = 1;
+};
+
+inline std::string format_count(uint64_t value) {
+    if (value >= 1'000'000) {
+        return fmt::format("{:.1f}m", static_cast<double>(value) / 1'000'000.0);
+    }
+    if (value >= 1'000) {
+        return fmt::format("{:.1f}k", static_cast<double>(value) / 1'000.0);
+    }
+    return fmt::format("{}", value);
+}
+
+inline std::string display_date(std::string_view timestamp) {
+    return std::string{timestamp.substr(0, 10)};
+}
+
+inline std::string relative_date(std::string_view timestamp) {
+    if (timestamp.size() < 10 || timestamp[4] != '-' || timestamp[7] != '-') {
+        return display_date(timestamp);
+    }
+    int yearValue = 0;
+    unsigned monthValue = 0;
+    unsigned dayValue = 0;
+    const auto parse = [](std::string_view text, auto& value) {
+        const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), value);
+        return error == std::errc{} && end == text.data() + text.size();
+    };
+    if (!parse(timestamp.substr(0, 4), yearValue) || !parse(timestamp.substr(5, 2), monthValue) ||
+        !parse(timestamp.substr(8, 2), dayValue))
+    {
+        return display_date(timestamp);
+    }
+
+    const std::chrono::year_month_day date{
+        std::chrono::year{yearValue}, std::chrono::month{monthValue}, std::chrono::day{dayValue}};
+    if (!date.ok()) {
+        return display_date(timestamp);
+    }
+    const auto today = std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now());
+    const auto age = (today - std::chrono::sys_days{date}).count();
+    if (age < 0) {
+        return display_date(timestamp);
+    }
+    if (age == 0) {
+        return "today";
+    }
+    if (age == 1) {
+        return "yesterday";
+    }
+    if (age < 7) {
+        return fmt::format("{} days ago", age);
+    }
+    if (age < 30) {
+        const auto weekCount = age / 7;
+        return fmt::format("{} week{} ago", weekCount, weekCount == 1 ? "" : "s");
+    }
+    if (age < 365) {
+        const auto monthCount = age / 30;
+        return fmt::format("{} month{} ago", monthCount, monthCount == 1 ? "" : "s");
+    }
+    const auto yearCount = age / 365;
+    return fmt::format("{} year{} ago", yearCount, yearCount == 1 ? "" : "s");
+}
+
+inline std::string format_bytes(uint64_t bytes, ByteFormat options = {}) {
+    constexpr double kiB = 1024.0;
+    constexpr double miB = kiB * 1024.0;
+    constexpr double giB = miB * 1024.0;
+    if (bytes >= static_cast<uint64_t>(giB)) {
+        return fmt::format(
+            "{:.{}f} GiB", static_cast<double>(bytes) / giB, options.gibFractionDigits);
+    }
+    if (bytes >= static_cast<uint64_t>(miB)) {
+        return fmt::format(
+            "{:.{}f} MiB", static_cast<double>(bytes) / miB, options.mibFractionDigits);
+    }
+    if (bytes >= static_cast<uint64_t>(kiB)) {
+        return fmt::format("{:.0f} KiB", static_cast<double>(bytes) / kiB);
+    }
+    return fmt::format("{} B", bytes);
+}
+
+// Truncates without splitting a UTF-8 sequence.
+inline std::string snippet(std::string_view text, size_t maxBytes) {
+    if (text.size() <= maxBytes) {
+        return std::string{text};
+    }
+    size_t end = maxBytes;
+    while (end > 0 && (static_cast<unsigned char>(text[end]) & 0xC0) == 0x80) {
+        --end;
+    }
+    return fmt::format("{}...", text.substr(0, end));
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/graphics_tuner.cpp b/src/dusk/ui/graphics_tuner.cpp
index cddcf06330..5266319471 100644
--- a/src/dusk/ui/graphics_tuner.cpp
+++ b/src/dusk/ui/graphics_tuner.cpp
@@ -1,20 +1,18 @@
 #include "graphics_tuner.hpp"
 
-#include "Z2AudioLib/Z2SeMgr.h"
-#include "m_Do/m_Do_audio.h"
-
-#include <aurora/aurora.h>
-#include <aurora/gfx.h>
-#include <dolphin/gx/GXAurora.h>
-#include <dolphin/vi.h>
-#include <fmt/format.h>
+#include "button.hpp"
 
 #include "dusk/config.hpp"
+#include "dusk/logging.h"
 #include "dusk/settings.h"
-#include "dusk/texture_replacements.hpp"
+#include "m_Do/m_Do_audio.h"
+
+#include <dolphin/gx/GXAurora.h>
+#include <fmt/format.h>
 
 #include <algorithm>
 #include <string>
+#include <type_traits>
 
 namespace dusk::ui {
 namespace {
@@ -22,104 +20,117 @@ namespace {
 const Rml::String kDocumentSource = R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/tuner.rcss" />
 </head>
 <body>
-    <div id="root" class="tuner-root">
-        <div class="tuner">
-            <div class="header">
-                <div id="title"></div>
-                <div id="carousel-container" class="carousel-container"></div>
-            </div>
-            <div id="description" class="description"></div>
-            <div class="divider"></div>
-            <div id="footer" class="footer"></div>
-        </div>
-    </div>
+    <tuner-root id="root">
+        <graphics-tuner>
+            <tuner-header>
+                <tuner-title id="title" />
+                <carousel-container id="carousel-container" />
+            </tuner-header>
+            <tuner-description id="description" />
+            <tuner-divider />
+            <tuner-footer id="footer" />
+        </graphics-tuner>
+    </tuner-root>
 </body>
 </rml>
 )RML";
 
-int get_value(GraphicsOption option) {
-    switch (option) {
-    case GraphicsOption::InternalResolution:
-        return getSettings().game.internalResolutionScale.getValue();
-    case GraphicsOption::ShadowResolution:
-        return getSettings().game.shadowResolutionMultiplier.getValue();
-    case GraphicsOption::Resampler:
-        return static_cast<int>(getSettings().game.resampler.getValue());
-    case GraphicsOption::BloomMode:
-        return static_cast<int>(getSettings().game.bloomMode.getValue());
-    case GraphicsOption::BloomMultiplier:
-        return std::clamp(
-            static_cast<int>(getSettings().game.bloomMultiplier.getValue() * 100.0f + 0.5f), 0,
-            100);
-    case GraphicsOption::DepthOfFieldMode:
-        return static_cast<int>(getSettings().game.depthOfFieldMode.getValue());
-    case GraphicsOption::TextureReplacements:
-        return getSettings().game.enableTextureReplacements.getValue();
+Rml::String format_internal_resolution(int value) {
+    u32 width = 0;
+    u32 height = 0;
+    AuroraGetRenderSize(&width, &height);
+    if (value <= 0) {
+        return fmt::format("Auto ({}×{})", width, height);
     }
-    return 0;
+    return fmt::format("{}× ({}×{})", value, width, height);
 }
 
-void set_value(GraphicsOption option, int value) {
-    switch (option) {
-    case GraphicsOption::InternalResolution:
-        getSettings().game.internalResolutionScale.setValue(value);
-        VISetFrameBufferScale(static_cast<float>(value));
-        break;
-    case GraphicsOption::ShadowResolution:
-        getSettings().game.shadowResolutionMultiplier.setValue(value);
-        break;
-    case GraphicsOption::Resampler: {
-        const auto sampler = static_cast<Resampler>(std::clamp(value,
-            static_cast<int>(Resampler::Bilinear),
-            static_cast<int>(Resampler::Area)));
-        getSettings().game.resampler.setValue(sampler);
-        switch (sampler) {
-        case Resampler::Area:
-            aurora_set_resampler(SAMPLER_AREA);
-            break;
-        case Resampler::Bilinear:
-        default:
-            aurora_set_resampler(SAMPLER_BILINEAR);
-            break;
-        }
-        break;
+Rml::String format_resampler(int value) {
+    switch (static_cast<Resampler>(value)) {
+    case Resampler::Bilinear:
+        return "Bilinear";
+    case Resampler::Area:
+        return "Area";
+    default:
+        return "";
     }
-    case GraphicsOption::BloomMode:
-        getSettings().game.bloomMode.setValue(static_cast<BloomMode>(std::clamp(
-            value, static_cast<int>(BloomMode::Off), static_cast<int>(BloomMode::Dusk))));
-        break;
-    case GraphicsOption::DepthOfFieldMode:
-        getSettings().game.depthOfFieldMode.setValue(static_cast<DepthOfFieldMode>(std::clamp(
-            value, static_cast<int>(DepthOfFieldMode::Off), static_cast<int>(DepthOfFieldMode::Dusk))));
-        break;
-    case GraphicsOption::BloomMultiplier:
-        getSettings().game.bloomMultiplier.setValue(std::clamp(value, 0, 100) / 100.0f);
-        break;
-    case GraphicsOption::TextureReplacements:
-        texture_replacements::set_enabled(static_cast<bool>(value));
-        break;
+}
+
+Rml::String format_post_process_mode(int value) {
+    switch (static_cast<BloomMode>(value)) {
+    case BloomMode::Off:
+        return "Off";
+    case BloomMode::Classic:
+        return "Classic";
+    case BloomMode::Dusk:
+        return "Dusklight";
+    default:
+        return "";
     }
 }
 
+Rml::String format_times(int value) { return fmt::format("{}×", value); }
+
+Rml::String format_percent(int value) { return fmt::format("{}%", value); }
+
+Rml::String format_bool(int value) { return value ? "On" : "Off"; }
+
+template <typename T>
+int read_cvar(const ConfigVar<T>& var) {
+    if constexpr (std::is_same_v<T, float>) {
+        return static_cast<int>(var.getValue() * 100.0f + 0.5f);
+    } else {
+        return static_cast<int>(var.getValue());
+    }
+}
+
+template <typename T>
+void write_cvar(ConfigVar<T>& var, int value) {
+    if constexpr (std::is_same_v<T, float>) {
+        var.setValue(static_cast<float>(value) / 100.0f);
+    } else if constexpr (std::is_same_v<T, bool>) {
+        var.setValue(static_cast<bool>(value));
+    } else {
+        var.setValue(static_cast<T>(value));
+    }
+}
+
+template <auto Var, typename Min, typename Max, typename Def>
+const GraphicsSetting& bind(Min min, Max max, Def def, int step, Rml::String (*label)(int),
+    bool watchSize = false) {
+    static const GraphicsSetting desc{
+        .min = static_cast<int>(min),
+        .max = static_cast<int>(max),
+        .defaultValue = static_cast<int>(def),
+        .step = step,
+        .watchesRenderSize = watchSize,
+        .read = []() -> int { return read_cvar(Var()); },
+        .write = [](int value) { write_cvar(Var(), value); },
+        .label = label,
+        .cvarName = []() -> const char* { return Var().getName(); },
+        .isModified = []() -> bool { return Var().getValue() != Var().getDefaultValue(); },
+    };
+    return desc;
+}
+
 Rml::Element* create_stepped_carousel_root(Rml::Element* parent) {
     auto* doc = parent->GetOwnerDocument();
-    auto root = doc->CreateElement("div");
-    root->SetClass("stepped-carousel", true);
+    auto root = doc->CreateElement("stepped-carousel");
     root->SetAttribute("tabindex", "0");
     return parent->AppendChild(std::move(root));
 }
 
 Rml::Element* create_stepped_carousel_arrow(
     Rml::Element* parent, const Rml::String& className, const Rml::String& label) {
-    auto* doc = parent->GetOwnerDocument();
-    auto button = doc->CreateElement("button");
+    auto* button = append(parent, "button");
     button->SetClass("stepped-carousel-arrow", true);
     button->SetClass(className, true);
-    button->SetInnerRML(label);
-    return parent->AppendChild(std::move(button));
+    append_text(button, label);
+    return button;
 }
 
 void update_carousel_arrow_color(Rml::Element* arrow, bool dim) {
@@ -129,12 +140,40 @@ void update_carousel_arrow_color(Rml::Element* arrow, bool dim) {
 
 }  // namespace
 
+const GraphicsSetting& GraphicsSetting::of(GraphicsOption option) {
+    switch (option) {
+    case GraphicsOption::InternalResolution:
+        return bind<[]() -> auto& { return getSettings().game.internalResolutionScale; }>(
+            0, 12, 0, 1, format_internal_resolution, true);
+    case GraphicsOption::ShadowResolution:
+        return bind<[]() -> auto& { return getSettings().game.shadowResolutionMultiplier; }>(
+            1, 8, 1, 1, format_times);
+    case GraphicsOption::Resampler:
+        return bind<[]() -> auto& { return getSettings().game.resampler; }>(
+            Resampler::Bilinear, Resampler::Area, Resampler::Bilinear, 1, format_resampler);
+    case GraphicsOption::BloomMode:
+        return bind<[]() -> auto& { return getSettings().game.bloomMode; }>(
+            BloomMode::Off, BloomMode::Dusk, BloomMode::Classic, 1, format_post_process_mode);
+    case GraphicsOption::BloomMultiplier:
+        return bind<[]() -> auto& { return getSettings().game.bloomMultiplier; }>(
+            0, 100, 100, 10, format_percent);
+    case GraphicsOption::DepthOfFieldMode:
+        return bind<[]() -> auto& { return getSettings().game.depthOfFieldMode; }>(
+            DepthOfFieldMode::Off, DepthOfFieldMode::Dusk, DepthOfFieldMode::Classic, 1,
+            format_post_process_mode);
+    case GraphicsOption::TextureReplacements:
+        return bind<[]() -> auto& { return getSettings().game.enableTextureReplacements; }>(
+            0, 1, 0, 1, format_bool);
+    }
+    DuskLog.error("{} is an invalid GraphicsOption", static_cast<int>(option));
+    abort();
+}
+
 SteppedCarousel::SteppedCarousel(Rml::Element* parent, Props props)
     : Component(create_stepped_carousel_root(parent)), mProps(std::move(props)) {
-    mPrevElem = create_stepped_carousel_arrow(mRoot, "prev", "&#xe5cb;");
-    mValueElem = append(mRoot, "div");
-    mValueElem->SetClass("stepped-carousel-value", true);
-    mNextElem = create_stepped_carousel_arrow(mRoot, "next", "&#xe5cc;");
+    mPrevElem = create_stepped_carousel_arrow(mRoot, "prev", "\uE5CB");
+    mValueElem = append(mRoot, "stepped-carousel-value");
+    mNextElem = create_stepped_carousel_arrow(mRoot, "next", "\uE5CC");
 
     listen(mPrevElem, Rml::EventId::Click,
         [this](Rml::Event&) { handle_nav_command(NavCommand::Left); });
@@ -152,15 +191,17 @@ bool SteppedCarousel::focus() {
     return Component::focus();
 }
 
-void SteppedCarousel::update() {
+void SteppedCarousel::update() {}
+
+void SteppedCarousel::refresh() {
     if (mValueElem == nullptr) {
         return;
     }
     const int value = std::clamp(mProps.getValue ? mProps.getValue() : 0, mProps.min, mProps.max);
     if (mProps.formatValue) {
-        mValueElem->SetInnerRML(mProps.formatValue(value));
+        set_text_content(mValueElem, mProps.formatValue(value));
     } else {
-        mValueElem->SetInnerRML(std::to_string(value));
+        set_text_content(mValueElem, std::to_string(value));
     }
 
     update_carousel_arrow_color(mPrevElem, value == mProps.min);
@@ -194,79 +235,28 @@ void SteppedCarousel::apply(int value) {
     }
 }
 
-Rml::String format_graphics_setting_value(GraphicsOption option, int value) {
-    switch (option) {
-    case GraphicsOption::InternalResolution: {
-        u32 width = 0;
-        u32 height = 0;
-        AuroraGetRenderSize(&width, &height);
-        if (value <= 0) {
-            return fmt::format("Auto ({}×{})", width, height);
-        } else {
-            return fmt::format("{}× ({}×{})", value, width, height);
-        }
-    }
-    case GraphicsOption::ShadowResolution:
-        return fmt::format("{}×", value);
-    case GraphicsOption::Resampler:
-        switch (static_cast<Resampler>(value)) {
-        case Resampler::Bilinear:
-            return "Bilinear";
-        case Resampler::Area:
-            return "Area";
-        }
-        break;
-    case GraphicsOption::BloomMode:
-        switch (static_cast<BloomMode>(value)) {
-        case BloomMode::Off:
-            return "Off";
-        case BloomMode::Classic:
-            return "Classic";
-        case BloomMode::Dusk:
-            return "Dusklight";
-        }
-        break;
-    case GraphicsOption::DepthOfFieldMode:
-        switch (static_cast<DepthOfFieldMode>(value)) {
-        case DepthOfFieldMode::Off:
-            return "Off";
-        case DepthOfFieldMode::Classic:
-            return "Classic";
-        case DepthOfFieldMode::Dusk:
-            return "Dusklight";
-        }
-        break;
-    case GraphicsOption::BloomMultiplier:
-        return fmt::format("{}%", value);
-    case GraphicsOption::TextureReplacements:
-        return static_cast<bool>(value) ? "On" : "Off";
-    }
-    return "";
-}
-
 GraphicsTuner::GraphicsTuner(GraphicsTunerProps props)
-    : Document(kDocumentSource, false, DocumentScope::GraphicsTuner), mOption(props.option),
-      mValueMin(props.valueMin), mValueMax(props.valueMax), mDefaultValue(props.defaultValue) {
+    : Document(kDocumentSource, false, DocumentScope::GraphicsTuner),
+      mSetting(GraphicsSetting::of(props.option)) {
     if (mDocument == nullptr) {
         return;
     }
 
     if (auto* title = mDocument->GetElementById("title")) {
-        title->SetInnerRML(escape(props.title));
+        append_text(title, props.title);
     }
     if (auto* description = mDocument->GetElementById("description")) {
-        description->SetInnerRML(escape(props.helpText));
+        append_text(description, props.helpText);
     }
     if (auto* carouselParent = mDocument->GetElementById("carousel-container")) {
         mCarousel = &add_component<SteppedCarousel>(carouselParent,
             SteppedCarousel::Props{
-                .min = mValueMin,
-                .max = mValueMax,
-                .step = props.step,
-                .getValue = [this] { return get_value(mOption); },
-                .onChange = [this](int value) { set_value(mOption, value); },
-                .formatValue =
-                    [this](int value) { return format_graphics_setting_value(mOption, value); },
+                .min = mSetting.min,
+                .max = mSetting.max,
+                .step = mSetting.step,
+                .getValue = [this] { return mSetting.read(); },
+                .onChange = [this](int value) { mSetting.set(value); },
+                .formatValue = [this](int value) { return mSetting.label(value); },
             });
     }
 
@@ -282,6 +272,17 @@ GraphicsTuner::GraphicsTuner(GraphicsTunerProps props)
         resetButton.root()->SetClass("reset", true);
     }
 
+    if (mCarousel != nullptr) {
+        if (const char* name = mSetting.cvarName()) {
+            mSubscription = config::subscribe(name,
+                [this](config::ConfigVarBase&, const void*) { mCarousel->refresh(); });
+        }
+        mCarousel->refresh();
+        if (mSetting.watchesRenderSize) {
+            AuroraGetRenderSize(&mLastRenderWidth, &mLastRenderHeight);
+        }
+    }
+
     // Hide document after transition completion
     mRoot = mDocument->GetElementById("root");
     listen(mRoot, Rml::EventId::Transitionend, [this](Rml::Event& event) {
@@ -293,6 +294,12 @@ GraphicsTuner::GraphicsTuner(GraphicsTunerProps props)
     });
 }
 
+GraphicsTuner::~GraphicsTuner() {
+    if (mSubscription != 0) {
+        config::unsubscribe(mSubscription);
+    }
+}
+
 void GraphicsTuner::show() {
     Document::show();
     mRoot->SetAttribute("open", "");
@@ -309,6 +316,16 @@ void GraphicsTuner::hide(bool close) {
 }
 
 void GraphicsTuner::update() {
+    if (mSetting.watchesRenderSize && mCarousel != nullptr) {
+        u32 width = 0;
+        u32 height = 0;
+        AuroraGetRenderSize(&width, &height);
+        if (width != mLastRenderWidth || height != mLastRenderHeight) {
+            mLastRenderWidth = width;
+            mLastRenderHeight = height;
+            mCarousel->refresh();
+        }
+    }
     for (const auto& component : mComponents) {
         component->update();
     }
@@ -342,7 +359,7 @@ bool GraphicsTuner::handle_nav_command(Rml::Event& event, NavCommand cmd) {
 }
 
 void GraphicsTuner::reset_default() {
-    set_value(mOption, mDefaultValue);
+    mSetting.set(mSetting.defaultValue);
 }
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/graphics_tuner.hpp b/src/dusk/ui/graphics_tuner.hpp
index d778583b29..2a6b3e198a 100644
--- a/src/dusk/ui/graphics_tuner.hpp
+++ b/src/dusk/ui/graphics_tuner.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
-#include "button.hpp"
 #include "component.hpp"
 #include "document.hpp"
 #include "ui.hpp"
 
+#include <algorithm>
 #include <functional>
 #include <memory>
 #include <type_traits>
@@ -28,6 +28,7 @@ public:
 
     bool focus() override;
     void update() override;
+    void refresh();
     bool handle_nav_command(NavCommand cmd);
 
 private:
@@ -49,21 +50,34 @@ enum class GraphicsOption {
     TextureReplacements,
 };
 
-Rml::String format_graphics_setting_value(GraphicsOption option, int value);
+struct GraphicsSetting {
+    int min = 0;
+    int max = 0;
+    int defaultValue = 0;
+    int step = 1;
+    bool watchesRenderSize = false;
+    int (*read)() = nullptr;
+    void (*write)(int) = nullptr;
+    Rml::String (*label)(int) = nullptr;
+    const char* (*cvarName)() = nullptr;
+    bool (*isModified)() = nullptr;
+
+    static const GraphicsSetting& of(GraphicsOption option);
+
+    void set(int value) const { write(std::clamp(value, min, max)); }
+    Rml::String text() const { return label(read()); }
+};
 
 struct GraphicsTunerProps {
     GraphicsOption option;
     Rml::String title;
     Rml::String helpText;
-    int valueMin = 0;
-    int valueMax = 0;
-    int defaultValue = 0;
-    int step = 1;
 };
 
 class GraphicsTuner : public Document {
 public:
     explicit GraphicsTuner(GraphicsTunerProps props);
+    ~GraphicsTuner() override;
 
     void show() override;
     void hide(bool close) override;
@@ -85,13 +99,13 @@ private:
 
     void reset_default();
 
-    GraphicsOption mOption;
-    int mValueMin = 0;
-    int mValueMax = 0;
-    int mDefaultValue = 0;
+    GraphicsSetting mSetting;
     std::vector<std::unique_ptr<Component> > mComponents;
-    SteppedCarousel* mCarousel;
+    SteppedCarousel* mCarousel = nullptr;
     Rml::Element* mRoot;
+    u64 mSubscription = 0;
+    u32 mLastRenderWidth = 0;
+    u32 mLastRenderHeight = 0;
 };
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/group_button.cpp b/src/dusk/ui/group_button.cpp
new file mode 100644
index 0000000000..2f9a430d68
--- /dev/null
+++ b/src/dusk/ui/group_button.cpp
@@ -0,0 +1,25 @@
+#include "group_button.hpp"
+
+namespace dusk::ui {
+
+GroupButton::GroupButton(Rml::Element* parent, Props props)
+    : SelectButton{parent, {.key = std::move(props.text)}},
+      mIsSelected{std::move(props.isSelected)}, mIsDisabled{std::move(props.isDisabled)} {
+    mRoot->SetClass("group-button", true);
+}
+
+void GroupButton::update() {
+    set_selected(selected());
+    set_disabled(disabled());
+    SelectButton::update();
+}
+
+bool GroupButton::selected() const {
+    return mIsSelected ? mIsSelected() : SelectButton::selected();
+}
+
+bool GroupButton::disabled() const {
+    return mIsDisabled ? mIsDisabled() : SelectButton::disabled();
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/group_button.hpp b/src/dusk/ui/group_button.hpp
new file mode 100644
index 0000000000..8b207318d4
--- /dev/null
+++ b/src/dusk/ui/group_button.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "select_button.hpp"
+
+namespace dusk::ui {
+
+class GroupButton : public SelectButton {
+public:
+    struct Props {
+        Rml::String text;
+        std::function<bool()> isSelected;
+        std::function<bool()> isDisabled;
+    };
+
+    GroupButton(Rml::Element* parent, Props props);
+
+    void update() override;
+    bool selected() const override;
+    bool disabled() const override;
+
+private:
+    std::function<bool()> mIsSelected;
+    std::function<bool()> mIsDisabled;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/icon_button.cpp b/src/dusk/ui/icon_button.cpp
new file mode 100644
index 0000000000..b1fe3c9f04
--- /dev/null
+++ b/src/dusk/ui/icon_button.cpp
@@ -0,0 +1,70 @@
+#include "icon_button.hpp"
+
+#include <utility>
+
+namespace dusk::ui {
+
+const char* material_icon(std::string_view name) {
+    static constexpr std::pair<std::string_view, const char*> icons[] = {
+        {"play_arrow", "\uE037"},
+        {"pause", "\uE034"},
+        {"stop", "\uE047"},
+        {"replay", "\uE042"},
+        {"skip_next", "\uE044"},
+        {"skip_previous", "\uE045"},
+        {"note_add", "\uE89C"},
+        {"create_new_folder", "\uE2CC"},
+        {"delete", "\uE872"},
+        {"add", "\uE145"},
+        {"remove", "\uE15B"},
+        {"close", "\uE5CD"},
+        {"check", "\uE5CA"},
+        {"refresh", "\uE5D5"},
+        {"file_download", "\uE2C4"},
+        {"download", "\uF090"},
+        {"schedule", "\uE8B5"},
+        {"warning", "\uE002"},
+        {"check_circle", "\uE86C"},
+        {"favorite", "\uE87D"},
+        {"arrow_back", "\uE5C4"},
+        {"open_in_new", "\uE89E"},
+        {"settings", "\uE8B8"},
+        {"folder_open", "\uE2C8"},
+        {"history", "\uE889"},
+        {"queue_music", "\uE03D"},
+        {"volume_up", "\uE050"},
+        {"volume_off", "\uE04F"},
+        {"shuffle", "\uE043"},
+        {"repeat", "\uE040"},
+        {"search", "\uE8B6"},
+        {"info", "\uE88E"},
+        {"description", "\uE873"},
+        {"notes", "\uE26C"},
+        {"resume", "\uF7D0"},
+    };
+    for (const auto& [key, glyph] : icons) {
+        if (name == key) {
+            return glyph;
+        }
+    }
+    return "";
+}
+
+IconButton::IconButton(Rml::Element* parent, Props props)
+    : ControlledButton{parent, ControlledButton::Props{.text = "",
+                                   .isSelected = std::move(props.isSelected),
+                                   .isDisabled = std::move(props.isDisabled)}},
+      mTooltip{mRoot, props.label} {
+    mRoot->SetClass("icon-button", true);
+    mRoot->SetAttribute("aria-label", props.label);
+    auto* icon = append(mRoot, "icon");
+    icon->SetAttribute("aria-hidden", "true");
+    append_text(icon, material_icon(props.icon));
+}
+
+void IconButton::update() {
+    ControlledButton::update();
+    mTooltip.update();
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/icon_button.hpp b/src/dusk/ui/icon_button.hpp
new file mode 100644
index 0000000000..4c54e85495
--- /dev/null
+++ b/src/dusk/ui/icon_button.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "button.hpp"
+#include "tooltip.hpp"
+
+#include <string_view>
+
+namespace dusk::ui {
+
+const char* material_icon(std::string_view name);
+
+class IconButton : public ControlledButton {
+public:
+    struct Props {
+        Rml::String icon;
+        Rml::String label;
+        std::function<bool()> isSelected;
+        std::function<bool()> isDisabled;
+    };
+
+    IconButton(Rml::Element* parent, Props props);
+    void update() override;
+
+private:
+    Tooltip mTooltip;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/input.cpp b/src/dusk/ui/input.cpp
index 2628aeb682..d386bad69e 100644
--- a/src/dusk/ui/input.cpp
+++ b/src/dusk/ui/input.cpp
@@ -11,6 +11,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cmath>
 
 #include "dusk/action_bindings.h"
 
@@ -24,6 +25,8 @@ constexpr double kGamepadRepeatRampDuration = 1.0;
 constexpr double kGamepadMenuChordGraceDuration = 0.12;
 constexpr Sint16 kGamepadAxisPressThreshold = 16384;
 constexpr Sint16 kGamepadAxisReleaseThreshold = 12000;
+constexpr float kNavAxisDeadZone = 0.12f;
+constexpr double kMaxNavAxisDt = 0.05;
 constexpr int kGamepadAxisDirectionCount = SDL_GAMEPAD_AXIS_COUNT * 2;
 constexpr int kMenuTapFingerCount = 3;
 constexpr float kMenuTapMoveThreshold = 12.0f;
@@ -59,6 +62,10 @@ std::array<GamepadRepeatState, kGamepadAxisDirectionCount> sGamepadAxisRepeats;
 std::array<u32, PAD_MAX_CONTROLLERS> sPadHoldMasks;
 std::array<bool, PAD_MAX_CONTROLLERS> sMenuChordConsumed;
 TouchTapState sTouchMenuTap;
+Rml::Vector2f sNavAxis;
+std::array<Rml::Vector2f, SDL_GAMEPAD_AXIS_COUNT> sNavAxisContributions;
+SDL_JoystickID sNavAxisSource = 0;
+double sLastInputUpdateAt = 0.0;
 
 double now_seconds() noexcept {
     return static_cast<double>(SDL_GetTicksNS()) / 1000000000.0;
@@ -335,7 +342,9 @@ Rml::Input::KeyIdentifier map_gamepad_button(const SDL_GamepadButtonEvent& event
         }
     }
 
-    if (nativeButton == SDL_GAMEPAD_BUTTON_BACK && !isActionBound(ActionBinds::OPEN_DUSKLIGHT_MENU, port)) {
+    if (nativeButton == SDL_GAMEPAD_BUTTON_BACK &&
+        !isActionBound(ActionBinds::OPEN_DUSKLIGHT_MENU, port))
+    {
         return Rml::Input::KI_F1;
     }
 
@@ -367,6 +376,138 @@ Rml::Input::KeyIdentifier map_gamepad_axis(
     return Rml::Input::KI_UNKNOWN;
 }
 
+struct LogicalNavAxis {
+    enum class Component {
+        None,
+        X,
+        Y,
+    };
+
+    Component component = Component::None;
+    float direction = 0.0f;
+};
+
+LogicalNavAxis logical_nav_axis(PADAxis axis) noexcept {
+    switch (axis) {
+    case PAD_AXIS_LEFT_X_POS:
+        return {LogicalNavAxis::Component::X, 1.0f};
+    case PAD_AXIS_LEFT_X_NEG:
+        return {LogicalNavAxis::Component::X, -1.0f};
+    case PAD_AXIS_LEFT_Y_POS:
+        return {LogicalNavAxis::Component::Y, -1.0f};
+    case PAD_AXIS_LEFT_Y_NEG:
+        return {LogicalNavAxis::Component::Y, 1.0f};
+    default:
+        return {};
+    }
+}
+
+struct LogicalNavAxisMapping {
+    LogicalNavAxis active;
+    bool participates = false;
+};
+
+LogicalNavAxisMapping mapped_logical_nav_axis(const SDL_GamepadAxisEvent& event) noexcept {
+    u32 port = 0;
+    if (find_event_port(event.which, port)) {
+        LogicalNavAxisMapping result;
+        const PADAxisSign activeSign = event.value < 0 ? AXIS_SIGN_NEGATIVE : AXIS_SIGN_POSITIVE;
+        for (const PADAxisSign sign : {AXIS_SIGN_NEGATIVE, AXIS_SIGN_POSITIVE}) {
+            PADAxis axis = 0;
+            if (!find_mapped_pad_axis(port, static_cast<SDL_GamepadAxis>(event.axis), sign, axis)) {
+                continue;
+            }
+            const auto logical = logical_nav_axis(axis);
+            if (logical.component == LogicalNavAxis::Component::None) {
+                continue;
+            }
+            result.participates = true;
+            if (event.value != 0 && sign == activeSign) {
+                result.active = logical;
+            }
+        }
+        return result;
+    }
+
+    switch (static_cast<SDL_GamepadAxis>(event.axis)) {
+    case SDL_GAMEPAD_AXIS_LEFTX:
+        return {
+            .active = {LogicalNavAxis::Component::X, event.value < 0 ? -1.0f : 1.0f},
+            .participates = true,
+        };
+    case SDL_GAMEPAD_AXIS_LEFTY:
+        return {
+            .active = {LogicalNavAxis::Component::Y, event.value < 0 ? -1.0f : 1.0f},
+            .participates = true,
+        };
+    default:
+        return {};
+    }
+}
+
+float normalize_nav_axis(Sint16 value) noexcept {
+    const float normalized =
+        value < 0 ? -static_cast<float>(value) / 32768.0f : static_cast<float>(value) / 32767.0f;
+    if (normalized <= kNavAxisDeadZone) {
+        return 0.0f;
+    }
+    return (normalized - kNavAxisDeadZone) / (1.0f - kNavAxisDeadZone);
+}
+
+bool update_nav_axis(const SDL_GamepadAxisEvent& event) noexcept {
+    const auto mapping = mapped_logical_nav_axis(event);
+    const int axisIndex = static_cast<int>(event.axis);
+    if (!mapping.participates || axisIndex < 0 || axisIndex >= SDL_GAMEPAD_AXIS_COUNT) {
+        return false;
+    }
+
+    const float magnitude = normalize_nav_axis(event.value);
+    if (magnitude != 0.0f && mapping.active.component != LogicalNavAxis::Component::None &&
+        sNavAxisSource != event.which)
+    {
+        sNavAxis = {};
+        sNavAxisContributions = {};
+        sNavAxisSource = event.which;
+    } else if (sNavAxisSource != 0 && sNavAxisSource != event.which) {
+        return false;
+    }
+
+    auto& contribution = sNavAxisContributions[axisIndex];
+    contribution = {};
+    if (mapping.active.component == LogicalNavAxis::Component::X) {
+        contribution.x = mapping.active.direction * magnitude;
+    } else if (mapping.active.component == LogicalNavAxis::Component::Y) {
+        contribution.y = mapping.active.direction * magnitude;
+    }
+
+    const Rml::Vector2f previous = sNavAxis;
+    sNavAxis = {};
+    for (const auto value : sNavAxisContributions) {
+        if (std::abs(value.x) > std::abs(sNavAxis.x)) {
+            sNavAxis.x = value.x;
+        }
+        if (std::abs(value.y) > std::abs(sNavAxis.y)) {
+            sNavAxis.y = value.y;
+        }
+    }
+    if (sNavAxis.x == 0.0f && sNavAxis.y == 0.0f) {
+        sNavAxisSource = 0;
+    }
+    return sNavAxis != previous;
+}
+
+void dispatch_nav_axis(Rml::Context& context, double dtSeconds) noexcept {
+    auto* target = context.GetFocusElement();
+    if (target == nullptr) {
+        return;
+    }
+    target->DispatchEvent(kNavAxisEvent, {
+                                             {"x", Rml::Variant{sNavAxis.x}},
+                                             {"y", Rml::Variant{sNavAxis.y}},
+                                             {"dt", Rml::Variant{static_cast<float>(dtSeconds)}},
+                                         });
+}
+
 bool is_repeatable_key(Rml::Input::KeyIdentifier key) noexcept {
     switch (key) {
     case Rml::Input::KI_UP:
@@ -657,7 +798,9 @@ void process_axis_direction(
     if (chorded) {
         consume_menu_chord(port, context);
     }
-    const auto key = chorded && !isActionBound(ActionBinds::OPEN_DUSKLIGHT_MENU, port) ? Rml::Input::KI_F1 : map_gamepad_axis(event, sign);
+    const auto key = chorded && !isActionBound(ActionBinds::OPEN_DUSKLIGHT_MENU, port) ?
+                         Rml::Input::KI_F1 :
+                         map_gamepad_axis(event, sign);
     if (key == Rml::Input::KI_UNKNOWN) {
         return;
     }
@@ -695,6 +838,9 @@ void release_input_block() noexcept {
 void reset_input_state() noexcept {
     clear_gamepad_repeats();
     reset_touch_menu_tap();
+    sNavAxis = {};
+    sNavAxisContributions = {};
+    sNavAxisSource = 0;
 }
 
 void handle_event(const SDL_Event& event) noexcept {
@@ -728,6 +874,9 @@ void handle_event(const SDL_Event& event) noexcept {
     }
 
     if (event.type == SDL_EVENT_GAMEPAD_AXIS_MOTION) {
+        if (update_nav_axis(event.gaxis)) {
+            dispatch_nav_axis(*context, 0.0);
+        }
         process_axis_direction(*context, event.gaxis, AXIS_SIGN_POSITIVE);
         process_axis_direction(*context, event.gaxis, AXIS_SIGN_NEGATIVE);
         sync_input_block();
@@ -744,7 +893,9 @@ void handle_event(const SDL_Event& event) noexcept {
         if (chorded) {
             consume_menu_chord(port, *context);
         }
-        const auto key = chorded && !isActionBound(ActionBinds::OPEN_DUSKLIGHT_MENU, port) ? Rml::Input::KI_F1 : map_gamepad_button(event.gbutton);
+        const auto key = chorded && !isActionBound(ActionBinds::OPEN_DUSKLIGHT_MENU, port) ?
+                             Rml::Input::KI_F1 :
+                             map_gamepad_button(event.gbutton);
         if (key != Rml::Input::KI_UNKNOWN) {
             bool deferred = false;
             if (repeat != nullptr) {
@@ -782,6 +933,10 @@ void update_input() noexcept {
     auto* context = aurora::rmlui::get_context();
     if (context != nullptr) {
         const double now = now_seconds();
+        const double dtSeconds = sLastInputUpdateAt == 0.0 ?
+                                     0.0 :
+                                     std::clamp(now - sLastInputUpdateAt, 0.0, kMaxNavAxisDt);
+        sLastInputUpdateAt = now;
         auto process_repeats = [context, now](auto& repeats) {
             for (auto& repeat : repeats) {
                 if (!repeat.held) {
@@ -814,9 +969,11 @@ void update_input() noexcept {
         };
         process_repeats(sGamepadButtonRepeats);
         process_repeats(sGamepadAxisRepeats);
+        dispatch_nav_axis(*context, dtSeconds);
     } else {
         reset_input_state();
+        sLastInputUpdateAt = 0.0;
     }
 }
 
-}  // namespace dusk::ui
+}  // namespace dusk::ui::input
diff --git a/src/dusk/ui/input.hpp b/src/dusk/ui/input.hpp
index a2ad859530..7a30e89e07 100644
--- a/src/dusk/ui/input.hpp
+++ b/src/dusk/ui/input.hpp
@@ -4,6 +4,8 @@ union SDL_Event;
 
 namespace dusk::ui::input {
 
+inline constexpr char kNavAxisEvent[] = "navaxis";
+
 void handle_event(const SDL_Event& event) noexcept;
 void update_input() noexcept;
 void reset_input_state() noexcept;
diff --git a/src/dusk/ui/list.cpp b/src/dusk/ui/list.cpp
new file mode 100644
index 0000000000..fc8d233847
--- /dev/null
+++ b/src/dusk/ui/list.cpp
@@ -0,0 +1,363 @@
+#include "list.hpp"
+
+#include "ui.hpp"
+
+#include "Z2AudioLib/Z2SeMgr.h"
+#include "m_Do/m_Do_audio.h"
+
+#include <algorithm>
+#include <ranges>
+#include <utility>
+
+namespace dusk::ui {
+namespace {
+
+Rml::Element* create_root(Rml::Element* parent) {
+    auto* document = parent->GetOwnerDocument();
+    auto root = document->CreateElement("ui-list");
+    return parent->AppendChild(std::move(root));
+}
+
+Rml::Element* append_element(Rml::Element* parent, const Rml::String& tag) {
+    auto element = parent->GetOwnerDocument()->CreateElement(tag);
+    return parent->AppendChild(std::move(element));
+}
+
+}  // namespace
+
+List::List(Rml::Element* parent, Props props)
+    : FluentComponent(create_root(parent)), mProps(std::move(props)) {
+    mViewport = append_element(mRoot, "ui-list-viewport");
+    mContent = append_element(mViewport, "ui-list-content");
+    mEmpty = append_element(mRoot, "ui-list-empty");
+    append_text(mEmpty, "No items");
+
+    Component::listen(mViewport, Rml::EventId::Scroll, [this](Rml::Event&) { mCullDirty = true; });
+    listen(Rml::EventId::Keydown, [this](Rml::Event& event) { handle_keydown(event); });
+
+    apply_items(std::move(mProps.items));
+}
+
+void List::set_items(std::vector<Item> items) {
+    mPendingSnapshotFocus = capture_snapshot_focus();
+    mPendingItems = std::move(items);
+}
+
+void List::update() {
+    if (mPendingItems) {
+        auto items = std::move(*mPendingItems);
+        const auto snapshotFocus = mPendingSnapshotFocus;
+        mPendingItems.reset();
+        mPendingSnapshotFocus.reset();
+        apply_items(std::move(items), snapshotFocus);
+    }
+
+    for (const auto& row : mRows) {
+        if (!row->culled) {
+            row->button->update();
+        }
+    }
+
+    const float scrollTop = mViewport->GetScrollTop();
+    const float viewportWidth = mViewport->GetClientWidth();
+    const float viewportHeight = mViewport->GetClientHeight();
+    if (scrollTop != mLastScrollTop || viewportWidth != mLastViewportWidth ||
+        viewportHeight != mLastViewportHeight)
+    {
+        mCullDirty = true;
+        if (viewportWidth != mLastViewportWidth || viewportHeight != mLastViewportHeight) {
+            mLayoutScanFrames = std::max(mLayoutScanFrames, 2);
+        }
+        mLastScrollTop = scrollTop;
+        mLastViewportWidth = viewportWidth;
+        mLastViewportHeight = viewportHeight;
+    }
+
+    if (mCullDirty || mLayoutScanFrames > 0) {
+        update_culling();
+        mCullDirty = false;
+        if (mLayoutScanFrames > 0) {
+            --mLayoutScanFrames;
+        }
+    }
+
+    update_pending_focus();
+}
+
+bool List::focus() {
+    if (mActiveKey) {
+        const int activeIndex = row_index(*mActiveKey);
+        if (activeIndex >= 0 && focus_row(activeIndex, true)) {
+            return true;
+        }
+    }
+    for (int i = 0; i < static_cast<int>(mRows.size()); ++i) {
+        if (focus_row(i, true)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool List::focus_from(NavCommand direction) {
+    if (direction != NavCommand::Up) {
+        return focus();
+    }
+    for (int i = static_cast<int>(mRows.size()) - 1; i >= 0; --i) {
+        if (focus_row(i, true)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+List::Row* List::row_from_element(Rml::Element* element) const {
+    for (const auto& row : mRows) {
+        if (row->button->contains(element)) {
+            return row.get();
+        }
+    }
+    return nullptr;
+}
+
+int List::row_index(uint64_t key) const {
+    for (int i = 0; i < static_cast<int>(mRows.size()); ++i) {
+        if (mRows[i]->key == key) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+List::SnapshotFocus List::capture_snapshot_focus() {
+    auto* context = mRoot->GetContext();
+    auto* focusedElement = context != nullptr ? context->GetFocusElement() : nullptr;
+    Row* focusedRow = row_from_element(focusedElement);
+    if (focusedRow == nullptr) {
+        return {};
+    }
+    mActiveKey = focusedRow->key;
+    return {
+        .owned = true,
+        .key = focusedRow->key,
+        .index = row_index(focusedRow->key),
+    };
+}
+
+std::unique_ptr<List::Row> List::create_row(const Item& item) {
+    auto row = std::make_unique<Row>();
+    row->key = item.key;
+    row->button = std::make_unique<ControlledButton>(mContent,
+        ControlledButton::Props{
+            .text = item.label,
+            .isSelected =
+                [this, key = item.key] { return mProps.isSelected && mProps.isSelected(key); },
+            .isDisabled =
+                [this, key = item.key] { return mProps.isDisabled && mProps.isDisabled(key); },
+        });
+    row->button->root()->SetClass("ui-list-row", true);
+    row->button->root()->SetProperty("visibility", "hidden");
+    row->button->Component::listen(row->button->root(), Rml::EventId::Focus,
+        [this, key = item.key](Rml::Event&) { mActiveKey = key; });
+    row->button->on_pressed([this, key = item.key] {
+        mActiveKey = key;
+        if (mProps.onPressed) {
+            mProps.onPressed(key);
+        }
+    });
+    return row;
+}
+
+void List::apply_items(std::vector<Item> items, const std::optional<SnapshotFocus>& snapshotFocus) {
+    const SnapshotFocus focusState = snapshotFocus ? *snapshotFocus : capture_snapshot_focus();
+
+    std::unordered_map<uint64_t, std::unique_ptr<Row>> oldRows;
+    oldRows.reserve(mRows.size());
+    for (auto& row : mRows) {
+        oldRows.emplace(row->key, std::move(row));
+    }
+    mRows.clear();
+    mRows.reserve(items.size());
+
+    for (const auto& item : items) {
+        if (auto node = oldRows.extract(item.key); !node.empty()) {
+            auto row = std::move(node.mapped());
+            row->button->set_text(item.label);
+            mRows.push_back(std::move(row));
+        } else {
+            mRows.push_back(create_row(item));
+        }
+    }
+
+    for (auto& row : oldRows | std::views::values) {
+        mContent->RemoveChild(row->button->root());
+    }
+
+    for (int i = 0; i < static_cast<int>(mRows.size()); ++i) {
+        auto* desired = mRows[i]->button->root();
+        auto* current = mContent->GetChild(i);
+        if (current != desired) {
+            auto element = mContent->RemoveChild(desired);
+            mContent->InsertBefore(std::move(element), current);
+        }
+    }
+
+    mRowsByKey.clear();
+    mRowsByKey.reserve(mRows.size());
+    for (const auto& row : mRows) {
+        mRowsByKey.emplace(row->key, row.get());
+    }
+    mItems = std::move(items);
+
+    if (mRows.empty()) {
+        mViewport->SetProperty("display", "none");
+        mEmpty->RemoveProperty("display");
+    } else {
+        mViewport->RemoveProperty("display");
+        mEmpty->SetProperty("display", "none");
+    }
+
+    if (focusState.owned && !mRows.empty()) {
+        uint64_t targetKey =
+            mRows[std::min(focusState.index, static_cast<int>(mRows.size()) - 1)]->key;
+        if (focusState.key && mRowsByKey.contains(*focusState.key)) {
+            targetKey = *focusState.key;
+        }
+        request_focus(targetKey, false);
+    } else {
+        mPendingFocusKey.reset();
+        mPendingFocusFrames = 0;
+        mPendingFocusMayEnterList = false;
+    }
+
+    mCullDirty = true;
+    mLayoutScanFrames = 2;
+}
+
+void List::update_culling() {
+    const float viewTop = mViewport->GetAbsoluteOffset(Rml::BoxArea::Border).y;
+    const float viewHeight = mViewport->GetClientHeight();
+    if (viewHeight <= 0.0f) {
+        return;
+    }
+    auto* context = mRoot->GetContext();
+    const Row* focusedRow = context != nullptr ? row_from_element(context->GetFocusElement()) : nullptr;
+
+    for (const auto& row : mRows) {
+        auto* element = row->button->root();
+        const float top = element->GetAbsoluteOffset(Rml::BoxArea::Border).y - viewTop;
+        const bool inWindow =
+            top + element->GetOffsetHeight() >= -viewHeight && top <= viewHeight * 2.0f;
+        const bool focusGuard =
+            row.get() == focusedRow || (mPendingFocusKey && row->key == *mPendingFocusKey);
+        const bool shouldShow = inWindow || focusGuard;
+        if (shouldShow && row->culled) {
+            show_row(*row);
+        } else if (!shouldShow && !row->culled) {
+            row->culled = true;
+            element->SetProperty("visibility", "hidden");
+        }
+    }
+}
+
+void List::show_row(Row& row) {
+    if (!row.culled) {
+        return;
+    }
+    row.button->update();
+    row.button->root()->RemoveProperty("visibility");
+    row.culled = false;
+}
+
+bool List::focus_row(int index, bool mayEnterList) {
+    if (index < 0 || index >= static_cast<int>(mRows.size())) {
+        return false;
+    }
+    auto& row = *mRows[index];
+    show_row(row);
+    row.button->update();
+    if (row.button->root()->IsPseudoClassSet("disabled")) {
+        return false;
+    }
+    if (row.button->focus()) {
+        mActiveKey = row.key;
+        mPendingFocusKey.reset();
+        mPendingFocusFrames = 0;
+        mPendingFocusMayEnterList = false;
+        return true;
+    }
+    request_focus(row.key, mayEnterList);
+    return true;
+}
+
+void List::request_focus(uint64_t key, bool mayEnterList) {
+    const auto it = mRowsByKey.find(key);
+    if (it == mRowsByKey.end()) {
+        return;
+    }
+    show_row(*it->second);
+    mPendingFocusKey = key;
+    mPendingFocusFrames = 2;
+    mPendingFocusMayEnterList = mayEnterList;
+}
+
+void List::update_pending_focus() {
+    if (!mPendingFocusKey) {
+        return;
+    }
+    const auto it = mRowsByKey.find(*mPendingFocusKey);
+    if (it == mRowsByKey.end()) {
+        mPendingFocusKey.reset();
+        return;
+    }
+
+    auto* context = mRoot->GetContext();
+    auto* focusedElement = context != nullptr ? context->GetFocusElement() : nullptr;
+    if (!mPendingFocusMayEnterList && focusedElement != nullptr && !contains(focusedElement)) {
+        mPendingFocusKey.reset();
+        return;
+    }
+    if (it->second->button->contains(focusedElement)) {
+        mPendingFocusKey.reset();
+        mPendingFocusFrames = 0;
+        mPendingFocusMayEnterList = false;
+        return;
+    }
+    if (mPendingFocusFrames > 0) {
+        --mPendingFocusFrames;
+        return;
+    }
+
+    auto& row = *it->second;
+    show_row(row);
+    row.button->update();
+    if (!row.button->root()->IsPseudoClassSet("disabled") && row.button->focus()) {
+        mActiveKey = row.key;
+    }
+    mPendingFocusKey.reset();
+    mPendingFocusMayEnterList = false;
+}
+
+void List::handle_keydown(Rml::Event& event) {
+    const NavCommand command = map_nav_event(event);
+    if (command != NavCommand::Down && command != NavCommand::Up) {
+        return;
+    }
+    Row* focusedRow = row_from_element(event.GetTargetElement());
+    if (focusedRow == nullptr) {
+        return;
+    }
+    mActiveKey = focusedRow->key;
+    const int direction = command == NavCommand::Down ? 1 : -1;
+    for (int i = row_index(focusedRow->key) + direction;
+        i >= 0 && i < static_cast<int>(mRows.size()); i += direction)
+    {
+        if (focus_row(i, true)) {
+            mDoAud_seStartMenu(kSoundItemFocus);
+            event.StopPropagation();
+            return;
+        }
+    }
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/list.hpp b/src/dusk/ui/list.hpp
new file mode 100644
index 0000000000..11a9dab5d6
--- /dev/null
+++ b/src/dusk/ui/list.hpp
@@ -0,0 +1,80 @@
+#pragma once
+
+#include "button.hpp"
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <vector>
+
+namespace dusk::ui {
+
+class List : public FluentComponent<List> {
+public:
+    struct Item {
+        uint64_t key = 0;
+        Rml::String label;
+    };
+
+    struct Props {
+        std::vector<Item> items;
+        std::function<void(uint64_t)> onPressed;
+        std::function<bool(uint64_t)> isSelected;
+        std::function<bool(uint64_t)> isDisabled;
+    };
+
+    List(Rml::Element* parent, Props props);
+
+    void set_items(std::vector<Item> items);
+    void update() override;
+    bool focus() override;
+    bool focus_from(NavCommand direction) override;
+
+private:
+    struct SnapshotFocus {
+        bool owned = false;
+        std::optional<uint64_t> key;
+        int index = -1;
+    };
+
+    struct Row {
+        uint64_t key = 0;
+        std::unique_ptr<ControlledButton> button;
+        bool culled = true;
+    };
+
+    Row* row_from_element(Rml::Element* element) const;
+    int row_index(uint64_t key) const;
+    SnapshotFocus capture_snapshot_focus();
+    std::unique_ptr<Row> create_row(const Item& item);
+    void apply_items(std::vector<Item> items, const std::optional<SnapshotFocus>& snapshotFocus = {});
+    void update_culling();
+    void show_row(Row& row);
+    bool focus_row(int index, bool mayEnterList);
+    void request_focus(uint64_t key, bool mayEnterList);
+    void update_pending_focus();
+    void handle_keydown(Rml::Event& event);
+
+    Props mProps;
+    Rml::Element* mViewport = nullptr;
+    Rml::Element* mContent = nullptr;
+    Rml::Element* mEmpty = nullptr;
+    std::vector<Item> mItems;
+    std::optional<std::vector<Item>> mPendingItems;
+    std::optional<SnapshotFocus> mPendingSnapshotFocus;
+    std::vector<std::unique_ptr<Row>> mRows;
+    std::unordered_map<uint64_t, Row*> mRowsByKey;
+    std::optional<uint64_t> mActiveKey;
+    std::optional<uint64_t> mPendingFocusKey;
+    int mPendingFocusFrames = 0;
+    bool mPendingFocusMayEnterList = false;
+    bool mCullDirty = true;
+    int mLayoutScanFrames = 2;
+    float mLastScrollTop = -1.0f;
+    float mLastViewportWidth = -1.0f;
+    float mLastViewportHeight = -1.0f;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/logs_window.cpp b/src/dusk/ui/logs_window.cpp
index 9fdd89e50d..008611b0f6 100644
--- a/src/dusk/ui/logs_window.cpp
+++ b/src/dusk/ui/logs_window.cpp
@@ -72,16 +72,10 @@ std::string format_time(int64_t timeMs) {
     return fmt::format("{}.{:03}", buffer.data(), timeMs % 1000);
 }
 
-void append_text(Rml::ElementDocument* doc, Rml::Element* parent, const Rml::String& text) {
-    parent->AppendChild(doc->CreateTextNode(text));
-}
-
-Rml::Element* append_span(Rml::ElementDocument* doc, Rml::Element* parent, const char* className,
-    const Rml::String& text) {
-    auto span = doc->CreateElement("span");
-    span->SetClass(className, true);
-    append_text(doc, span.get(), text);
-    return parent->AppendChild(std::move(span));
+Rml::Element* append_log_field(Rml::Element* parent, const char* tagName, const Rml::String& text) {
+    auto* field = append(parent, tagName);
+    append_text(field, text);
+    return field;
 }
 
 }  // namespace
@@ -94,18 +88,15 @@ LogsWindow::LogsWindow(std::string modFilter)
 }
 
 void LogsWindow::build_content(Rml::Element* content) {
-    auto* toolbar = append(content, "div");
-    toolbar->SetClass("log-toolbar", true);
+    auto* toolbar = append(content, "log-toolbar");
 
-    auto* title = append(toolbar, "div");
-    title->SetClass("log-title", true);
-    title->SetInnerRML("Logs");
+    auto* title = append(toolbar, "log-title");
+    append_text(title, "Logs");
 
-    auto* modLabel = append(toolbar, "div");
-    modLabel->SetClass("log-title-mod", true);
-    modLabel->SetInnerRML(mModFilter.empty() ? "All mods" : fmt::format("{}", escape(mModFilter)));
+    auto* modLabel = append(toolbar, "log-title-mod");
+    append_text(modLabel, mModFilter.empty() ? "All mods" : mModFilter);
 
-    append(toolbar, "div")->SetClass("log-toolbar-spacer", true);
+    append(toolbar, "log-toolbar-spacer");
 
     for (const LogLevel level :
         {LOG_LEVEL_TRACE, LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN, LOG_LEVEL_ERROR})
@@ -121,7 +112,7 @@ void LogsWindow::build_content(Rml::Element* content) {
             });
     }
 
-    append(toolbar, "div")->SetClass("log-toolbar-spacer", true);
+    append(toolbar, "log-toolbar-spacer");
 
     add_child<Button>(toolbar, "Copy").on_pressed([this] { copy_to_clipboard(); });
     add_child<Button>(toolbar, "Clear").on_pressed([this] {
@@ -132,9 +123,7 @@ void LogsWindow::build_content(Rml::Element* content) {
     auto& pane = add_child<Pane>(content, Pane::Type::Uncontrolled);
     pane.root()->SetClass("log-view", true);
     mScrollElem = pane.root();
-    mLinesElem = append(pane.root(), "div");
-    mLinesElem->SetClass("log-lines", true);
-    pane.finalize();
+    mLinesElem = append(pane.root(), "log-lines");
 
     listen(mScrollElem, Rml::EventId::Scroll, [this](Rml::Event&) {
         const float bottom = mScrollElem->GetScrollHeight() - mScrollElem->GetClientHeight();
@@ -265,18 +254,17 @@ Rml::Element* LogsWindow::append_log_line(const mods::log::Line& line) {
         modId = "?";
     }
 
-    auto elem = mDocument->CreateElement("div");
-    elem->SetClass("log-line", true);
+    auto* elem = append(mLinesElem, "log-line");
     elem->SetClass(level_class(line.level), true);
 
     constexpr const char* kNbsp = "\xc2\xa0";
-    append_span(mDocument, elem.get(), "log-time", format_time(line.timeMs));
-    append_text(mDocument, elem.get(), kNbsp);
-    append_span(mDocument, elem.get(), "log-mod", fmt::format("[{}]", modId));
-    append_text(mDocument, elem.get(), kNbsp);
-    append_span(mDocument, elem.get(), "log-msg", line.message);
+    append_log_field(elem, "log-time", format_time(line.timeMs));
+    append_text(elem, kNbsp);
+    append_log_field(elem, "log-mod", fmt::format("[{}]", modId));
+    append_text(elem, kNbsp);
+    append_log_field(elem, "log-msg", line.message);
 
-    return mLinesElem->AppendChild(std::move(elem));
+    return elem;
 }
 
 void LogsWindow::copy_to_clipboard() {
diff --git a/src/dusk/ui/menu_bar.cpp b/src/dusk/ui/menu_bar.cpp
index 0c6528e424..fa0fdacddb 100644
--- a/src/dusk/ui/menu_bar.cpp
+++ b/src/dusk/ui/menu_bar.cpp
@@ -1,29 +1,30 @@
 #include "menu_bar.hpp"
 
-#include <RmlUi/Core.h>
-
-#include "Z2AudioLib/Z2SeMgr.h"
-#include "m_Do/m_Do_audio.h"
-
 #include "achievements.hpp"
-#include "aurora/rmlui.hpp"
-#include "dusk/livesplit.h"
-#include "dusk/main.h"
-#include "dusk/mods/svc/ui.hpp"
-#include "dusk/settings.h"
-#include "dusk/speedrun.h"
 #include "editor.hpp"
-#include "f_pc/f_pc_manager.h"
-#include "f_pc/f_pc_name.h"
-#include "imgui.h"
 #include "modal.hpp"
 #include "mods_window.hpp"
+#include "prelaunch.hpp"
 #include "settings.hpp"
 #include "ui.hpp"
 #include "warp.hpp"
 #include "window.hpp"
 
-#include <chrono>
+#include "dusk/game_mode.hpp"
+#include "dusk/livesplit.h"
+#include "dusk/main.h"
+#include "dusk/mods/svc/ui.hpp"
+#include "dusk/settings.h"
+#include "dusk/speedrun.h"
+
+#include "f_pc/f_pc_manager.h"
+#include "f_pc/f_pc_name.h"
+#include "m_Do/m_Do_audio.h"
+
+#include <aurora/rmlui.hpp>
+#include <imgui.h>
+#include <RmlUi/Core.h>
+
 #include <cmath>
 
 namespace dusk::ui {
@@ -32,6 +33,7 @@ namespace {
 const Rml::String kDocumentSource = R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/tabbing.rcss" />
     <link type="text/rcss" href="res/rml/popup.rcss" />
 </head>
@@ -54,6 +56,20 @@ MenuBar::MenuBar()
                                                       },
                                                   .autoSelect = false,
                                               });
+
+    // Hide document after transition completion
+    listen(mRoot, Rml::EventId::Transitionend, [this](Rml::Event& event) {
+        if (event.GetTargetElement() == mRoot && !mRoot->HasAttribute("open") &&
+            Document::visible())
+        {
+            Document::hide(mPendingClose);
+        }
+    });
+
+    build_tabs();
+}
+
+void MenuBar::build_tabs() {
     mTabBar->add_tab("Settings", [this] { push(std::make_unique<SettingsWindow>()); });
 
     if (getSettings().backend.enableAdvancedSettings) {
@@ -61,7 +77,12 @@ MenuBar::MenuBar()
         mTabBar->add_tab("Editor", [this] { push(std::make_unique<EditorWindow>()); });
     }
 
-    mTabBar->add_tab("Achievements", [this] { push(std::make_unique<AchievementsWindow>()); });
+    // Only allow us to access achievements if we are playing on a game mode that uses them
+    if (gamemode::getGameModeManager().isCurrentGameMode(gamemode::kVanillaGameModeId) ||
+        gamemode::getGameModeManager().isCurrentGameMode(speedrun::kSpeedrunGameModeId))
+    {
+        mTabBar->add_tab("Achievements", [this] { push(std::make_unique<AchievementsWindow>()); });
+    }
     mTabBar->add_tab("Mods", [this] { push(std::make_unique<ModsWindow>()); });
     for (auto& tab : mods::svc::ui_mod_menu_tabs()) {
         mTabBar->add_tab(tab.label, std::move(tab.onSelected));
@@ -73,7 +94,7 @@ MenuBar::MenuBar()
         push(std::make_unique<Modal>(Modal::Props{
             .title = "Reset Game",
             .bodyRml = "Unsaved progress will be lost.<br/>"
-                       "<span class=\"tip\">Tip: You can also reset by holding Start+X+B</span>",
+                       "<modal-tip>Tip: You can also reset by holding Start+X+B</modal-tip>",
             .actions =
                 {
                     ModalAction{
@@ -93,9 +114,14 @@ MenuBar::MenuBar()
                                     dismiss(modal);
                                     return;
                                 }
-                                JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
                                 dismiss(modal);
+                                if (gamemode::getGameModeManager().getRegisteredGameModes().size() >
+                                    1) {
+                                    // If game modes are registered, return to prelaunch on reset.
+                                    prelaunch_state().returnToPrelaunchOnReset = true;
+                                }
                                 hide(false);
+                                JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
                             },
                     },
                 },
@@ -108,7 +134,7 @@ MenuBar::MenuBar()
         const auto dismiss = [](Modal& modal) { modal.pop(); };
         push(std::make_unique<Modal>(Modal::Props{
             .title = "Quit Dusklight",
-            .bodyRml = "Unsaved progress will be lost.",
+            .bodyText = "Unsaved progress will be lost.",
             .actions =
                 {
                     ModalAction{
@@ -134,39 +160,29 @@ MenuBar::MenuBar()
         }));
     });
 
-    if (getSettings().game.speedrunMode) {
-        mTabBar->add_tab("Reset Timer", [this] {
+    if (speedrun::isActive()) {
+        mTabBar->add_tab("Reset Run", [this] {
             mTabBar->set_active_tab(-1);
             mDoAud_seStartMenu(kSoundClick);
-            m_speedrunInfo.reset();
-            if (getSettings().game.liveSplitEnabled) {
-                dusk::speedrun::reset();
-            }
+            speedrun::g_speedrunInfo.reset();
+            speedrun::reset();
+            JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
             hide(false);
         });
     }
-
-    // Hide document after transition completion
-    listen(mRoot, Rml::EventId::Transitionend, [this](Rml::Event& event) {
-        if (event.GetTargetElement() == mRoot && !mRoot->HasAttribute("open") &&
-            Document::visible())
-        {
-            Document::hide(mPendingClose);
-        }
-    });
 }
 
 void MenuBar::show() {
     Document::show();
     mRoot->SetAttribute("open", "");
     mTabBar->set_active_tab(-1);
-    if (!mTabBar->focus_tab(mFocusedTabIndex)) {
+    if (!mTabBar->focus_tab(mFocusedTabTitle)) {
         mTabBar->focus();
     }
 }
 
 void MenuBar::hide(bool close) {
-    mFocusedTabIndex = mTabBar->focused_tab_index();
+    mFocusedTabTitle = mTabBar->focused_tab_title();
     mRoot->RemoveAttribute("open");
     if (close) {
         mPendingClose = true;
@@ -236,19 +252,19 @@ bool MenuBar::focus() {
     return mTabBar->focus();
 }
 
-void MenuBar::rebuild() {
-    for (auto& doc : get_document_stack()) {
-        if (auto* menuBar = dynamic_cast<MenuBar*>(doc.get())) {
-            const bool wasVisible = menuBar->visible();
-            auto next = std::make_unique<MenuBar>();
-            next->mFocusedTabIndex = menuBar->mFocusedTabIndex;
-            next->mWasVisible = menuBar->mWasVisible;
-            doc = std::move(next);
-            if (wasVisible) {
-                doc->show();
-            }
-            break;
-        }
+void MenuBar::refresh_tabs() {
+    auto* menuBar = static_cast<MenuBar*>(find_document(DocumentScope::MenuBar));
+    if (menuBar == nullptr) {
+        return;
+    }
+    const auto focusedTitle = menuBar->mTabBar->focused_tab_title();
+    if (!focusedTitle.empty()) {
+        menuBar->mFocusedTabTitle = focusedTitle;
+    }
+    menuBar->mTabBar->clear_tabs();
+    menuBar->build_tabs();
+    if (menuBar->visible() && !menuBar->mTabBar->focus_tab(menuBar->mFocusedTabTitle)) {
+        menuBar->mTabBar->focus();
     }
 }
 
diff --git a/src/dusk/ui/menu_bar.hpp b/src/dusk/ui/menu_bar.hpp
index 29ce2199c5..0d33a3f1f7 100644
--- a/src/dusk/ui/menu_bar.hpp
+++ b/src/dusk/ui/menu_bar.hpp
@@ -20,13 +20,15 @@ public:
     void update() override;
     bool focus() override;
     bool visible() const override;
+    bool permanent() const override { return true; }
 
-    static void rebuild();
+    static void refresh_tabs();
 
 protected:
     bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
 
 private:
+    void build_tabs();
     void update_safe_area() noexcept;
 
     Rml::Element* mRoot;
@@ -34,7 +36,7 @@ private:
     std::unique_ptr<Button> mCloseButton;
     Insets mTabBarPadding;
     float mTopMargin = 0.f;
-    int mFocusedTabIndex = -1;
+    Rml::String mFocusedTabTitle;
 };
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/mod_browser.cpp b/src/dusk/ui/mod_browser.cpp
new file mode 100644
index 0000000000..f9ce86a742
--- /dev/null
+++ b/src/dusk/ui/mod_browser.cpp
@@ -0,0 +1,1051 @@
+#include "mod_browser.hpp"
+
+#include "bool_button.hpp"
+#include "button.hpp"
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/loader/packages.hpp"
+#include "dusk/mods/queue.hpp"
+#include "dusk/mods/svc/registry.hpp"
+#include "fmt/format.h"
+#include "format.hpp"
+#include "icon_button.hpp"
+#include "mods_window.hpp"
+#include "nav_group.hpp"
+#include "package_row.hpp"
+#include "queue_window.hpp"
+#include "remote_texture_provider.hpp"
+#include "string_button.hpp"
+
+#include <SDL3/SDL_misc.h>
+#include <borealis/http.hpp>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <cstddef>
+#include <exception>
+#include <memory>
+#include <ranges>
+#include <string_view>
+
+namespace dusk::ui {
+namespace {
+
+struct SortOption {
+    mods::catalog::Sort value;
+    std::string_view label;
+};
+
+constexpr std::array sortOptions{
+    SortOption{mods::catalog::Sort::Updated, "Recently updated"},
+    SortOption{mods::catalog::Sort::Downloads, "Most downloaded"},
+    SortOption{mods::catalog::Sort::Endorsements, "Most endorsed"},
+    SortOption{mods::catalog::Sort::Newest, "Newest"},
+    SortOption{mods::catalog::Sort::Name, "Name"},
+};
+
+std::string_view sort_label(mods::catalog::Sort sort) noexcept {
+    const auto iter = std::ranges::find(sortOptions, sort, &SortOption::value);
+    return iter != sortOptions.end() ? iter->label : sortOptions.front().label;
+}
+
+void add_list_markers(Rml::Element* fragment) {
+    Rml::ElementList lists;
+    fragment->QuerySelectorAll(lists, "ul, ol");
+
+    for (auto* list : lists) {
+        const bool ordered = list->GetTagName() == "ol";
+        int ordinal = list->GetAttribute("start", 1);
+        for (int index = 0; index < list->GetNumChildren(); ++index) {
+            auto* item = list->GetChild(index);
+            if (item->GetTagName() != "li") {
+                continue;
+            }
+
+            auto marker = item->GetOwnerDocument()->CreateElement("catalog-list-marker");
+            Rml::Element* insertedMarker = nullptr;
+            if (auto* firstChild = item->GetFirstChild()) {
+                insertedMarker = item->InsertBefore(std::move(marker), firstChild);
+            } else {
+                insertedMarker = item->AppendChild(std::move(marker));
+            }
+            append_text(insertedMarker, ordered ? fmt::format("{}.", ordinal) : "\u2022");
+            if (ordered) {
+                ++ordinal;
+            }
+        }
+    }
+}
+
+std::string image_source(const mods::catalog::Image& image, uint32_t preferredWidth) {
+    const auto wider = std::ranges::find_if(image.sources,
+        [preferredWidth](const auto& source) { return source.width >= preferredWidth; });
+    if (wider != image.sources.end()) {
+        return wider->pngUrl;
+    }
+    return image.sources.empty() ? std::string{} : image.sources.back().pngUrl;
+}
+
+std::optional<mods::queue::Icon> queue_icon(const std::optional<mods::catalog::Image>& image) {
+    if (!image) {
+        return std::nullopt;
+    }
+    auto source = image_source(*image, 128);
+    if (source.empty()) {
+        return std::nullopt;
+    }
+    return mods::queue::Icon{
+        .url = std::move(source),
+        .width = image->width,
+        .height = image->height,
+    };
+}
+
+void set_image(Rml::Element* element, const mods::catalog::Image& image, uint32_t preferredWidth,
+    std::string_view fit = "cover") {
+    if (element == nullptr) {
+        return;
+    }
+    auto source = image_source(image, preferredWidth);
+    if (!source.empty()) {
+        source = remote_image_source(source, image.width, image.height);
+        element->SetProperty(
+            "decorator", fmt::format(R"(image("{}" {} center center))", escape(source), fit));
+        element->SetClass("has-image", true);
+    }
+}
+
+std::string_view activation_failure(const mods::LoadedMod& mod) {
+    if (!mod.failureReason.empty()) {
+        return mod.failureReason;
+    }
+    return mod.suspendedByProvider ? "A required provider is unavailable" : "Activation failed";
+}
+
+void open_web_url(const std::string& url) {
+    if (url.starts_with("https://")) {
+        SDL_OpenURL(url.c_str());
+    }
+}
+
+void set_icon_button_content(Button& button, std::string_view icon, const Rml::String& label) {
+    clear_children(button.root());
+    append_text(append(button.root(), "icon"), material_icon(icon));
+    append_text_element(button.root(), "span", label);
+}
+
+void append_status(Rml::Element* parent, const Rml::String& title, const Rml::String& message) {
+    append_text_element(parent, "h2", title);
+    append_text_element(parent, "p", message);
+}
+
+void append_stat(Rml::Element* parent, std::string_view icon, const Rml::String& value,
+    const Rml::String& suffix) {
+    auto* stat = append(parent, "stat");
+    if (!icon.empty()) {
+        append_text(append(stat, "icon"), material_icon(icon));
+    }
+    append_text_element(stat, "span", value + suffix);
+}
+
+void append_detail_field(Rml::Element* list, const Rml::String& label, const Rml::String& value) {
+    append_text_element(list, "dt", label);
+    append_text_element(list, "dd", value);
+}
+
+class ModBrowserDetail;
+
+class CatalogCard final : public Button {
+public:
+    CatalogCard(Rml::Element* parent, const mods::catalog::Mod& mod, std::function<void()> onOpen)
+        : Button{parent, Props{}} {
+        mRoot->SetClass("catalog-card", true);
+        const auto category = mod.category ? mod.category->name : "Uncategorized";
+        const auto isInstalled = mods::ModLoader::instance().find_mod(mod.id) != nullptr;
+        const auto installedLabel = isInstalled ? "Installed" : format_bytes(mod.packageSize);
+
+        auto* art = append(mRoot, "catalog-card-art");
+        auto* artImage = append(art, "catalog-card-art-image");
+        auto* icon = append(art, "mod-icon");
+        auto* iconImage = append(icon, "mod-icon-image");
+
+        auto* body = append(mRoot, "catalog-card-body");
+        append_text_element(body, "small", relative_date(mod.updatedAt));
+        auto* identity = append(body, "section");
+        append_text_element(identity, "b", category);
+        append_text_element(identity, "h2", mod.name);
+        append_text_element(identity, "small", fmt::format("by {}", mod.author.name));
+        append_text_element(body, "p", snippet(mod.summary, 126));
+        auto* meta = append(body, "footer");
+        auto* downloads = append(meta, "stat");
+        append_text(append(downloads, "icon"), material_icon("download"));
+        append_text_element(downloads, "span", format_count(mod.downloads));
+        auto* endorsements = append(meta, "stat");
+        append_text(append(endorsements, "icon"), material_icon("favorite"));
+        append_text_element(endorsements, "span", format_count(mod.endorsements));
+        auto* size = append_text_element(meta, "small", installedLabel);
+        size->SetClass("size", true);
+        if (isInstalled) {
+            size->SetClass("installed", true);
+        }
+
+        if (mod.banner) {
+            set_image(artImage, *mod.banner, 640);
+        } else if (mod.icon) {
+            set_image(artImage, *mod.icon, 256);
+        }
+        if (mod.icon) {
+            set_image(iconImage, *mod.icon, 128);
+        }
+        on_pressed(std::move(onOpen));
+    }
+};
+
+class ScreenshotViewer final : public Window {
+public:
+    ScreenshotViewer(std::vector<mods::catalog::Screenshot> screenshots, size_t index)
+        : Window{Props{
+              .tabBar = false,
+              .styleSheets = {"res/rml/mod_browser.rcss"},
+          }},
+          mScreenshots{std::move(screenshots)}, mIndex{index} {
+        mRoot->SetClass("screenshot-viewer", true);
+        set_content([this](Rml::Element* content) { build_content(content); });
+    }
+
+    void update() override {
+        if (mRebuildRequested) {
+            mRebuildRequested = false;
+            rebuild_content();
+        }
+        Window::update();
+    }
+
+private:
+    void build_content(Rml::Element* content) {
+        auto* image = append(content, "catalog-screenshot-full");
+        if (mIndex < mScreenshots.size()) {
+            set_image(image, mScreenshots[mIndex].image, 1280, "contain");
+        }
+
+        auto* actionsRoot = append(content, "catalog-screenshot-actions");
+        auto& actions =
+            add_child<NavGroup>(actionsRoot, NavGroup::Props{
+                                                 .layout = NavGroup::Layout::Horizontal,
+                                                 .horizontalBoundary = NavGroup::Boundary::Stop,
+                                                 .verticalBoundary = NavGroup::Boundary::Stop,
+                                             });
+        auto& back = actions.add_item<Button>("Back");
+        back.root()->SetClass("catalog-icon-action", true);
+        set_icon_button_content(back, "arrow_back", "Back");
+        back.on_pressed([this] { pop(); });
+        auto& previous = actions.add_item<ControlledButton>(ControlledButton::Props{
+            .text = "Previous",
+            .isDisabled = [this] { return mIndex == 0; },
+        });
+        previous.on_pressed([this] {
+            if (mIndex > 0) {
+                --mIndex;
+                mRestoreNav = -1;
+                mRebuildRequested = true;
+            }
+        });
+        actions.add_item<ControlledButton>(ControlledButton::Props{
+            .text = fmt::format("{} / {}", mIndex + 1, mScreenshots.size()),
+            .isDisabled = [] { return true; },
+        });
+        auto& next = actions.add_item<ControlledButton>(ControlledButton::Props{
+            .text = "Next",
+            .isDisabled = [this] { return mIndex + 1 >= mScreenshots.size(); },
+        });
+        next.on_pressed([this] {
+            if (mIndex + 1 < mScreenshots.size()) {
+                ++mIndex;
+                mRestoreNav = 1;
+                mRebuildRequested = true;
+            }
+        });
+        if (mRestoreNav < 0) {
+            if (!previous.focus()) {
+                next.focus();
+            }
+        } else if (mRestoreNav > 0) {
+            if (!next.focus()) {
+                previous.focus();
+            }
+        }
+        mRestoreNav = 0;
+    }
+
+    std::vector<mods::catalog::Screenshot> mScreenshots;
+    size_t mIndex = 0;
+    bool mRebuildRequested = false;
+    int mRestoreNav = 0;
+};
+
+class DetailContent final : public NavGroup {
+public:
+    DetailContent(
+        Rml::Element* root, ModBrowserDetail& window, const mods::catalog::Detail& detail);
+};
+
+class ScrollAnchor final : public Component {
+public:
+    using Component::Component;
+};
+
+class ModBrowserDetail final : public Window {
+public:
+    explicit ModBrowserDetail(mods::catalog::Mod mod)
+        : Window{Props{.tabBar = false, .styleSheets = {"res/rml/mod_browser.rcss"}}},
+          mSummary{std::move(mod)} {
+        mRoot->SetClass("mod-browser-detail", true);
+        set_content([this](Rml::Element* content) { build_content(content); });
+        begin_fetch();
+    }
+
+    void update() override {
+        if (mFetch && mFetch.ready()) {
+            try {
+                if (auto result = mFetch.try_take()) {
+                    if (result->detail) {
+                        mDetail = std::move(result->detail);
+                        mError.clear();
+                    } else {
+                        mError = result->error.empty() ? "The mod request failed." :
+                                                         std::move(result->error);
+                    }
+                }
+            } catch (const std::exception& exception) {
+                mError = fmt::format("The mod request failed: {}", exception.what());
+            } catch (...) {
+                mError = "The mod request failed.";
+            }
+            mFetch = {};
+            mRebuildRequested = true;
+        }
+        if (mRebuildRequested) {
+            mRebuildRequested = false;
+            rebuild_content();
+        }
+        Window::update();
+    }
+
+    void show_screenshot(size_t index) {
+        if (mDetail && index < mDetail->screenshots.size()) {
+            push(std::make_unique<ScreenshotViewer>(mDetail->screenshots, index));
+        }
+    }
+
+    void show_downloads(const std::string& id) { push(std::make_unique<QueueWindow>(id)); }
+
+private:
+    void begin_fetch() {
+        mDetail.reset();
+        mError.clear();
+        mFetch = mods::catalog::fetch_detail(mSummary.id);
+        mRebuildRequested = true;
+    }
+
+    void build_content(Rml::Element* content) {
+        if (mDetail) {
+            auto* scroll = append(content, "detail-scroll");
+            add_child<DetailContent>(scroll, *this, *mDetail);
+            return;
+        }
+
+        auto* status = append(content, "catalog-detail-status");
+        if (mError.empty()) {
+            append_status(status, fmt::format("Loading {}", mSummary.name),
+                "Fetching mod details and images...");
+            return;
+        }
+        append_status(status, fmt::format("Could not load {}", mSummary.name), mError);
+        auto* retryRoot = append(status, "catalog-retry-actions");
+        auto& retry = add_child<NavGroup>(retryRoot, NavGroup::Props{});
+        retry.add_item<Button>("Retry").on_pressed([this] { begin_fetch(); });
+    }
+
+    mods::catalog::Mod mSummary;
+    std::optional<mods::catalog::Detail> mDetail;
+    borealis::Task<mods::catalog::DetailFetchResult> mFetch;
+    std::string mError;
+    bool mRebuildRequested = false;
+};
+
+class CatalogInstallButton final : public Button {
+public:
+    CatalogInstallButton(
+        Rml::Element* parent, ModBrowserDetail& window, const mods::catalog::Detail& detail)
+        : Button{parent, Props{}}, mWindow{window}, mRequest{
+                                                        .id = detail.mod.id,
+                                                        .name = detail.mod.name,
+                                                        .version = detail.mod.version,
+                                                        .source =
+                                                            mods::queue::Url{
+                                                                .url = detail.download.url,
+                                                                .sha256 = detail.download.sha256,
+                                                                .size = detail.download.size,
+                                                            },
+                                                        .icon = queue_icon(detail.mod.icon),
+                                                    } {
+        mRoot->SetClass("catalog-install-action", true);
+        mCaption = append(parent, "catalog-install-caption");
+        on_pressed([this] { press(); });
+        update();
+    }
+
+    void update() override {
+        auto queued = matching_queue_item();
+        const auto* local = mods::ModLoader::instance().find_mod(mRequest.id);
+        const bool activationPending =
+            mActivationOperation != nullptr &&
+            mActivationOperation->state == mods::ModOperation::State::Pending;
+        if (mActivationOperation != nullptr && !activationPending) {
+            mActivationOperation.reset();
+        }
+        std::string_view icon = "file_download";
+        std::string label;
+        std::string caption = format_bytes(package_size());
+        std::string state = "idle";
+        float progress = 0.0f;
+        bool disabled = false;
+        mAction = Action::Install;
+
+        if (queued && queued->state != mods::queue::State::Canceled) {
+            using enum mods::queue::State;
+            mAction = Action::OpenQueue;
+            mQueueId = queued->id;
+            state = queue_state_class(queued->state);
+            progress = queued->total == 0 ? 0.0f :
+                                            std::clamp(static_cast<float>(queued->completed) /
+                                                           static_cast<float>(queued->total),
+                                                0.0f, 1.0f);
+            switch (queued->state) {
+            case Queued:
+                icon = "schedule";
+                label = "Queued";
+                if (const auto ahead = mods::queue::active_items_ahead(mRequest.id); ahead != 0) {
+                    caption = fmt::format("{} ahead · opens the queue", ahead);
+                } else {
+                    caption = "Next · opens the queue";
+                }
+                break;
+            case Downloading:
+                label = fmt::format(
+                    "{} / {}", format_bytes(queued->completed), format_bytes(queued->total));
+                caption = "Tap to open the queue";
+                break;
+            case Paused:
+                icon = "play_arrow";
+                label = "Resume";
+                caption = fmt::format("{} kept on disk", format_bytes(queued->completed));
+                break;
+            case Retrying:
+                icon = "warning";
+                label = fmt::format("Retrying in {}s", queued->retrySeconds);
+                caption = "Network error · keeps retrying itself";
+                break;
+            case Verifying:
+                icon = "schedule";
+                label = "Verifying…";
+                caption = "Checking package integrity";
+                break;
+            case Handoff:
+                icon = "schedule";
+                label = "Installing…";
+                caption = "Applying package";
+                progress = 1.0f;
+                disabled = true;
+                break;
+            case Installed:
+            case InstallFailed:
+                break;
+            case Failed:
+                icon = "refresh";
+                label = queued->local ? "Retry package" : "Retry download";
+                caption = queued->message.empty() ? "Package preparation failed" : queued->message;
+                progress = 1.0f;
+                break;
+            case Canceled:
+                break;
+            }
+        }
+
+        if (label.empty()) {
+            mAction = Action::Install;
+            const int versionOrder = local != nullptr ?
+                mods::compare_package_versions(mRequest.version, local->metadata.version) : 1;
+            const bool current = local != nullptr && versionOrder == 0;
+            const bool updateable =
+                local != nullptr && versionOrder > 0 &&
+                mods::ModLoader::instance().can_update(*local);
+            if (activationPending) {
+                icon = "schedule";
+                label = "Activating…";
+                caption = "Retrying mod activation";
+                state = "installing";
+                progress = 1.0f;
+                disabled = true;
+            } else if (current && local->activation_failed()) {
+                mAction = Action::RetryActivation;
+                icon = "refresh";
+                label = "Retry activation";
+                caption = activation_failure(*local);
+                state = "failed";
+                progress = 1.0f;
+            } else if (current || (local != nullptr && !updateable)) {
+                mAction = Action::OpenManager;
+                icon = "check_circle";
+                label = "Installed";
+                caption = fmt::format("Installed · {} · {}", format_bytes(package_size()),
+                    local != nullptr && local->active ? "enabled" : "disabled");
+                state = "installed";
+                progress = 1.0f;
+            } else {
+                label = updateable ? "Update" : "Install";
+            }
+        }
+        if (disabled) {
+            mAction = Action::None;
+        }
+
+        if (mLabel != label || mIcon != icon) {
+            ui::clear_children(mRoot);
+            append_text(append(mRoot, "icon"), material_icon(icon));
+            append_text_element(mRoot, "span", label);
+            mProgress = append(mRoot, "progress");
+            mLabel = std::move(label);
+            mIcon = icon;
+        }
+        set_text_content(mCaption, caption);
+        for (const auto* candidate : {"idle", "queued", "downloading", "paused", "retrying",
+                 "installing", "installed", "failed"})
+        {
+            mRoot->SetClass(candidate, state == candidate);
+            mCaption->SetClass(candidate, state == candidate);
+        }
+        if (mProgress != nullptr) {
+            mProgress->SetAttribute("value", progress);
+            mProgress->SetProperty(
+                "display", state == "idle" || state == "installed" ? "none" : "block");
+        }
+        set_disabled(disabled);
+        Button::update();
+    }
+
+private:
+    enum class Action { Install, OpenQueue, RetryActivation, OpenManager, None };
+
+    std::optional<mods::queue::Item> matching_queue_item() const {
+        auto item = mods::queue::find_by_mod_id(mRequest.id);
+        if (!item || item->version != mRequest.version ||
+            mods::queue::is_install_result(item->state))
+        {
+            return std::nullopt;
+        }
+        return item;
+    }
+
+    void press() {
+        update();
+        switch (mAction) {
+        case Action::OpenQueue:
+            mWindow.show_downloads(mQueueId);
+            return;
+        case Action::RetryActivation:
+            mActivationOperation = mods::ModLoader::instance().request_reactivate(mRequest.id);
+            return;
+        case Action::OpenManager:
+            pop_to_or_push<ModsWindow>([id = mRequest.id](ModsWindow& window) {
+                window.select_mod(id);
+            });
+            return;
+        case Action::None:
+            return;
+        case Action::Install:
+            break;
+        }
+        if (!mods::queue::enqueue(mRequest)) {
+            push_toast({
+                .type = "warning",
+                .title = "Could not start download",
+                .content = "The catalog download descriptor is invalid.",
+                .duration = std::chrono::seconds{5},
+            });
+        }
+    }
+
+    ModBrowserDetail& mWindow;
+    mods::queue::Request mRequest;
+    Rml::Element* mCaption = nullptr;
+    Rml::Element* mProgress = nullptr;
+    std::string mLabel;
+    std::string mIcon;
+    std::string mQueueId;
+    Action mAction = Action::None;
+    mods::ModOperationHandle mActivationOperation;
+
+    uint64_t package_size() const { return std::get<mods::queue::Url>(mRequest.source).size; }
+};
+
+DetailContent::DetailContent(
+    Rml::Element* root, ModBrowserDetail& window, const mods::catalog::Detail& detail)
+    : NavGroup{root, Props{
+                         .layout = Layout::Vertical,
+                         .horizontalBoundary = Boundary::Stop,
+                         .verticalBoundary = Boundary::Stop,
+                     }} {
+    auto* hero = append(mRoot, "catalog-detail-hero");
+    auto* heroImage = append(hero, "catalog-detail-hero-image");
+    if (detail.mod.banner) {
+        set_image(heroImage, *detail.mod.banner, 1280);
+    } else if (detail.mod.icon) {
+        set_image(heroImage, *detail.mod.icon, 512);
+    }
+
+    auto* actionsRoot = append(hero, "catalog-detail-actions");
+    auto& actions =
+        add_existing_item<NavGroup>(actionsRoot, Props{
+                                                     .layout = Layout::Horizontal,
+                                                     .horizontalBoundary = Boundary::Bubble,
+                                                     .verticalBoundary = Boundary::Bubble,
+                                                 });
+    auto& back = actions.add_item<Button>("Back");
+    back.root()->SetClass("catalog-icon-action", true);
+    set_icon_button_content(back, "arrow_back", "Back");
+    back.on_pressed([&window] { window.pop(); });
+    auto& open = actions.add_item<Button>("Open in browser");
+    open.root()->SetClass("catalog-icon-action", true);
+    set_icon_button_content(open, "open_in_new", "Open in browser");
+    open.on_pressed([url = detail.siteUrl] { open_web_url(url); });
+
+    auto* identity = append(hero, "catalog-detail-identity");
+    auto* detailIcon = append(identity, "mod-icon");
+    auto* detailIconImage = append(detailIcon, "mod-icon-image");
+    auto* detailHeading = append(identity, "header");
+    append_text_element(
+        detailHeading, "b", detail.mod.category ? detail.mod.category->name : "Uncategorized");
+    auto* title = append(detailHeading, "h1");
+    append_text(title, detail.mod.name);
+    append_text_element(title, "small", fmt::format("v{}", detail.mod.version));
+    auto* author = append(detailHeading, "p");
+    append_text(author, fmt::format("by {} ", detail.mod.author.name));
+    if (detail.mod.author.official) {
+        append_text_element(author, "catalog-official-badge", "Official");
+    }
+    if (detail.mod.icon) {
+        set_image(detailIconImage, *detail.mod.icon, 256);
+    }
+    auto* installRoot = append(identity, "catalog-install-control");
+    auto& installControl =
+        add_existing_item<NavGroup>(installRoot, Props{
+                                                     .layout = Layout::Vertical,
+                                                     .horizontalBoundary = Boundary::Bubble,
+                                                     .verticalBoundary = Boundary::Bubble,
+                                                 });
+    installControl.add_item<CatalogInstallButton>(window, detail);
+
+    auto* stats = append(mRoot, "catalog-detail-stats");
+    append_stat(stats, "download", format_count(detail.mod.downloads), " downloads");
+    append_stat(stats, "favorite", format_count(detail.mod.endorsements), " endorsements");
+
+    auto* body = append(mRoot, "catalog-detail-body");
+    auto* main = append(body, "main");
+    auto* sidebar = append(body, "aside");
+
+    auto* description = append(main, "section");
+    description->SetClass("catalog-scroll-anchor", true);
+    add_existing_item<ScrollAnchor>(description);
+    auto* descriptionFragment = append(description, "catalog-fragment");
+    if (detail.descriptionHtml.empty()) {
+        append_text_element(descriptionFragment, "p", "No description provided.");
+    } else {
+        descriptionFragment->SetInnerRML(detail.descriptionHtml);
+        add_list_markers(descriptionFragment);
+    }
+
+    if (!detail.screenshots.empty()) {
+        auto* section = append(main, "section");
+        append_text(append(section, "h2"), "Screenshots");
+        auto* galleryRoot = append(section, "catalog-gallery");
+        auto& gallery =
+            add_existing_item<NavGroup>(galleryRoot, Props{
+                                                         .layout = Layout::Horizontal,
+                                                         .horizontalBoundary = Boundary::Bubble,
+                                                         .verticalBoundary = Boundary::Bubble,
+                                                     });
+        const size_t shown = std::min<size_t>(detail.screenshots.size(), 3);
+        for (size_t index = 0; index < shown; ++index) {
+            auto& screenshot = gallery.add_item<Button>(Button::Props{});
+            screenshot.root()->SetClass("catalog-screenshot", true);
+            screenshot.root()->SetClass("primary", index == 0);
+            auto* image = append(screenshot.root(), "catalog-screenshot-image");
+            set_image(image, detail.screenshots[index].image, index == 0 ? 1280 : 640);
+            if (index == 2 && detail.screenshots.size() > shown) {
+                auto* more = append(screenshot.root(), "catalog-screenshot-more");
+                append_text_element(more, "span", fmt::format("+{}", detail.screenshots.size() - shown));
+            }
+            screenshot.on_pressed([&window, index] { window.show_screenshot(index); });
+        }
+    }
+
+    if (std::ranges::any_of(detail.serviceImports, [](const auto& import) { return !import.optional; })) {
+        auto* dependencies = append(main, "section");
+        dependencies->SetClass("catalog-scroll-anchor", true);
+        add_existing_item<ScrollAnchor>(dependencies);
+        append_text(append(dependencies, "h2"), "Dependencies");
+        auto* dependencyList = append(dependencies, "catalog-dependencies");
+        size_t requiredDusklight = 0;
+        std::vector<std::string> dusklightProblems;
+        for (const auto& import : detail.serviceImports) {
+            if (import.optional) {
+                continue;
+            }
+            const bool available =
+                mods::svc::find_service(import.id.c_str(), import.major, import.minMinor) != nullptr;
+            if (import.id.starts_with(DUSKLIGHT_SERVICE_ID_PREFIX)) {
+                ++requiredDusklight;
+                if (!available) {
+                    dusklightProblems.push_back(mods::svc::describe_missing_service(
+                        import.id.c_str(), import.major, import.minMinor));
+                }
+                continue;
+            }
+            auto* row = append(dependencyList, "catalog-dependency");
+            append_text_element(row, "catalog-dependency-name", import.id);
+            append_text_element(row, "catalog-dependency-status",
+                fmt::format("v{}.{}+ · {}", import.major, import.minMinor,
+                    available ? "Available" : "Not available"));
+            row->SetClass("missing", !available);
+        }
+        if (requiredDusklight != 0) {
+            auto* row = append(dependencyList, "catalog-dependency");
+            append_text_element(row, "catalog-dependency-name", "Dusklight services");
+            append_text_element(row, "catalog-dependency-status",
+                dusklightProblems.empty() ? fmt::format("{} required · Available", requiredDusklight) :
+                                           fmt::format("{} required", requiredDusklight));
+            for (const auto& problem : dusklightProblems) {
+                append_text_element(row, "catalog-dependency-status", problem);
+            }
+            row->SetClass("missing", !dusklightProblems.empty());
+        }
+    }
+
+    auto* changelog = append(main, "section");
+    changelog->SetClass("catalog-scroll-anchor", true);
+    add_existing_item<ScrollAnchor>(changelog);
+    auto* changelogTitle = append(changelog, "h2");
+    append_text(changelogTitle, "Changelog ");
+    append_text_element(changelogTitle, "small",
+        fmt::format("v{} · {}", detail.mod.version, display_date(detail.mod.updatedAt)));
+    auto* changelogFragment = append(changelog, "catalog-fragment");
+    if (detail.changelogHtml.empty()) {
+        append_text_element(changelogFragment, "p", "No changelog was provided.");
+    } else {
+        changelogFragment->SetInnerRML(detail.changelogHtml);
+        add_list_markers(changelogFragment);
+    }
+
+    auto* detailList = append(sidebar, "dl");
+    append_detail_field(detailList, "Version", detail.mod.version);
+    append_detail_field(detailList, "Last updated", display_date(detail.mod.updatedAt));
+    append_detail_field(
+        detailList, "Category", detail.mod.category ? detail.mod.category->name : "Uncategorized");
+    if (detail.license && !detail.license->empty()) {
+        append_detail_field(detailList, "License", *detail.license);
+    }
+}
+
+}  // namespace
+
+ModBrowser::ModBrowser()
+    : Window{Props{.tabBar = false, .styleSheets = {"res/rml/mod_browser.rcss"}}} {
+    mRoot->SetClass("mod-browser", true);
+    mQuery.sort = mods::catalog::Sort::Updated;
+    mLoaderGeneration = mods::ModLoader::instance().generation();
+    mState = borealis::http::available() ? State::Loading : State::Unavailable;
+    set_content([this](Rml::Element* content) { build_content(content); });
+    if (mState == State::Loading) {
+        mFetch = mods::catalog::fetch_page(mQuery);
+    }
+}
+
+void ModBrowser::build_content(Rml::Element* content) {
+    auto* filtersRoot = append(content, "catalog-filters");
+    auto& filters =
+        add_child<NavGroup>(filtersRoot, NavGroup::Props{
+                                             .layout = NavGroup::Layout::Vertical,
+                                             .horizontalBoundary = NavGroup::Boundary::Bubble,
+                                             .verticalBoundary = NavGroup::Boundary::Stop,
+                                         });
+    append_text(append(filtersRoot, "h1"), "Browse Mods");
+    auto& search = filters.add_item<StringButton>(StringButton::Props{
+        .key = "Search",
+        .getValue = [this] { return mQuery.search; },
+        .setValue =
+            [this](Rml::String value) {
+                if (mQuery.search != value) {
+                    mQuery.search = std::move(value);
+                    mQuery.page = 1;
+                    begin_fetch(FocusTarget::Search);
+                }
+            },
+        .maxLength = 100,
+    });
+    append_text(append(filtersRoot, "h2"), "Category");
+    auto& category = filters.add_item<ControlledSelectButton>(ControlledSelectButton::Props{
+        .key = "Category",
+        .getValue =
+            [this] {
+                if (mQuery.category.empty() || !mPage) {
+                    return Rml::String{"All mods"};
+                }
+                const auto iter = std::ranges::find(
+                    mPage->categories, mQuery.category, &mods::catalog::Category::slug);
+                return iter == mPage->categories.end() ? Rml::String{"All mods"} : iter->name;
+            },
+    });
+    category.on_pressed([this] { cycle_category(); });
+    auto& sort = filters.add_item<ControlledSelectButton>(ControlledSelectButton::Props{
+        .key = "Sort by",
+        .getValue = [this] { return Rml::String{sort_label(mQuery.sort)}; },
+    });
+    sort.on_pressed([this] { cycle_sort(); });
+    auto& device = filters.add_item<BoolButton>(BoolButton::Props{
+        .key = "This device",
+        .getValue = [this] { return mQuery.thisDevice; },
+        .setValue =
+            [this](bool value) {
+                if (mQuery.thisDevice != value) {
+                    mQuery.thisDevice = value;
+                    mQuery.page = 1;
+                    begin_fetch(FocusTarget::Device);
+                }
+            },
+    });
+    append_text(append(filtersRoot, "h2"), "Library");
+    auto& library = filters.add_item<Button>(
+        fmt::format("Installed mods ({})", mods::ModLoader::instance().mods().size()));
+    library.root()->SetClass("catalog-library-link", true);
+    library.on_pressed([this] { pop(); });
+
+    auto* resultsRoot = append(content, "catalog-results");
+    auto& results =
+        add_child<NavGroup>(resultsRoot, NavGroup::Props{
+                                             .layout = NavGroup::Layout::Vertical,
+                                             .horizontalBoundary = NavGroup::Boundary::Bubble,
+                                             .verticalBoundary = NavGroup::Boundary::Stop,
+                                         });
+    auto* heading = append(resultsRoot, "header");
+    const std::string categoryName = [&] {
+        if (mQuery.category.empty() || !mPage) {
+            return std::string{"All mods"};
+        }
+        const auto iter =
+            std::ranges::find(mPage->categories, mQuery.category, &mods::catalog::Category::slug);
+        return iter == mPage->categories.end() ? std::string{"All mods"} : iter->name;
+    }();
+    const uint64_t total = mPage ? mPage->pagination.total : 0;
+    append_text_element(heading, "h1", categoryName);
+    append_text_element(
+        heading, "small", fmt::format("{} mods · sorted by {}", total, sort_label(mQuery.sort)));
+
+    Component* resultFocus = nullptr;
+    Component* retryFocus = nullptr;
+    auto* viewport = append(resultsRoot, "catalog-viewport");
+
+    if (mState == State::Ready && mPage && !mPage->mods.empty()) {
+        auto* gridRoot = append(viewport, "catalog-grid");
+        auto& grid = results.add_existing_item<NavGroup>(
+            gridRoot, NavGroup::Props{
+                          .layout = NavGroup::Layout::Grid,
+                          .columns = 2,
+                          .horizontalBoundary = NavGroup::Boundary::Bubble,
+                          .verticalBoundary = NavGroup::Boundary::Bubble,
+                      });
+        for (const auto& mod : mPage->mods) {
+            auto& card = grid.add_item<CatalogCard>(
+                mod, [this, mod] { push(std::make_unique<ModBrowserDetail>(mod)); });
+            if (resultFocus == nullptr) {
+                resultFocus = &card;
+            }
+        }
+
+        if (mPage->pagination.pageCount > 1) {
+            auto* paginationRoot = append(resultsRoot, "catalog-pagination");
+            auto& pagination = results.add_existing_item<NavGroup>(
+                paginationRoot, NavGroup::Props{
+                                    .layout = NavGroup::Layout::Horizontal,
+                                    .horizontalBoundary = NavGroup::Boundary::Stop,
+                                    .verticalBoundary = NavGroup::Boundary::Bubble,
+                                });
+            pagination
+                .add_item<ControlledButton>(ControlledButton::Props{
+                    .text = "Previous",
+                    .isDisabled = [this] { return mQuery.page <= 1; },
+                })
+                .on_pressed([this] {
+                    if (mQuery.page > 1) {
+                        --mQuery.page;
+                        begin_fetch(FocusTarget::Results);
+                    }
+                });
+            auto* label = append(paginationRoot, "catalog-pagination-label");
+            append_text(label,
+                fmt::format("Page {} of {}", mPage->pagination.page, mPage->pagination.pageCount));
+            pagination
+                .add_item<ControlledButton>(ControlledButton::Props{
+                    .text = "Next",
+                    .isDisabled =
+                        [this] { return !mPage || mQuery.page >= mPage->pagination.pageCount; },
+                })
+                .on_pressed([this] {
+                    if (mPage && mQuery.page < mPage->pagination.pageCount) {
+                        ++mQuery.page;
+                        begin_fetch(FocusTarget::Results);
+                    }
+                });
+        }
+    } else {
+        auto* status = append(viewport, "catalog-results-status");
+        switch (mState) {
+        case State::Loading:
+            // TODO better loading state
+            append_status(status, "Loading catalog", "Fetching published mods...");
+            break;
+        case State::Unavailable:
+            append_status(status, "Catalog unavailable", "This build has no HTTP backend.");
+            break;
+        case State::Error: {
+            append_status(status, "Could not load mods", mError);
+            auto* retryRoot = append(status, "catalog-retry-actions");
+            auto& retryGroup = results.add_existing_item<NavGroup>(retryRoot, NavGroup::Props{});
+            auto& retry = retryGroup.add_item<Button>("Retry");
+            retry.on_pressed([this] { begin_fetch(FocusTarget::Retry); });
+            retryFocus = &retry;
+            break;
+        }
+        case State::Ready:
+            append_status(status, "No mods found", "Try changing the search or category.");
+            break;
+        }
+    }
+
+    Component* focus = nullptr;
+    switch (mFocusTarget) {
+    case FocusTarget::Search:
+        focus = &search;
+        break;
+    case FocusTarget::Category:
+        focus = &category;
+        break;
+    case FocusTarget::Sort:
+        focus = &sort;
+        break;
+    case FocusTarget::Device:
+        focus = &device;
+        break;
+    case FocusTarget::Results:
+        focus = resultFocus;
+        break;
+    case FocusTarget::Retry:
+        focus = retryFocus;
+        break;
+    case FocusTarget::Default:
+        break;
+    }
+    if (mState != State::Loading) {
+        mFocusTarget = FocusTarget::Default;
+    }
+    if (focus != nullptr) {
+        focus->focus();
+    }
+}
+
+void ModBrowser::begin_fetch(FocusTarget focusTarget) {
+    mFocusTarget = focusTarget;
+    if (!borealis::http::available()) {
+        mState = State::Unavailable;
+        mFetch = {};
+    } else {
+        mState = State::Loading;
+        mError.clear();
+        mFetch = mods::catalog::fetch_page(mQuery);
+    }
+    mRebuildRequested = true;
+}
+
+void ModBrowser::finish_fetch(mods::catalog::FetchResult result) {
+    if (result.page) {
+        mPage = std::move(result.page);
+        mQuery.page = std::max(mPage->pagination.page, 1);
+        mState = State::Ready;
+        mError.clear();
+        if (mFocusTarget == FocusTarget::Retry) {
+            mFocusTarget = FocusTarget::Results;
+        }
+    } else {
+        mState = State::Error;
+        mError = result.error.empty() ? "The catalog request failed." : std::move(result.error);
+    }
+    if (mFocusTarget == FocusTarget::Default) {
+        mFocusTarget = FocusTarget::Search;
+    }
+    mRebuildRequested = true;
+}
+
+void ModBrowser::cycle_category() {
+    if (!mPage || mPage->categories.empty()) {
+        return;
+    }
+    if (mQuery.category.empty()) {
+        mQuery.category = mPage->categories.front().slug;
+    } else {
+        const auto iter =
+            std::ranges::find(mPage->categories, mQuery.category, &mods::catalog::Category::slug);
+        const auto next =
+            iter == mPage->categories.end() ? mPage->categories.begin() : std::next(iter);
+        mQuery.category = next == mPage->categories.end() ? std::string{} : next->slug;
+    }
+    mQuery.page = 1;
+    begin_fetch(FocusTarget::Category);
+}
+
+void ModBrowser::cycle_sort() {
+    const auto iter = std::ranges::find(sortOptions, mQuery.sort, &SortOption::value);
+    const auto next = iter == sortOptions.end() || std::next(iter) == sortOptions.end() ?
+                          sortOptions.begin() :
+                          std::next(iter);
+    mQuery.sort = next->value;
+    mQuery.page = 1;
+    begin_fetch(FocusTarget::Sort);
+}
+
+void ModBrowser::update() {
+    const auto loaderGeneration = mods::ModLoader::instance().generation();
+    if (loaderGeneration != mLoaderGeneration) {
+        mLoaderGeneration = loaderGeneration;
+        mRebuildRequested = true;
+    }
+    if (mFetch && mFetch.ready()) {
+        try {
+            if (auto result = mFetch.try_take()) {
+                finish_fetch(std::move(*result));
+            }
+        } catch (const std::exception& exception) {
+            finish_fetch(
+                {.error = fmt::format("The catalog request failed: {}", exception.what())});
+        } catch (...) {
+            finish_fetch({.error = "The catalog request failed."});
+        }
+        mFetch = {};
+    }
+    if (mRebuildRequested) {
+        mRebuildRequested = false;
+        rebuild_content();
+    }
+    Window::update();
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/mod_browser.hpp b/src/dusk/ui/mod_browser.hpp
new file mode 100644
index 0000000000..7604dd1621
--- /dev/null
+++ b/src/dusk/ui/mod_browser.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "dusk/mods/catalog.hpp"
+#include "window.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace dusk::ui {
+
+class ModBrowser final : public Window {
+public:
+    ModBrowser();
+
+    void update() override;
+
+private:
+    enum class State {
+        Loading,
+        Ready,
+        Error,
+        Unavailable,
+    };
+    enum class FocusTarget {
+        Default,
+        Search,
+        Category,
+        Sort,
+        Device,
+        Results,
+        Retry,
+    };
+
+    void build_content(Rml::Element* content);
+    void begin_fetch(FocusTarget focusTarget);
+    void finish_fetch(mods::catalog::FetchResult result);
+    void cycle_category();
+    void cycle_sort();
+
+    mods::catalog::Query mQuery;
+    std::optional<mods::catalog::Page> mPage;
+    borealis::Task<mods::catalog::FetchResult> mFetch;
+    std::string mError;
+    State mState = State::Loading;
+    FocusTarget mFocusTarget = FocusTarget::Default;
+    uint64_t mLoaderGeneration = 0;
+    bool mRebuildRequested = false;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/mod_texture_provider.cpp b/src/dusk/ui/mod_texture_provider.cpp
index ff7fd28b9b..a5e86d09db 100644
--- a/src/dusk/ui/mod_texture_provider.cpp
+++ b/src/dusk/ui/mod_texture_provider.cpp
@@ -1,6 +1,7 @@
 #include "mod_texture_provider.hpp"
 
 #include "dusk/mod_loader.hpp"
+#include "runtime_image.hpp"
 
 #include <fmt/format.h>
 
@@ -14,14 +15,12 @@ std::string mod_image_source(const mods::LoadedMod& mod, std::string_view bundle
 
 #ifdef AURORA_ENABLE_RMLUI
 
-#include <SDL3/SDL_iostream.h>
-#include <SDL3/SDL_surface.h>
-#include <aurora/lib/logging.hpp>
+#include <RmlUi/Core.h>
 #include <aurora/rmlui.hpp>
+#include <borealis/log.hpp>
 
 #include <cstddef>
 #include <cstdint>
-#include <cstring>
 #include <memory>
 #include <optional>
 #include <span>
@@ -34,23 +33,16 @@ std::string mod_image_source(const mods::LoadedMod& mod, std::string_view bundle
 namespace dusk::ui {
 namespace {
 
-aurora::Module Log{"dusk::ui::modTexture"};
-
+constexpr borealis::Log Log{"dusk::ui::modTexture"};
 constexpr std::string_view kScheme = "mod";
 constexpr std::string_view kSourcePrefix = "mod://";
 constexpr size_t kMaxCachedImages = 64;
+constexpr size_t kMaxCachedImageBytes = 64 * 1024 * 1024;
 constexpr size_t kMaxImageFileSize = 16 * 1024 * 1024;
-constexpr uint32_t kMaxImageDimension = 4096;
 
-struct CachedImage {
-    std::vector<uint8_t> pixels;
-    uint32_t width = 0;
-    uint32_t height = 0;
-};
-
-std::unordered_map<std::string, CachedImage>& image_cache() {
-    static auto* cache = new std::unordered_map<std::string, CachedImage>();
-    return *cache;
+std::unordered_map<std::string, DecodedImage>& image_cache() {
+    static std::unordered_map<std::string, DecodedImage> cache;
+    return cache;
 }
 
 std::string_view strip_query(std::string_view path) noexcept {
@@ -61,62 +53,7 @@ std::string_view strip_query(std::string_view path) noexcept {
     return path;
 }
 
-std::optional<CachedImage> decode_png(std::span<const uint8_t> data, std::string_view source) {
-    SDL_IOStream* stream = SDL_IOFromConstMem(data.data(), data.size());
-    if (stream == nullptr) {
-        Log.warn("Failed to open image stream for '{}': {}", source, SDL_GetError());
-        return std::nullopt;
-    }
-
-    SDL_Surface* loadedSurface = SDL_LoadPNG_IO(stream, true);
-    if (loadedSurface == nullptr) {
-        Log.warn("Failed to decode image '{}': {}", source, SDL_GetError());
-        return std::nullopt;
-    }
-
-    SDL_Surface* rgbaSurface = SDL_ConvertSurface(loadedSurface, SDL_PIXELFORMAT_RGBA32);
-    SDL_DestroySurface(loadedSurface);
-    if (rgbaSurface == nullptr) {
-        Log.warn("Failed to convert image '{}': {}", source, SDL_GetError());
-        return std::nullopt;
-    }
-
-    const auto width = static_cast<uint32_t>(rgbaSurface->w);
-    const auto height = static_cast<uint32_t>(rgbaSurface->h);
-    if (width == 0 || height == 0 || width > kMaxImageDimension || height > kMaxImageDimension) {
-        Log.warn("Image '{}' has unsupported dimensions {}x{}", source, width, height);
-        SDL_DestroySurface(rgbaSurface);
-        return std::nullopt;
-    }
-
-    const size_t rowSize = static_cast<size_t>(width) * 4;
-    CachedImage image{
-        .pixels = std::vector<uint8_t>(rowSize * height),
-        .width = width,
-        .height = height,
-    };
-    for (uint32_t row = 0; row < height; ++row) {
-        const auto* src = static_cast<const uint8_t*>(rgbaSurface->pixels) +
-                          static_cast<size_t>(row) * static_cast<size_t>(rgbaSurface->pitch);
-        auto* dst = image.pixels.data() + static_cast<size_t>(row) * rowSize;
-        std::memcpy(dst, src, rowSize);
-
-        // Convert to premultiplied alpha for correct compositing.
-        for (size_t col = 0; col < rowSize; col += 4) {
-            const uint8_t alpha = dst[col + 3];
-            for (size_t channel = 0; channel < 3; ++channel) {
-                dst[col + channel] = static_cast<uint8_t>(
-                    (static_cast<uint32_t>(dst[col + channel]) * static_cast<uint32_t>(alpha)) /
-                    255);
-            }
-        }
-    }
-
-    SDL_DestroySurface(rgbaSurface);
-    return image;
-}
-
-std::optional<CachedImage> load_mod_image(std::string_view idAndPath, std::string_view source) {
+std::optional<DecodedImage> load_mod_image(std::string_view idAndPath, std::string_view source) {
     const auto slash = idAndPath.find('/');
     if (slash == std::string_view::npos || slash == 0 || slash + 1 >= idAndPath.size()) {
         Log.warn("Malformed mod image source '{}'", source);
@@ -169,8 +106,20 @@ std::optional<aurora::rmlui::RuntimeTexture> mod_texture_provider(std::string_vi
         if (!image) {
             return std::nullopt;
         }
-        if (cache.size() >= kMaxCachedImages) {
-            cache.erase(cache.begin());
+        if (image->pixels.size() > kMaxCachedImageBytes) {
+            return std::nullopt;
+        }
+        size_t cachedBytes = 0;
+        for (const auto& [source, cached] : cache) {
+            cachedBytes += cached.pixels.size();
+        }
+        while (cache.size() >= kMaxCachedImages ||
+               cachedBytes > kMaxCachedImageBytes - image->pixels.size())
+        {
+            const auto victim = cache.begin();
+            cachedBytes -= victim->second.pixels.size();
+            Rml::ReleaseTexture(victim->first);
+            cache.erase(victim);
         }
         it = cache.emplace(key, std::move(*image)).first;
     }
@@ -182,6 +131,7 @@ std::optional<aurora::rmlui::RuntimeTexture> mod_texture_provider(std::string_vi
         .rgba8 =
             std::span{reinterpret_cast<const std::byte*>(image.pixels.data()), image.pixels.size()},
         .premultipliedAlpha = true,
+        .generateMipmaps = true,
     };
 }
 
@@ -193,6 +143,9 @@ void register_mod_texture_provider() noexcept {
 
 void unregister_mod_texture_provider() noexcept {
     aurora::rmlui::unregister_texture_provider(kScheme);
+    for (const auto& [source, image] : image_cache()) {
+        Rml::ReleaseTexture(source);
+    }
     image_cache().clear();
 }
 
diff --git a/src/dusk/ui/mod_window.cpp b/src/dusk/ui/mod_window.cpp
index 3547f92bc8..289576ffe9 100644
--- a/src/dusk/ui/mod_window.cpp
+++ b/src/dusk/ui/mod_window.cpp
@@ -1,6 +1,8 @@
 #include "mod_window.hpp"
 
 #include "bool_button.hpp"
+#include "color_input.hpp"
+#include "file_button.hpp"
 #include "number_button.hpp"
 #include "string_button.hpp"
 
@@ -16,6 +18,7 @@ Component* build_mod_control(Pane& pane, Pane* helpPane, ModControlSpec spec) {
     case ModControlSpec::Kind::Button:
         control = &pane.add_button(ControlledButton::Props{
                                        .text = s.label,
+                                       .isSelected = s.isSelected,
                                        .isDisabled = s.isDisabled,
                                    })
                        .on_pressed([shared] {
@@ -24,6 +27,18 @@ Component* build_mod_control(Pane& pane, Pane* helpPane, ModControlSpec spec) {
                            }
                        });
         break;
+    case ModControlSpec::Kind::Group:
+        control = &pane.add_group_button(GroupButton::Props{
+                                             .text = s.label,
+                                             .isSelected = s.isSelected,
+                                             .isDisabled = s.isDisabled,
+                                         })
+                       .on_pressed([shared] {
+                           if (shared->onPressed) {
+                               shared->onPressed();
+                           }
+                       });
+        break;
     case ModControlSpec::Kind::Toggle:
         control = &pane.add_child<BoolButton>(BoolButton::Props{
             .key = s.label,
@@ -55,6 +70,29 @@ Component* build_mod_control(Pane& pane, Pane* helpPane, ModControlSpec spec) {
             .isDisabled = s.isDisabled,
             .isModified = s.isModified,
             .maxLength = s.maxLength,
+            .setOnChange = s.stringSetOnChange,
+        });
+        break;
+    case ModControlSpec::Kind::Color:
+        control = &pane.add_child<ColorInput>(ColorInput::Props{
+            .key = s.label,
+            .getValue = s.getString,
+            .setValue = s.setString,
+            .isDisabled = s.isDisabled,
+            .isModified = s.isModified,
+            .presets = s.colorPresets,
+            .alpha = s.colorAlpha,
+        });
+        break;
+    case ModControlSpec::Kind::FilePicker:
+        control = &pane.add_child<FileButton>(FileButton::Props{
+            .key = s.label,
+            .getValue = s.getString,
+            .setValue = s.setString,
+            .isDisabled = s.isDisabled,
+            .isModified = s.isModified,
+            .filters = s.fileFilters,
+            .directoryMode = s.directoryMode,
         });
         break;
     case ModControlSpec::Kind::Select:
diff --git a/src/dusk/ui/mod_window.hpp b/src/dusk/ui/mod_window.hpp
index 92a5fa81ac..552f859324 100644
--- a/src/dusk/ui/mod_window.hpp
+++ b/src/dusk/ui/mod_window.hpp
@@ -3,6 +3,8 @@
 #include "pane.hpp"
 #include "window.hpp"
 
+#include <borealis/file_select.hpp>
+
 #include <climits>
 
 namespace dusk::ui {
@@ -10,10 +12,13 @@ namespace dusk::ui {
 struct ModControlSpec {
     enum class Kind : u8 {
         Button,
+        Group,
         Toggle,
         Number,
         String,
         Select,
+        Color,
+        FilePicker,
     };
 
     Kind kind = Kind::Button;
@@ -27,6 +32,7 @@ struct ModControlSpec {
     std::function<void(int)> setInt;
     std::function<Rml::String()> getString;
     std::function<void(Rml::String)> setString;
+    std::function<bool()> isSelected;
     std::function<bool()> isDisabled;
     std::function<bool()> isModified;
     int min = 0;
@@ -36,6 +42,11 @@ struct ModControlSpec {
     Rml::String suffix;
     std::vector<Rml::String> options;
     int maxLength = -1;
+    bool stringSetOnChange = false;
+    std::vector<Rml::String> colorPresets;
+    bool colorAlpha = false;
+    std::vector<borealis::file_select::Filter> fileFilters;
+    bool directoryMode = false;
 };
 
 Component* build_mod_control(Pane& pane, Pane* helpPane, ModControlSpec spec);
@@ -59,7 +70,6 @@ public:
     ~ModWindow() override;
 
     void update() override;
-    void force_close() { Document::hide(true); }
 
 private:
     Desc mDesc;
diff --git a/src/dusk/ui/modal.cpp b/src/dusk/ui/modal.cpp
index 8d9956ca13..93e873d137 100644
--- a/src/dusk/ui/modal.cpp
+++ b/src/dusk/ui/modal.cpp
@@ -1,30 +1,38 @@
 #include "modal.hpp"
 
+#include <algorithm>
+#include <utility>
+
 namespace dusk::ui {
 
-Modal::Modal(Props props) : WindowSmall("modal", "modal-dialog"), mProps(std::move(props)) {
+Modal::Modal(Props props) : WindowSmall("modal"), mProps(std::move(props)) {
     if (!mProps.variant.empty()) {
         mRoot->SetClass(mProps.variant, true);
     }
 
-    auto* header = append(mDialog, "div");
-    header->SetClass("modal-header", true);
+    auto* header = append(mDialog, "modal-header");
 
-    auto* title = append(header, "div");
-    title->SetClass("modal-title", true);
-    title->SetInnerRML(mProps.title);
+    auto* title = append(header, "modal-title");
+    append_text(title, mProps.title);
 
     if (!mProps.icon.empty()) {
         auto* icon = append(header, "icon");
         icon->SetClass(mProps.icon, true);
     }
 
-    auto* body = append(mDialog, "div");
-    body->SetClass("modal-body", true);
-    body->SetInnerRML(mProps.bodyRml);
+    auto* body = append(mDialog, "modal-body");
+    if (mProps.bodyText) {
+        append_text(body, *mProps.bodyText);
+    } else {
+        body->SetInnerRML(mProps.bodyRml);
+    }
 
-    auto* actions = append(mDialog, "div");
-    actions->SetClass("modal-actions", true);
+    mContentRoot = append(mDialog, "modal-content");
+
+    auto* actions = append(mDialog, "modal-actions");
+    if (props.isVertical) {
+        actions->SetClass("vertical", true);
+    }
 
     for (auto& action : mProps.actions) {
         add_action(std::move(action));
@@ -33,12 +41,43 @@ Modal::Modal(Props props) : WindowSmall("modal", "modal-dialog"), mProps(std::mo
     mDoAud_seStartMenu(kSoundWindowOpen);
 }
 
+void Modal::update() {
+    if (mContentPane != nullptr) {
+        mContentPane->update();
+    }
+    for (const auto& button : mButtons) {
+        button->update();
+    }
+    if (mPendingAction) {
+        auto action = std::exchange(mPendingAction, {});
+        action(*this);
+    }
+    WindowSmall::update();
+}
+
+Pane& Modal::content_pane() {
+    if (mContentPane == nullptr) {
+        mContentRoot->SetClass("active", true);
+        mContentPane = std::make_unique<Pane>(mContentRoot, Pane::Type::Uncontrolled);
+    }
+    return *mContentPane;
+}
+
 void Modal::add_action(ModalAction action) {
-    auto* actions = mDialog->QuerySelector(".modal-actions");
-    auto btn = std::make_unique<Button>(actions, action.label);
+    auto* actions = mDialog->QuerySelector("modal-actions");
+    auto btn =
+        std::make_unique<ControlledButton>(actions, ControlledButton::Props{
+                                                        .text = std::move(action.label),
+                                                        .isDisabled = std::move(action.isDisabled),
+                                                    });
     btn->root()->SetClass("modal-btn", true);
     btn->on_pressed([this, callback = std::move(action.onPressed)] {
-        if (callback) {
+        if (!callback) {
+            return;
+        }
+        if (mContentPane != nullptr) {
+            mPendingAction = callback;
+        } else {
             callback(*this);
         }
     });
@@ -46,7 +85,11 @@ void Modal::add_action(ModalAction action) {
 }
 
 void Modal::set_body(const Rml::String& bodyRml) {
-    mDialog->QuerySelector(".modal-body")->SetInnerRML(bodyRml);
+    mDialog->QuerySelector("modal-body")->SetInnerRML(bodyRml);
+}
+
+void Modal::set_body_text(const Rml::String& bodyText) {
+    set_text_content(mDialog->QuerySelector("modal-body"), bodyText);
 }
 
 void Modal::set_icon(const Rml::String& icon) {
@@ -59,14 +102,19 @@ void Modal::set_icon(const Rml::String& icon) {
     }
     if (iconElem == nullptr) {
         // The constructor only creates the icon element when Props.icon is set.
-        iconElem = append(mDialog->QuerySelector(".modal-header"), "icon");
+        iconElem = append(mDialog->QuerySelector("modal-header"), "icon");
     }
     iconElem->SetClassNames(icon);
 }
 
 bool Modal::focus() {
-    if (!mButtons.empty()) {
-        return mButtons.front()->focus();
+    if (mContentPane != nullptr && mContentPane->focus()) {
+        return true;
+    }
+    for (const auto& button : mButtons) {
+        if (button->focus()) {
+            return true;
+        }
     }
     return false;
 }
@@ -86,22 +134,44 @@ bool Modal::handle_nav_command(Rml::Event& event, NavCommand cmd) {
         return true;
     }
 
+    auto* target = event.GetTargetElement();
+    if (mContentPane != nullptr && mContentPane->contains(target) && cmd == NavCommand::Down) {
+        for (const auto& button : mButtons) {
+            if (button->focus()) {
+                mDoAud_seStartMenu(kSoundItemFocus);
+                return true;
+            }
+        }
+    }
+    if (mContentPane != nullptr && cmd == NavCommand::Up &&
+        std::ranges::any_of(
+            mButtons, [target](const auto& button) { return button->contains(target); }) &&
+        mContentPane->focus_last())
+    {
+        mDoAud_seStartMenu(kSoundItemFocus);
+        return true;
+    }
+
     int direction = 0;
-    if (cmd == NavCommand::Left) {
+    NavCommand prevCommand = mProps.isVertical ? NavCommand::Up : NavCommand::Left;
+    NavCommand nextCommand = mProps.isVertical ? NavCommand::Down : NavCommand::Right;
+    if (cmd == prevCommand) {
         direction = -1;
-    } else if (cmd == NavCommand::Right) {
+    } else if (cmd == nextCommand) {
         direction = 1;
     } else {
         return false;
     }
 
-    auto* target = event.GetTargetElement();
     for (int i = 0; i < static_cast<int>(mButtons.size()); ++i) {
         if (mButtons[i]->contains(target)) {
-            const int next = i + direction;
-            if (next >= 0 && next < static_cast<int>(mButtons.size()) && mButtons[next]->focus()) {
-                mDoAud_seStartMenu(kSoundItemFocus);
-                return true;
+            for (int next = i + direction; next >= 0 && next < static_cast<int>(mButtons.size());
+                next += direction)
+            {
+                if (mButtons[next]->focus()) {
+                    mDoAud_seStartMenu(kSoundItemFocus);
+                    return true;
+                }
             }
             return false;
         }
diff --git a/src/dusk/ui/modal.hpp b/src/dusk/ui/modal.hpp
index 400f55bd64..d7fd354ebd 100644
--- a/src/dusk/ui/modal.hpp
+++ b/src/dusk/ui/modal.hpp
@@ -1,43 +1,55 @@
 #pragma once
 
 #include "button.hpp"
+#include "pane.hpp"
 #include "window.hpp"
 
+#include <optional>
+
 namespace dusk::ui {
 class Modal;
 
 struct ModalAction {
     Rml::String label;
     std::function<void(Modal&)> onPressed;
+    std::function<bool()> isDisabled;
 };
 
 class Modal : public WindowSmall {
 public:
     struct Props {
         Rml::String title;
+        std::optional<Rml::String> bodyText;
         Rml::String bodyRml;
         std::vector<ModalAction> actions;
         std::function<void(Modal&)> onDismiss;
         Rml::String variant;
         Rml::String icon = "";
+        bool isVertical = false;
     };
 
     explicit Modal(Props props);
 
+    void update() override;
     bool focus() override;
 
-    void add_action(ModalAction action);
+    Pane& content_pane();
     void set_body(const Rml::String& bodyRml);
+    void set_body_text(const Rml::String& bodyText);
     void set_icon(const Rml::String& icon);
 
 protected:
     bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
 
 private:
+    void add_action(ModalAction action);
     void dismiss();
 
     Props mProps;
-    std::vector<std::unique_ptr<Button> > mButtons;
+    Rml::Element* mContentRoot = nullptr;
+    std::unique_ptr<Pane> mContentPane;
+    std::function<void(Modal&)> mPendingAction;
+    std::vector<std::unique_ptr<Button>> mButtons;
 };
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/mods_window.cpp b/src/dusk/ui/mods_window.cpp
index 46a7d3bc52..d10fb12b5d 100644
--- a/src/dusk/ui/mods_window.cpp
+++ b/src/dusk/ui/mods_window.cpp
@@ -1,18 +1,37 @@
 #include "mods_window.hpp"
 
-#include "dusk/mod_loader.hpp"
-#include "dusk/mods/svc/ui.hpp"
-#include "fmt/format.h"
+#include "format.hpp"
+#include "icon_button.hpp"
 #include "logs_window.hpp"
+#include "mod_browser.hpp"
 #include "mod_texture_provider.hpp"
+#include "modal.hpp"
+#include "mods/svc/http.h"
 #include "pane.hpp"
+#include "queue_window.hpp"
+
+#include <borealis/http.hpp>
+
+#include "dusk/data.hpp"
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/queue.hpp"
+#include "dusk/mods/svc/net.hpp"
+#include "dusk/mods/svc/ui.hpp"
 
-#include "Z2AudioLib/Z2SeMgr.h"
 #include "m_Do/m_Do_audio.h"
 
+#include <fmt/format.h>
+#include <fmt/ranges.h>
+
+#include <algorithm>
+#include <cstddef>
+
 #include <memory>
+#include <optional>
+#include <ranges>
 #include <string>
 #include <string_view>
+#include <vector>
 
 namespace dusk::ui {
 namespace {
@@ -22,10 +41,6 @@ struct ModStatus {
     const char* text = "";
 };
 
-bool mod_enabled(const mods::LoadedMod& mod) {
-    return mod.cvarIsEnabled != nullptr && mod.cvarIsEnabled->getValue();
-}
-
 ModStatus mod_status(const mods::LoadedMod& mod) {
     if (mod.loadFailed) {
         return {"failed", "Failed"};
@@ -39,41 +54,83 @@ ModStatus mod_status(const mods::LoadedMod& mod) {
     return {"", "Disabled"};
 }
 
-// Truncates to at most maxBytes without splitting a UTF-8 sequence.
-std::string snippet(std::string_view text, size_t maxBytes) {
-    if (text.size() <= maxBytes) {
-        return std::string{text};
+bool mod_uses_network(const mods::LoadedMod& mod) {
+    return std::ranges::any_of(
+        mod.manifestInfo.imports, [](const mods::ModManifestInfo::Import& serviceImport) {
+            return mods::svc::is_network_service(serviceImport.id);
+        });
+}
+
+enum class ModAction {
+    Retry,
+    Reload,
+    Enable,
+    Disable,
+    Logs,
+    OpenFolder,
+    Uninstall,
+};
+
+struct ModActionInfo {
+    ModAction action;
+    const char* text;
+    const char* icon;
+};
+
+std::vector<ModActionInfo> available_mod_actions(const mods::LoadedMod& mod) {
+    std::vector<ModActionInfo> actions;
+    if (mod.activation_failed()) {
+        actions.push_back({ModAction::Retry, "Retry", "replay"});
+        actions.push_back({ModAction::Disable, "Disable", "pause"});
+    } else if (mod.is_enabled()) {
+        if (!mod.nativeInPlace) {
+            actions.push_back({ModAction::Reload, "Reload", "refresh"});
+        }
+        actions.push_back({ModAction::Disable, "Disable", "pause"});
+    } else {
+        actions.push_back({ModAction::Enable, "Enable", "play_arrow"});
     }
-    size_t end = maxBytes;
-    while (end > 0 && (static_cast<unsigned char>(text[end]) & 0xC0) == 0x80) {
-        --end;
+    actions.push_back({ModAction::Logs, "Logs", "notes"});
+    if (data::manager().capabilities().canOpenFolder) {
+        actions.push_back({ModAction::OpenFolder, "Open folder", "folder_open"});
     }
-    return std::string{text.substr(0, end)} + "...";
+    if (mods::ModLoader::instance().can_uninstall(mod)) {
+        actions.push_back({
+            ModAction::Uninstall,
+            mod.hasBundledCopy ? "Remove update" : "Uninstall",
+            "delete",
+        });
+    }
+    return actions;
 }
 
 class ModListEntry : public FluentComponent<ModListEntry> {
 public:
     ModListEntry(Rml::Element* parent, const mods::LoadedMod& mod)
         : FluentComponent{append(parent, "mod-entry")} {
-        Rml::String iconRml;
+        mRoot->SetAttribute("mod-id", mod.metadata.id);
+        auto* icon = append(mRoot, "mod-icon");
         if (!mod.metadata.iconPath.empty()) {
-            iconRml = fmt::format(R"(<img class="mod-icon" src="{}"/>)",
-                mod_image_source(mod, mod.metadata.iconPath));
-        } else {
-            iconRml = R"(<icon class="mod-icon placeholder"/>)";
+            auto* image = append(icon, "img");
+            image->SetAttribute("src", mod_image_source(mod, mod.metadata.iconPath));
         }
+
         const auto status = mod_status(mod);
-        mRoot->SetInnerRML(fmt::format(
-            R"({})"
-            R"(<div class="mod-entry-info">)"
-            R"(<div class="mod-entry-name"><span class="mod-entry-name-text">{}</span>)"
-            R"(<span class="mod-entry-version">v{}</span></div>)"
-            R"(<div class="mod-entry-sub">{} - <span class="mod-entry-status {}">{}</span></div>)"
-            R"(<div class="mod-entry-desc">{}</div>)"
-            R"(</div>)",
-            iconRml, escape(mod.metadata.name), escape(mod.metadata.version),
-            escape(mod.metadata.author), status.badgeClass, status.text,
-            escape(snippet(mod.metadata.description, 90))));
+        auto* info = append(mRoot, "mod-info");
+        auto* heading = append(info, "header");
+        append_text(append(heading, "b"), mod.metadata.name);
+        append_text(append(heading, "small"), fmt::format("v{}", mod.metadata.version));
+        auto* sub = append(info, "small");
+        append_text(sub, fmt::format("{} - ", mod.metadata.author));
+        auto* statusElement = append(sub, "mod-status");
+        if (status.badgeClass[0] != '\0') {
+            statusElement->SetClass(status.badgeClass, true);
+        }
+        append_text(statusElement, status.text);
+        if (mod_uses_network(mod)) {
+            append_text(append(sub, "mod-network"), "Network");
+        }
+        append_text(append(info, "p"), snippet(mod.metadata.description, 90));
         mRoot->SetClass("inactive", !mod.active);
         mRoot->SetClass("failed", mod.loadFailed);
 
@@ -87,36 +144,98 @@ public:
     }
 };
 
+class BrowseModsEntry final : public FluentComponent<BrowseModsEntry> {
+public:
+    BrowseModsEntry(Rml::Element* parent, std::function<void()> onOpen)
+        : FluentComponent{append(parent, "mod-entry")} {
+        mRoot->SetClass("browser", true);
+        append(mRoot, "mod-icon");
+
+        auto* info = append(mRoot, "mod-info");
+        auto* heading = append(info, "header");
+        append_text(append(heading, "b"), "Browse online mods");
+        append_text(append(info, "p"), "Discover and install mods from the community.");
+
+        on_nav_command([callback = std::move(onOpen)](Rml::Event&, NavCommand cmd) {
+            if (cmd != NavCommand::Confirm) {
+                return false;
+            }
+            callback();
+            return true;
+        });
+    }
+};
+
+class InstallQueueEntry final : public FluentComponent<InstallQueueEntry> {
+public:
+    InstallQueueEntry(Rml::Element* parent, std::function<void()> onOpen)
+        : FluentComponent{append(parent, "mod-entry")} {
+        mRoot->SetClass("installs", true);
+        append(mRoot, "mod-icon");
+
+        auto* info = append(mRoot, "mod-info");
+        auto* heading = append(info, "header");
+        append_text(append(heading, "b"), "Installs");
+        mSummary = append(info, "small");
+        mProgress = append(info, "progress");
+
+        on_nav_command([callback = std::move(onOpen)](Rml::Event&, NavCommand cmd) {
+            if (cmd != NavCommand::Confirm) {
+                return false;
+            }
+            callback();
+            return true;
+        });
+        update();
+    }
+
+    void update() override {
+        const auto current = mods::queue::first_active();
+        const auto activeCount = mods::queue::active_count();
+        const auto totalCount = mods::queue::item_count();
+
+        if (!current) {
+            set_text_content(mSummary, fmt::format("0 active · {} total", totalCount));
+            mProgress->SetProperty("display", "none");
+        } else {
+            const float progress = current->total == 0 ?
+                                       0.0f :
+                                       std::clamp(static_cast<float>(current->completed) /
+                                                      static_cast<float>(current->total),
+                                           0.0f, 1.0f);
+            set_text_content(
+                mSummary, fmt::format("{} in queue · {:.0f}%", activeCount, progress * 100.0f));
+            mProgress->SetAttribute("value", progress);
+            mProgress->SetProperty("display", "block");
+        }
+        Component::update();
+    }
+
+private:
+    Rml::Element* mSummary = nullptr;
+    Rml::Element* mProgress = nullptr;
+};
+
 class ModDetailHeader : public FluentComponent<ModDetailHeader> {
 public:
     ModDetailHeader(
-        Rml::Element* parent, const mods::LoadedMod& mod, std::function<void()> onShowLogs)
+        Rml::Element* parent, const mods::LoadedMod& mod, std::vector<ContextMenu::Item> items)
         : FluentComponent{append(parent, "mod-header")} {
+        mRoot->SetAttribute("mod-id", mod.metadata.id);
         const bool hasBanner = !mod.metadata.bannerPath.empty();
         mRoot->SetClass(hasBanner ? "has-banner" : "no-banner", true);
+        mRoot->SetClass("inactive", !mod.active);
         if (hasBanner) {
-            mRoot->SetProperty("decorator", fmt::format(R"(image("{}" cover center top))",
+            auto* image = append(mRoot, "mod-header-image");
+            image->SetProperty("decorator", fmt::format(R"(image("{}" cover center center))",
                                                 mod_image_source(mod, mod.metadata.bannerPath)));
         }
 
-        auto* actions = append(mRoot, "div");
-        actions->SetClass("mod-actions", true);
-        const std::string modId = mod.metadata.id;
-        if (mod_enabled(mod)) {
-            if (!mod.inPlace) {
-                make_button(actions, "Reload").on_pressed([modId] {
-                    mods::ModLoader::instance().request_reload(modId);
-                });
-            }
-            make_button(actions, "Disable").on_pressed([modId] {
-                mods::ModLoader::instance().request_disable(modId);
-            });
-        } else {
-            make_button(actions, "Enable").on_pressed([modId] {
-                mods::ModLoader::instance().request_enable(modId);
-            });
+        auto* actions = append(mRoot, "mod-actions");
+        for (auto& item : items) {
+            auto& button = make_button(actions, item);
+            button.on_pressed(std::move(item.onPressed));
         }
-        make_button(actions, "Logs").on_pressed(std::move(onShowLogs));
 
         listen(Rml::EventId::Keydown, [this](Rml::Event& event) {
             const auto cmd = map_nav_event(event);
@@ -151,8 +270,9 @@ public:
     }
 
 private:
-    Button& make_button(Rml::Element* parent, Rml::String text) {
-        auto button = std::make_unique<Button>(parent, std::move(text));
+    Button& make_button(Rml::Element* parent, const ContextMenu::Item& item) {
+        auto button = std::make_unique<IconButton>(
+            parent, IconButton::Props{.icon = item.icon, .label = item.text});
         Button& ref = *button;
         mChildren.emplace_back(std::move(button));
         mButtons.push_back(&ref);
@@ -164,36 +284,162 @@ private:
 
 }  // namespace
 
-ModsWindow::ModsWindow() : Window{Props{.tabBar = false, .styleSheets = {"res/rml/mods.rcss"}}} {
+ModsWindow::ModsWindow()
+    : Window{Props{.tabBar = false, .styleSheets = {"res/rml/mods.rcss"}}},
+      mContextMenu{*this, mRoot, "mod-entry, mod-header", [this](Rml::Element* target) {
+                       const auto id = target->GetAttribute<Rml::String>("mod-id", "");
+                       auto* mod = mods::ModLoader::instance().find_mod(id);
+                       return mod != nullptr ? mod_actions(*mod, true) :
+                                               std::vector<ContextMenu::Item>{};
+                   }} {
     mRoot->SetClass("mods", true);
 
-    for (auto& trackedMod : mods::ModLoader::instance().mods()) {
-        mSnapshot.push_back({
-            .mod = &trackedMod,
-            .active = trackedMod.active,
-            .loadFailed = trackedMod.loadFailed,
-            .enabled = mod_enabled(trackedMod),
-            .suspended = trackedMod.suspendedByProvider,
-            .cacheGeneration = trackedMod.cacheGeneration,
-        });
-    }
+    refresh_snapshot();
+    mQueueItemCount = mods::queue::item_count();
 
     set_content([this](Rml::Element* content) { build_content(content); });
 }
 
+void ModsWindow::hide(bool close) {
+    mContextMenu.dismiss();
+    Window::hide(close);
+}
+
+bool ModsWindow::select_mod(std::string_view id) {
+    if (mods::ModLoader::instance().find_mod(id) == nullptr) {
+        return false;
+    }
+    mContextMenu.dismiss();
+    mSelectedModId = id;
+    mSelectedMod = nullptr;
+    mBrowserSelected = false;
+    mFocusSelectedMod = true;
+    refresh_snapshot();
+    mQueueItemCount = mods::queue::item_count();
+    rebuild_content();
+    return true;
+}
+
+bool ModsWindow::focus() {
+    if (mFocusSelectedMod) {
+        mDocument->UpdateDocument();
+        for (size_t i = 0; i < mEntryMods.size(); ++i) {
+            if (mEntryMods[i]->metadata.id == mSelectedModId && mEntries[i]->focus()) {
+                mEntries[i]->set_selected(true);
+                mFocusSelectedMod = false;
+                return true;
+            }
+        }
+    }
+    return Window::focus();
+}
+
+std::vector<ContextMenu::Item> ModsWindow::mod_actions(
+    const mods::LoadedMod& mod, bool contextMenu) {
+    std::vector<ContextMenu::Item> items;
+    for (const auto& info : available_mod_actions(mod)) {
+        if (!contextMenu && info.action == ModAction::OpenFolder) {
+            continue;
+        }
+        items.push_back({
+            .text = info.text,
+            .icon = info.icon,
+            .onPressed =
+                [this, id = mod.metadata.id, action = info.action] {
+                    auto& loader = mods::ModLoader::instance();
+                    auto* current = loader.find_mod(id);
+                    if (current == nullptr) {
+                        return;
+                    }
+                    const auto actions = available_mod_actions(*current);
+                    if (std::ranges::none_of(
+                            actions, [action](const auto& info) { return info.action == action; }))
+                    {
+                        return;
+                    }
+                    switch (action) {
+                    case ModAction::Retry:
+                        loader.request_reactivate(id);
+                        break;
+                    case ModAction::Reload:
+                        loader.request_reload(id);
+                        break;
+                    case ModAction::Enable:
+                        loader.request_enable(id);
+                        break;
+                    case ModAction::Disable:
+                        loader.request_disable(id);
+                        break;
+                    case ModAction::Logs:
+                        push(std::make_unique<LogsWindow>(id));
+                        break;
+                    case ModAction::Uninstall:
+                        confirm_uninstall(*current);
+                        break;
+                    case ModAction::OpenFolder: {
+                        const auto folder = current->fromDirectory ? current->modPath :
+                                                                     current->modPath.parent_path();
+                        if (!data::manager().open_folder(folder)) {
+                            push(std::make_unique<Modal>(Modal::Props{
+                                .title = "Could not open folder",
+                                .bodyText =
+                                    "The mod folder could not be opened in the file browser.",
+                                .actions = {{"OK", [](Modal& modal) { modal.pop(); }, {}}},
+                            }));
+                        }
+                        break;
+                    }
+                    }
+                },
+            .destructive = info.action == ModAction::Uninstall,
+            .separatorBefore = info.action == ModAction::Uninstall,
+        });
+    }
+    return items;
+}
+
 void ModsWindow::build_content(Rml::Element* content) {
     mEntries.clear();
     mEntryMods.clear();
+    mBrowserEntry = nullptr;
 
     auto& listPane = add_child<Pane>(content, Pane::Type::Controlled);
     listPane.root()->SetClass("mod-list", true);
     auto& detailPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
     detailPane.root()->SetClass("mod-detail", true);
 
-    if (mods::ModLoader::instance().mods().empty()) {
+    bool hasUtilityEntries = false;
+    if (borealis::http::available()) {
+        auto& browse =
+            listPane.add_child<BrowseModsEntry>([this] { push(std::make_unique<ModBrowser>()); });
+        mBrowserEntry = &browse;
+        hasUtilityEntries = true;
+        listPane.register_control(browse, detailPane, [this](Pane& pane) {
+            mBrowserSelected = true;
+            mSelectedMod = nullptr;
+            mSelectedModId.clear();
+            mark_current_entry();
+        });
+    }
+
+    if (mQueueItemCount != 0) {
+        listPane.add_child<InstallQueueEntry>([this] { push(std::make_unique<QueueWindow>()); });
+        hasUtilityEntries = true;
+    }
+
+    const bool hasInstalledMods = !mods::ModLoader::instance().mods().empty();
+    if (hasUtilityEntries && hasInstalledMods) {
+        append(listPane.root(), "mod-list-separator");
+    }
+
+    if (!hasInstalledMods) {
         listPane.add_text("No mods installed.");
-        listPane.finalize();
-        detailPane.finalize();
+        mSelectedMod = nullptr;
+        mSelectedModId.clear();
+        if (borealis::http::available()) {
+            mBrowserSelected = true;
+        }
+        mark_current_entry();
         return;
     }
 
@@ -202,110 +448,196 @@ void ModsWindow::build_content(Rml::Element* content) {
         mEntries.push_back(&entry);
         mEntryMods.push_back(&trackedMod);
         listPane.register_control(entry, detailPane, [this, tracked = &trackedMod](Pane& pane) {
+            mBrowserSelected = false;
             mSelectedMod = tracked;
+            mSelectedModId = tracked->metadata.id;
             pane.clear();
             build_detail(pane, *tracked);
             mark_current_entry();
         });
     }
 
-    if (mSelectedMod == nullptr) {
-        mSelectedMod = mEntryMods.front();
+    if (mBrowserSelected && mBrowserEntry != nullptr) {
+        mSelectedMod = nullptr;
+        mSelectedModId.clear();
+    } else {
+        mSelectedMod = nullptr;
+        if (!mSelectedModId.empty()) {
+            const auto selected = std::ranges::find_if(
+                mEntryMods, [this](const auto* mod) { return mod->metadata.id == mSelectedModId; });
+            if (selected != mEntryMods.end()) {
+                mSelectedMod = *selected;
+            }
+        }
+        if (mSelectedMod == nullptr) {
+            mSelectedMod = mEntryMods.front();
+            mSelectedModId = mSelectedMod->metadata.id;
+        }
+        build_detail(detailPane, *mSelectedMod);
     }
-    build_detail(detailPane, *mSelectedMod);
     mark_current_entry();
-
-    listPane.finalize();
 }
 
 void ModsWindow::build_detail(Pane& pane, mods::LoadedMod& mod) {
     pane.root()->SetAttribute("mod-id", mod.metadata.id);
-    pane.add_child<ModDetailHeader>(
-        mod, [this, id = mod.metadata.id] { push(std::make_unique<LogsWindow>(id)); });
+    pane.add_child<ModDetailHeader>(mod, mod_actions(mod, false));
 
-    Rml::String statusBadge;
-    if (mod.loadFailed || mod.suspendedByProvider) {
-        const auto status = mod_status(mod);
-        statusBadge = fmt::format(
-            R"(&nbsp;<span class="status-badge {}">{}</span>)", status.badgeClass, status.text);
+    auto* title = append(pane.root(), "mod-title");
+    append_text(title, fmt::format("{} ", mod.metadata.name));
+    append_text(append(title, "small"), fmt::format("v{}", mod.metadata.version));
+    if (mod_uses_network(mod)) {
+        append_text(title, "\u00a0");
+        auto* badge = append(title, "status-badge");
+        badge->SetClass("network", true);
+        append_text(badge, "Network");
     }
-    pane.add_rml(fmt::format(R"(<div class="mod-title">{} )"
-                             R"(<span class="mod-title-version">v{}</span>{}</div>)"
-                             R"(<div class="mod-author">by {}</div>)",
-        escape(mod.metadata.name), escape(mod.metadata.version), statusBadge,
-        escape(mod.metadata.author)));
+    auto* author = append(pane.root(), "mod-author");
+    append_text(author, fmt::format("by {}\u00a0·\u00a0", mod.metadata.author));
+    const auto status = mod_status(mod);
+    auto* badge = append(author, "status-badge");
+    if (status.badgeClass[0] != '\0') {
+        badge->SetClass(status.badgeClass, true);
+    }
+    append_text(badge, status.text);
 
     if (mod.loadFailed && !mod.failureReason.empty()) {
-        pane.add_rml(fmt::format(R"(<div class="mod-info-row">)"
-                                 R"(<span class="mod-info-label failed">Reason</span>)"
-                                 R"(<span class="mod-info-value">{}</span>)"
-                                 R"(</div>)",
-            escape(mod.failureReason)));
+        auto* row = append(pane.root(), "mod-info-row");
+        auto* label = append(row, "b");
+        label->SetClass("failed", true);
+        append_text(label, "Reason");
+        append_text(append(row, "span"), mod.failureReason);
     } else if (mod.suspendedByProvider) {
-        std::string providers;
+        std::vector<std::string_view> providers;
         for (const auto& edge : mod.dependencies) {
             if (edge.required && edge.mod != nullptr && !edge.mod->active) {
-                if (!providers.empty()) {
-                    providers += ", ";
-                }
-                providers += edge.mod->metadata.name;
+                providers.push_back(edge.mod->metadata.name);
             }
         }
-        pane.add_rml(fmt::format(R"(<div class="mod-info-row">)"
-                                 R"(<span class="mod-info-label">Waiting on</span>)"
-                                 R"(<span class="mod-info-value">{}</span>)"
-                                 R"(</div>)",
-            escape(providers)));
+        auto* row = append(pane.root(), "mod-info-row");
+        append_text(append(row, "b"), "Waiting on");
+        append_text(append(row, "span"), fmt::format("{}", fmt::join(providers, ", ")));
     }
 
-    std::string activeDependents;
+    std::vector<std::string_view> activeDependents;
     for (const auto& edge : mod.dependents) {
         if (edge.mod != nullptr && edge.mod->active) {
-            if (!activeDependents.empty()) {
-                activeDependents += ", ";
-            }
-            activeDependents += edge.mod->metadata.name;
+            activeDependents.push_back(edge.mod->metadata.name);
         }
     }
     if (mod.active && !activeDependents.empty()) {
-        pane.add_rml(fmt::format(R"(<div class="mod-restart-note">{}</div>)",
-            escape(fmt::format("Disabling or reloading also restarts: {}", activeDependents))));
+        append_text(append(pane.root(), "mod-restart-note"),
+            fmt::format(
+                "Disabling or reloading also restarts: {}", fmt::join(activeDependents, ", ")));
     }
 
     if (!mod.metadata.description.empty()) {
-        pane.add_text(mod.metadata.description)->SetClass("mod-description", true);
+        auto* description = append(pane.root(), "mod-description");
+        append_text(description, mod.metadata.description);
     }
 
     if (mod.active) {
         mods::svc::ui_build_mods_panels(mod, pane);
     }
+}
 
-    pane.finalize();
+void ModsWindow::confirm_uninstall(const mods::LoadedMod& mod) {
+    const std::string action = mod.hasBundledCopy ? "Remove update" : "Uninstall";
+    std::string body = mod.hasBundledCopy ?
+                           "Installed mod will be reverted back to the bundled version. Settings "
+                           "and saved data are kept." :
+                           "Installed mod will be removed. Settings and saved data are kept.";
+    std::vector<std::string_view> dependents;
+    for (const auto& edge : mod.dependents) {
+        if (!edge.required || edge.mod == nullptr) {
+            continue;
+        }
+        dependents.push_back(edge.mod->metadata.name);
+    }
+    if (!dependents.empty()) {
+        body = fmt::format("{} Required dependents: {}.", body, fmt::join(dependents, ", "));
+    }
+
+    push(std::make_unique<Modal>(Modal::Props{
+        .title = mod.hasBundledCopy ? fmt::format("Revert {}?", mod.metadata.name) :
+                                      fmt::format("Uninstall {}?", mod.metadata.name),
+        .bodyText = std::move(body),
+        .actions =
+            {
+                ModalAction{"Cancel", [](Modal& modal) { modal.pop(); }, {}},
+                ModalAction{action,
+                    [id = mod.metadata.id](Modal& modal) {
+                        mods::ModLoader::instance().request_uninstall(id);
+                        modal.pop();
+                    },
+                    {}},
+            },
+        .variant = "danger",
+        .icon = "warning",
+    }));
+}
+
+void ModsWindow::refresh_snapshot() {
+    mSnapshot.clear();
+    auto& loader = mods::ModLoader::instance();
+    mLoaderGeneration = loader.generation();
+    for (auto& trackedMod : loader.mods()) {
+        mSnapshot.push_back({
+            .mod = &trackedMod,
+            .active = trackedMod.active,
+            .loadFailed = trackedMod.loadFailed,
+            .enabled = trackedMod.is_enabled(),
+            .suspended = trackedMod.suspendedByProvider,
+            .cacheGeneration = trackedMod.cacheGeneration,
+        });
+    }
 }
 
 void ModsWindow::mark_current_entry() {
+    if (mBrowserEntry != nullptr) {
+        mBrowserEntry->root()->SetClass("current", mBrowserSelected);
+    }
     for (size_t i = 0; i < mEntries.size(); ++i) {
         mEntries[i]->root()->SetClass("current", mEntryMods[i] == mSelectedMod);
     }
 }
 
 void ModsWindow::update() {
-    bool dirty = false;
-    for (auto& snapshot : mSnapshot) {
-        const auto& mod = *snapshot.mod;
-        if (mod.active != snapshot.active || mod.loadFailed != snapshot.loadFailed ||
-            mod_enabled(mod) != snapshot.enabled || mod.suspendedByProvider != snapshot.suspended ||
-            mod.cacheGeneration != snapshot.cacheGeneration)
-        {
-            snapshot.active = mod.active;
-            snapshot.loadFailed = mod.loadFailed;
-            snapshot.enabled = mod_enabled(mod);
-            snapshot.suspended = mod.suspendedByProvider;
-            snapshot.cacheGeneration = mod.cacheGeneration;
-            dirty = true;
+    auto& loader = mods::ModLoader::instance();
+    bool dirty = loader.generation() != mLoaderGeneration;
+    if (dirty) {
+        mSelectedMod = nullptr;
+        refresh_snapshot();
+    } else {
+        for (auto& snapshot : mSnapshot) {
+            const auto& mod = *snapshot.mod;
+            if (mod.active != snapshot.active || mod.loadFailed != snapshot.loadFailed ||
+                mod.is_enabled() != snapshot.enabled ||
+                mod.suspendedByProvider != snapshot.suspended ||
+                mod.cacheGeneration != snapshot.cacheGeneration)
+            {
+                snapshot.active = mod.active;
+                snapshot.loadFailed = mod.loadFailed;
+                snapshot.enabled = mod.is_enabled();
+                snapshot.suspended = mod.suspendedByProvider;
+                snapshot.cacheGeneration = mod.cacheGeneration;
+                dirty = true;
+            }
         }
     }
+    const auto queueItemCount = mods::queue::item_count();
+    if (queueItemCount != mQueueItemCount) {
+        mQueueItemCount = queueItemCount;
+        dirty = true;
+    }
     if (dirty) {
+        mContextMenu.dismiss();
+        const auto previousModId = mSelectedModId;
+        std::optional<Rml::Property> previousBannerFilter;
+        if (auto* image = mContentRoot->QuerySelector("mod-header-image")) {
+            previousBannerFilter = *image->GetProperty(Rml::PropertyId::Filter);
+        }
+        auto* list = mContentRoot->QuerySelector("pane.mod-list");
+        const float listScrollTop = list != nullptr ? list->GetScrollTop() : 0.0f;
         auto* focused = mDocument != nullptr ? mDocument->GetFocusLeafNode() : nullptr;
         bool hadContentFocus = false;
         for (auto* node = focused; node != nullptr; node = node->GetParentNode()) {
@@ -315,14 +647,33 @@ void ModsWindow::update() {
             }
         }
         rebuild_content();
+        mDocument->UpdateDocument();
         if (hadContentFocus) {
-            for (size_t i = 0; i < mEntryMods.size(); ++i) {
-                if (mEntryMods[i] == mSelectedMod) {
-                    mEntries[i]->focus();
-                    break;
+            if (mBrowserSelected && mBrowserEntry != nullptr) {
+                mBrowserEntry->root()->Focus(true);
+            } else {
+                for (size_t i = 0; i < mEntryMods.size(); ++i) {
+                    if (mEntryMods[i] == mSelectedMod) {
+                        mEntries[i]->root()->Focus(true);
+                        break;
+                    }
                 }
             }
         }
+        if (previousBannerFilter && previousModId == mSelectedModId) {
+            mDocument->UpdateDocument();
+            if (auto* image = mContentRoot->QuerySelector("mod-header-image")) {
+                const auto target = *image->GetProperty(Rml::PropertyId::Filter);
+                if (*previousBannerFilter != target) {
+                    image->SetProperty(Rml::PropertyId::Filter, *previousBannerFilter);
+                    image->Animate(Rml::PropertyId::Filter, target, 0.2f,
+                        Rml::Tween{Rml::Tween::Cubic, Rml::Tween::InOut}, 1, false);
+                }
+            }
+        }
+        if (auto* refreshedList = mContentRoot->QuerySelector("pane.mod-list")) {
+            refreshedList->SetScrollTop(listScrollTop);
+        }
     }
 
     if (mSelectedMod != nullptr && mSelectedMod->active) {
diff --git a/src/dusk/ui/mods_window.hpp b/src/dusk/ui/mods_window.hpp
index 9d1b8dbf6d..2445dce9e2 100644
--- a/src/dusk/ui/mods_window.hpp
+++ b/src/dusk/ui/mods_window.hpp
@@ -1,7 +1,11 @@
 #pragma once
 
 #include "window.hpp"
+#include "context_menu.hpp"
 
+#include <cstddef>
+#include <string>
+#include <string_view>
 #include <vector>
 
 #include "dusk/mod_loader.hpp"
@@ -13,7 +17,10 @@ class Pane;
 class ModsWindow : public Window {
 public:
     ModsWindow();
+    void hide(bool close) override;
     void update() override;
+    bool focus() override;
+    bool select_mod(std::string_view id);
 
 private:
     struct ModSnapshot {
@@ -27,12 +34,22 @@ private:
 
     void build_content(Rml::Element* content);
     void build_detail(Pane& pane, mods::LoadedMod& mod);
+    void confirm_uninstall(const mods::LoadedMod& mod);
+    std::vector<ContextMenu::Item> mod_actions(const mods::LoadedMod& mod, bool contextMenu);
+    void refresh_snapshot();
     void mark_current_entry();
 
     std::vector<ModSnapshot> mSnapshot;
     std::vector<Component*> mEntries;
     std::vector<mods::LoadedMod*> mEntryMods;
+    Component* mBrowserEntry = nullptr;
     mods::LoadedMod* mSelectedMod = nullptr;
+    std::string mSelectedModId;
+    uint64_t mLoaderGeneration = 0;
+    size_t mQueueItemCount = 0;
+    bool mBrowserSelected = false;
+    bool mFocusSelectedMod = false;
+    ContextMenu::Binding mContextMenu;
 };
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/nav_group.cpp b/src/dusk/ui/nav_group.cpp
new file mode 100644
index 0000000000..41e8b230e2
--- /dev/null
+++ b/src/dusk/ui/nav_group.cpp
@@ -0,0 +1,180 @@
+#include "nav_group.hpp"
+
+#include "Z2AudioLib/Z2SeMgr.h"
+#include "m_Do/m_Do_audio.h"
+
+#include <algorithm>
+
+namespace dusk::ui {
+
+NavGroup::NavGroup(Rml::Element* root, Props props) : Component{root}, mProps{props} {
+    mProps.columns = std::max(mProps.columns, 1);
+
+    listen(
+        mRoot, Rml::EventId::Focus,
+        [this](Rml::Event& event) {
+            const int index = item_index(event.GetTargetElement());
+            if (index >= 0) {
+                mRememberedIndex = index;
+            }
+        },
+        true);
+    listen(mRoot, Rml::EventId::Keydown, [this](Rml::Event& event) {
+        const auto direction = map_nav_event(event);
+        const auto result = navigate(event.GetTargetElement(), direction);
+        if (result == MoveResult::Moved) {
+            mDoAud_seStartMenu(kSoundItemFocus);
+        }
+        if (result != MoveResult::Unhandled) {
+            event.StopPropagation();
+        }
+    });
+}
+
+bool NavGroup::focus() {
+    if (mRememberedIndex >= 0 && focus_index(mRememberedIndex, NavCommand::None)) {
+        return true;
+    }
+    return focus_linear(0, 1, NavCommand::None);
+}
+
+bool NavGroup::focus_from(NavCommand direction) {
+    if (mRememberedIndex >= 0 && focus_index(mRememberedIndex, direction)) {
+        return true;
+    }
+    const bool reverse = direction == NavCommand::Up || direction == NavCommand::Left;
+    return focus_linear(
+        reverse ? static_cast<int>(mItems.size()) - 1 : 0, reverse ? -1 : 1, direction);
+}
+
+NavGroup::MoveResult NavGroup::navigate(Rml::Element* target, NavCommand direction) {
+    const bool horizontal = direction == NavCommand::Left || direction == NavCommand::Right;
+    const bool vertical = direction == NavCommand::Up || direction == NavCommand::Down;
+    if (!horizontal && !vertical) {
+        return MoveResult::Unhandled;
+    }
+
+    const int current = item_index(target);
+    if (current < 0) {
+        return MoveResult::Unhandled;
+    }
+    mRememberedIndex = current;
+
+    if (mProps.layout == Layout::Grid) {
+        return navigate_grid(current, direction);
+    }
+    if ((mProps.layout == Layout::Horizontal && horizontal) ||
+        (mProps.layout == Layout::Vertical && vertical))
+    {
+        return navigate_linear(current, direction);
+    }
+    return handle_boundary(direction);
+}
+
+NavGroup::MoveResult NavGroup::navigate_linear(int current, NavCommand direction) {
+    const int step = direction == NavCommand::Left || direction == NavCommand::Up ? -1 : 1;
+    if (focus_linear(current + step, step, direction)) {
+        return MoveResult::Moved;
+    }
+    return handle_boundary(direction);
+}
+
+NavGroup::MoveResult NavGroup::navigate_grid(int current, NavCommand direction) {
+    const int columns = mProps.columns;
+    const int row = current / columns;
+    const int column = current % columns;
+    const int rowStart = row * columns;
+    const int rowEnd = std::min(rowStart + columns, static_cast<int>(mItems.size()));
+
+    if (direction == NavCommand::Left || direction == NavCommand::Right) {
+        const int step = direction == NavCommand::Left ? -1 : 1;
+        const int edge = direction == NavCommand::Left ? rowStart - 1 : rowEnd;
+        for (int index = current + step; index != edge; index += step) {
+            if (focus_index(index, direction)) {
+                return MoveResult::Moved;
+            }
+        }
+        return handle_boundary(direction);
+    }
+
+    const int rowCount = (static_cast<int>(mItems.size()) + columns - 1) / columns;
+    const int step = direction == NavCommand::Up ? -1 : 1;
+    for (int nextRow = row + step; nextRow >= 0 && nextRow < rowCount; nextRow += step) {
+        if (focus_grid_row(nextRow, column, direction)) {
+            return MoveResult::Moved;
+        }
+    }
+    return handle_boundary(direction);
+}
+
+NavGroup::MoveResult NavGroup::handle_boundary(NavCommand direction) {
+    switch (boundary_for(direction)) {
+    case Boundary::Bubble:
+        return MoveResult::Unhandled;
+    case Boundary::Stop:
+        return MoveResult::Consumed;
+    }
+    return MoveResult::Unhandled;
+}
+
+bool NavGroup::focus_index(int index, NavCommand direction) {
+    if (index < 0 || index >= static_cast<int>(mItems.size())) {
+        return false;
+    }
+    if (!mItems[index]->focus_from(direction)) {
+        return false;
+    }
+    mRememberedIndex = index;
+    return true;
+}
+
+bool NavGroup::focus_linear(int start, int step, NavCommand direction) {
+    for (int index = start; index >= 0 && index < static_cast<int>(mItems.size()); index += step) {
+        if (focus_index(index, direction)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool NavGroup::focus_grid_row(int row, int preferredColumn, NavCommand direction) {
+    const int rowStart = row * mProps.columns;
+    const int rowEnd = std::min(rowStart + mProps.columns, static_cast<int>(mItems.size()));
+    if (rowStart >= rowEnd) {
+        return false;
+    }
+
+    const int column = std::min(preferredColumn, rowEnd - rowStart - 1);
+    if (focus_index(rowStart + column, direction)) {
+        return true;
+    }
+    for (int distance = 1; distance < mProps.columns; ++distance) {
+        if (column - distance >= 0 && focus_index(rowStart + column - distance, direction)) {
+            return true;
+        }
+        if (rowStart + column + distance < rowEnd &&
+            focus_index(rowStart + column + distance, direction))
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+int NavGroup::item_index(Rml::Element* target) const {
+    for (int index = 0; index < static_cast<int>(mItems.size()); ++index) {
+        if (mItems[index]->contains(target)) {
+            return index;
+        }
+    }
+    return -1;
+}
+
+NavGroup::Boundary NavGroup::boundary_for(NavCommand direction) const {
+    if (direction == NavCommand::Left || direction == NavCommand::Right) {
+        return mProps.horizontalBoundary;
+    }
+    return mProps.verticalBoundary;
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/nav_group.hpp b/src/dusk/ui/nav_group.hpp
new file mode 100644
index 0000000000..c2333a0217
--- /dev/null
+++ b/src/dusk/ui/nav_group.hpp
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "component.hpp"
+
+namespace dusk::ui {
+
+class NavGroup : public Component {
+public:
+    enum class Layout {
+        Horizontal,
+        Vertical,
+        Grid,
+    };
+    enum class Boundary {
+        Bubble,
+        Stop,
+    };
+    struct Props {
+        Layout layout = Layout::Vertical;
+        int columns = 1;
+        Boundary horizontalBoundary = Boundary::Bubble;
+        Boundary verticalBoundary = Boundary::Bubble;
+    };
+
+    NavGroup(Rml::Element* root, Props props);
+
+    bool focus() override;
+    bool focus_from(NavCommand direction) override;
+
+    template <typename T, typename... Args>
+        requires std::is_base_of_v<Component, T>
+    T& add_item(Args&&... args) {
+        auto child = std::make_unique<T>(mRoot, std::forward<Args>(args)...);
+        return add_item(std::move(child));
+    }
+
+    template <typename T, typename... Args>
+        requires std::is_base_of_v<Component, T>
+    T& add_existing_item(Rml::Element* root, Args&&... args) {
+        auto child = std::make_unique<T>(root, std::forward<Args>(args)...);
+        return add_item(std::move(child));
+    }
+
+private:
+    template <typename T>
+    T& add_item(std::unique_ptr<T> child) {
+        T& ref = *child;
+        mItems.push_back(&ref);
+        mChildren.emplace_back(std::move(child));
+        return ref;
+    }
+    enum class MoveResult {
+        Unhandled,
+        Consumed,
+        Moved,
+    };
+
+    MoveResult navigate(Rml::Element* target, NavCommand direction);
+    MoveResult navigate_linear(int current, NavCommand direction);
+    MoveResult navigate_grid(int current, NavCommand direction);
+    MoveResult handle_boundary(NavCommand direction);
+    bool focus_index(int index, NavCommand direction);
+    bool focus_linear(int start, int step, NavCommand direction);
+    bool focus_grid_row(int row, int preferredColumn, NavCommand direction);
+    int item_index(Rml::Element* target) const;
+    Boundary boundary_for(NavCommand direction) const;
+
+    Props mProps;
+    std::vector<Component*> mItems;
+    int mRememberedIndex = -1;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/overlay.cpp b/src/dusk/ui/overlay.cpp
index c0e073dbc2..20789014e4 100644
--- a/src/dusk/ui/overlay.cpp
+++ b/src/dusk/ui/overlay.cpp
@@ -1,22 +1,25 @@
 #include "overlay.hpp"
 
-#include "aurora/lib/logging.hpp"
 #include "controller_config.hpp"
+#include "window.hpp"
+
 #include "dusk/achievements.h"
 #include "dusk/action_bindings.h"
 #include "dusk/livesplit.h"
 #include "dusk/settings.h"
 #include "dusk/speedrun.h"
-#include "fmt/format.h"
-#include "magic_enum.hpp"
-#include "window.hpp"
 
+#include "m_Do/m_Do_main.h"
+
+#include <aurora/gfx.h>
+#include <borealis/log.hpp>
+#include <dolphin/pad.h>
+#include <fmt/format.h>
+#include <magic_enum.hpp>
 #include <SDL3/SDL_gamepad.h>
 #include <SDL3/SDL_timer.h>
+
 #include <algorithm>
-#include <aurora/gfx.h>
-#include <dolphin/pad.h>
-#include <m_Do/m_Do_main.h>
 
 #if defined(__APPLE__)
 #include <TargetConditionals.h>
@@ -24,11 +27,12 @@
 
 namespace dusk::ui {
 namespace {
-aurora::Module Log{"dusk::ui::overlay"};
+constexpr borealis::Log Log{"dusk::ui::overlay"};
 
 const Rml::String kDocumentSource = R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/overlay.rcss" />
 </head>
 <body>
@@ -71,6 +75,9 @@ Rml::Element* create_toast(Rml::Element* parent, const Toast& toast) {
     }
 
     auto* elem = append(parent, "toast");
+    if (!toast.modId.empty()) {
+        elem->SetAttribute("mod-id", toast.modId);
+    }
     if (!toast.type.empty()) {
         elem->SetClass(toast.type, true);
     }
@@ -79,8 +86,7 @@ Rml::Element* create_toast(Rml::Element* parent, const Toast& toast) {
         if (toast.title.starts_with("<")) {
             heading->SetInnerRML(toast.title);
         } else {
-            auto* span = append(heading, "span");
-            span->SetInnerRML(toast.title);
+            append_text(append(heading, "toast-title"), toast.title);
         }
         if (toast.type == "achievement") {
             auto* icon = append(heading, "icon");
@@ -92,6 +98,9 @@ Rml::Element* create_toast(Rml::Element* parent, const Toast& toast) {
         } else if (toast.type == "warning") {
             auto* icon = append(heading, "icon");
             icon->SetClass("warning", true);
+        } else if (toast.type == "mod-installed") {
+            auto* icon = append(heading, "icon");
+            icon->SetClass("download-done", true);
         }
     }
     {
@@ -99,8 +108,7 @@ Rml::Element* create_toast(Rml::Element* parent, const Toast& toast) {
         if (toast.content.starts_with("<")) {
             message->SetInnerRML(toast.content);
         } else {
-            auto* span = append(message, "span");
-            span->SetInnerRML(toast.content);
+            append_text(append(message, "toast-message-text"), toast.content);
         }
     }
     {
@@ -115,14 +123,15 @@ Rml::Element* create_controller_warning(Rml::Element* parent) {
     elem->SetClass("controller-warning", true);
 
     auto* heading = append(elem, "heading");
-    auto* title = append(heading, "span");
-    title->SetInnerRML("No Device Assigned");
+    append_text(append(heading, "toast-title"), "No Device Assigned");
     auto* icon = append(heading, "icon");
     icon->SetClass("warning", true);
 
     auto* message = append(elem, "message");
-    auto* content = append(message, "span");
-    content->SetInnerRML("Configure <b>Port 1</b> in Settings.");
+    auto* content = append(message, "toast-message-text");
+    append_text(content, "Configure ");
+    append_text(append(content, "b"), "Port 1");
+    append_text(content, " in Settings.");
 
     return elem;
 }
@@ -157,12 +166,6 @@ Rml::String back_button_name() {
     return "Back";
 }
 
-#if defined(TARGET_ANDROID) || (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST)
-constexpr auto kMenuNotificationPrefix = "3-finger tap or";
-#else
-constexpr auto kMenuNotificationPrefix = "Press <b>F1</b> or";
-#endif
-
 Rml::Element* create_menu_notification(Rml::Element* parent) {
     auto* elem = append(parent, "toast");
     elem->SetClass("menu-notification", true);
@@ -179,11 +182,18 @@ Rml::Element* create_menu_notification(Rml::Element* parent) {
 
     auto* message = append(elem, "message");
     auto* row = append(message, "row");
-    append(row, "span")->SetInnerRML(kMenuNotificationPrefix);
+    auto* prefix = append(row, "notification-prefix");
+#if defined(TARGET_ANDROID) || (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST)
+    append_text(prefix, "3-finger tap or");
+#else
+    append_text(prefix, "Press ");
+    append_text(append(prefix, "b"), "F1");
+    append_text(prefix, " or");
+#endif
     auto* icon = append(row, "icon");
     icon->SetClass("controller", true);
-    append(row, "span")->SetInnerRML("<b>" + escape(padButton) + "</b>");
-    append(row, "span")->SetInnerRML("to open menu");
+    append_text(append(append(row, "notification-button"), "b"), padButton);
+    append_text(append(row, "notification-action"), "to open menu");
 
     return elem;
 }
@@ -200,10 +210,20 @@ void remove_element(Rml::Element*& elem) noexcept {
 
 }  // namespace
 
-static std::string FormatTime(OSTime ticks) {
-    OSCalendarTime t;
-    OSTicksToCalendarTime(ticks, &t);
-    return fmt::format("{0:02}:{1:02}:{2:02}.{3:03}", t.hour, t.min, t.sec, t.msec);
+static std::string FormatElapsedTime(OSTime ticksElapsed) {
+    using namespace std::chrono;
+
+    milliseconds ms{OSTicksToMilliseconds(ticksElapsed)};
+
+    const hours hr = duration_cast<hours>(ms);
+    ms -= hr;
+    const minutes min = duration_cast<minutes>(ms);
+    ms -= min;
+    const seconds sec = duration_cast<seconds>(ms);
+    ms -= sec;
+
+    return fmt::format(
+        "{0:02}:{1:02}:{2:02}.{3:03}", hr.count(), min.count(), sec.count(), ms.count());
 }
 
 Overlay::Overlay() : Document(kDocumentSource, true, DocumentScope::Overlay) {
@@ -252,8 +272,22 @@ void Overlay::update() {
         if (getSettings().video.enableFpsOverlay.getValue()) {
             const int idx = getSettings().video.fpsOverlayCorner.getValue();
             mFpsCounter->SetAttribute("open", "");
+            mFpsCounter->RemoveProperty(Rml::PropertyId::Bottom);
             mFpsCounter->SetAttribute("corner", kFpsCorners[idx]);
 
+            if (idx == 2) {
+                if (mPipelineProgress && mPipelineProgress->GetAttribute("open")) {
+                    // 12 (height of pipeline box off bottom) + height of pipeline box + 3 (padding
+                    // space)
+                    mFpsCounter->SetProperty(Rml::PropertyId::Bottom,
+                        Rml::Property(15 + mPipelineProgress->GetOffsetHeight(), Rml::Unit::PX));
+                } else {
+                    // Return fps counter to default height off the bottom
+                    mFpsCounter->SetProperty(
+                        Rml::PropertyId::Bottom, Rml::Property(12, Rml::Unit::PX));
+                }
+            }
+
             const Uint64 perfFreq = SDL_GetPerformanceFrequency();
             float fps = aurora_get_fps();
 
@@ -264,7 +298,7 @@ void Overlay::update() {
                 static_cast<double>(now - mFpsLastUpdate) >= 0.5 * static_cast<double>(perfFreq);
             if (refreshLabel) {
                 mFpsLastUpdate = now;
-                mFpsCounter->SetInnerRML(escape(fmt::format("{:.0f} FPS", fps)));
+                set_text_content(mFpsCounter, fmt::format("{:.0f} FPS", fps));
             }
         } else {
             mFpsCounter->RemoveAttribute("open");
@@ -275,7 +309,7 @@ void Overlay::update() {
     update_pipeline_progress();
 
 #if !(defined(__ANDROID__) || (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST))
-    if (getSettings().game.speedrunMode && getSettings().game.liveSplitEnabled) {
+    if (dusk::speedrun::isActive() && getSettings().game.liveSplitEnabled) {
         dusk::speedrun::updateLiveSplit();
         if (dusk::speedrun::consumeConnectedEvent()) {
             push_toast({.title = "LiveSplit connected", .duration = std::chrono::seconds(3)});
@@ -287,46 +321,48 @@ void Overlay::update() {
 #endif
 
     if (mSpeedrunTimer != nullptr && mSpeedrunRta != nullptr && mSpeedrunIgt != nullptr) {
-        if (getSettings().game.speedrunMode) {
+        if (dusk::speedrun::isActive()) {
             // L+R+A+Start to reset timer
             if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) &&
                 mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigZ(PAD_1))
             {
-                m_speedrunInfo.reset();
+                dusk::speedrun::g_speedrunInfo.reset();
             }
 
             // L+R+A+Y to manually stop timer
             if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) &&
                 mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigY(PAD_1))
             {
-                if (m_speedrunInfo.m_isRunStarted) {
-                    m_speedrunInfo.m_endTimestamp = OSGetTime() - m_speedrunInfo.m_startTimestamp;
-                    m_speedrunInfo.m_isRunStarted = false;
+                if (speedrun::g_speedrunInfo.m_isRunStarted) {
+                    speedrun::g_speedrunInfo.stopRun();
                 }
             }
 
-            OSTime elapsedTime = 0;
-            if (m_speedrunInfo.m_isRunStarted) {
-                elapsedTime = OSGetTime() - m_speedrunInfo.m_startTimestamp;
-            } else if (m_speedrunInfo.m_endTimestamp != 0) {
-                elapsedTime = m_speedrunInfo.m_endTimestamp;
+            OSTime rtaElapsedTime = 0;
+            if (speedrun::g_speedrunInfo.m_isRunStarted) {
+                rtaElapsedTime = OSGetNativeTime() - speedrun::g_speedrunInfo.m_rtaStartTimestamp;
+            } else if (speedrun::g_speedrunInfo.m_rtaTimer != 0) {
+                rtaElapsedTime = speedrun::g_speedrunInfo.m_rtaTimer;
             }
 
-            if (!m_speedrunInfo.m_isPauseIGT) {
-                m_speedrunInfo.m_igtTimer = elapsedTime - m_speedrunInfo.m_totalLoadTime;
+            if (speedrun::g_speedrunInfo.m_isRunStarted && !speedrun::g_speedrunInfo.m_isPauseIGT) {
+                speedrun::g_speedrunInfo.m_igtTimer = OSGetTime() -
+                                                      speedrun::g_speedrunInfo.m_igtStartTimestamp -
+                                                      speedrun::g_speedrunInfo.m_totalLoadTime;
             }
 
             mSpeedrunTimer->SetAttribute("open", "");
 
             if (getSettings().game.showSpeedrunRTATimer) {
                 mSpeedrunRta->SetAttribute("open", "");
-                mSpeedrunRta->SetInnerRML(escape(fmt::format("RTA  {}", FormatTime(elapsedTime))));
+                set_text_content(
+                    mSpeedrunRta, fmt::format("RTA  {}", FormatElapsedTime(rtaElapsedTime)));
             } else {
                 mSpeedrunRta->RemoveAttribute("open");
             }
 
-            mSpeedrunIgt->SetInnerRML(
-                escape(fmt::format("IGT  {}", FormatTime(m_speedrunInfo.m_igtTimer))));
+            set_text_content(mSpeedrunIgt,
+                fmt::format("IGT  {}", FormatElapsedTime(speedrun::g_speedrunInfo.m_igtTimer)));
         } else {
             mSpeedrunTimer->RemoveAttribute("open");
         }
@@ -444,8 +480,8 @@ void Overlay::update_pipeline_progress() {
     if (queuedPipelines != mLastQueuedPipelines) {
         mLastQueuedPipelines = queuedPipelines;
         const auto noun = queuedPipelines == 1 ? "pipeline" : "pipelines";
-        mPipelineProgressLabel->SetInnerRML(
-            escape(fmt::format("Building {} {}", queuedPipelines, noun)));
+        set_text_content(
+            mPipelineProgressLabel, fmt::format("Building {} {}", queuedPipelines, noun));
     }
     mPipelineProgressBar->SetAttribute("value", progress);
 
diff --git a/src/dusk/ui/package_row.cpp b/src/dusk/ui/package_row.cpp
new file mode 100644
index 0000000000..e3849c9e5d
--- /dev/null
+++ b/src/dusk/ui/package_row.cpp
@@ -0,0 +1,121 @@
+#include "package_row.hpp"
+
+#include "fmt/format.h"
+
+namespace dusk::ui {
+namespace {
+
+Rml::Element* create_row(Rml::Element* parent) {
+    auto element = parent->GetOwnerDocument()->CreateElement("package-row");
+    return parent->AppendChild(std::move(element));
+}
+
+}  // namespace
+
+const char* queue_state_class(mods::queue::State state) {
+    using enum mods::queue::State;
+    switch (state) {
+    case Downloading:
+        return "downloading";
+    case Paused:
+        return "paused";
+    case Retrying:
+        return "retrying";
+    case Verifying:
+        return "installing";
+    case Handoff:
+        return "installing";
+    case Installed:
+        return "installed";
+    case InstallFailed:
+        return "failed";
+    case Failed:
+        return "failed";
+    case Canceled:
+        return "canceled";
+    case Queued:
+        return "queued";
+    }
+    return "queued";
+}
+
+std::string state_label(const mods::queue::Item& item) {
+    using enum mods::queue::State;
+    switch (item.state) {
+    case Queued:
+        return "Queued";
+    case Downloading:
+        return "Downloading";
+    case Paused:
+        return "Paused";
+    case Retrying:
+        return fmt::format("Retrying in {}s", item.retrySeconds);
+    case Verifying:
+        return "Verifying";
+    case Handoff:
+        return "Installing";
+    case Installed:
+        return "Installed";
+    case InstallFailed:
+        return "Failed";
+    case Failed:
+        return "Failed";
+    case Canceled:
+        return "Canceled";
+    }
+    return {};
+}
+
+PackageRow::PackageRow(Rml::Element* parent) : Component{create_row(parent)} {
+    mIcon = append(mRoot, "mod-icon");
+    auto* info = append(mRoot, "section");
+    auto* heading = append(info, "header");
+    auto* identity = append(heading, "h3");
+    mName = append(identity, "span");
+    mVersion = append(identity, "small");
+    mState = append(heading, "small");
+    mProgress = append(info, "progress");
+    mFooter = append(info, "footer");
+    mDetail = append(mFooter, "small");
+}
+
+void PackageRow::set_package(std::string name, std::string version, std::string status,
+    std::string detail, std::string stateClass, std::optional<float> progress) {
+    mRoot->SetClassNames(stateClass);
+    set_text_content(mName, name);
+    set_text_content(mVersion, fmt::format("v{}", version));
+    mVersion->SetProperty("display", version.empty() ? "none" : "block");
+    set_text_content(mState, status);
+    set_text_content(mDetail, detail);
+    if (progress) {
+        mProgress->SetProperty("display", "block");
+        mProgress->SetAttribute("value", *progress);
+    } else {
+        mProgress->SetProperty("display", "none");
+    }
+}
+
+void PackageRow::set_icon(std::string source) {
+    mIcon->SetClass("visible", true);
+    if (mIconSource == source) {
+        return;
+    }
+    mIconSource = std::move(source);
+    if (mIconSource.empty()) {
+        mIcon->RemoveProperty("decorator");
+        mIcon->SetClass("has-image", false);
+        return;
+    }
+    mIcon->SetProperty(
+        "decorator", fmt::format(R"(image("{}" cover center center))", escape(mIconSource)));
+    mIcon->SetClass("has-image", true);
+}
+
+Rml::Element* PackageRow::actions_root() {
+    if (mActions == nullptr) {
+        mActions = append(mFooter, "nav");
+    }
+    return mActions;
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/package_row.hpp b/src/dusk/ui/package_row.hpp
new file mode 100644
index 0000000000..198c352744
--- /dev/null
+++ b/src/dusk/ui/package_row.hpp
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "component.hpp"
+#include "dusk/mods/queue.hpp"
+
+#include <cstdint>
+#include <optional>
+#include <string>
+
+namespace dusk::ui {
+
+const char* queue_state_class(mods::queue::State state);
+std::string state_label(const mods::queue::Item& item);
+
+class PackageRow : public Component {
+public:
+    explicit PackageRow(Rml::Element* parent);
+
+    void set_package(std::string name, std::string version, std::string status, std::string detail,
+        std::string stateClass, std::optional<float> progress = {});
+    void set_icon(std::string source);
+    Rml::Element* actions_root();
+
+private:
+    Rml::Element* mIcon = nullptr;
+    Rml::Element* mName = nullptr;
+    Rml::Element* mVersion = nullptr;
+    Rml::Element* mState = nullptr;
+    Rml::Element* mProgress = nullptr;
+    Rml::Element* mDetail = nullptr;
+    Rml::Element* mFooter = nullptr;
+    Rml::Element* mActions = nullptr;
+    std::string mIconSource;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/pane.cpp b/src/dusk/ui/pane.cpp
index 01eaf1194b..6544d96c33 100644
--- a/src/dusk/ui/pane.cpp
+++ b/src/dusk/ui/pane.cpp
@@ -90,11 +90,6 @@ Pane::Pane(Rml::Element* parent, Type type) : FluentComponent(createRoot(parent)
     }
 }
 
-void Pane::update() {
-    finalize();
-    Component::update();
-}
-
 void Pane::set_selected_item(int index) {
     if (mType == Type::Uncontrolled) {
         return;
@@ -163,16 +158,24 @@ bool Pane::focus() {
     return false;
 }
 
+bool Pane::focus_last() {
+    for (auto child = mChildren.rbegin(); child != mChildren.rend(); ++child) {
+        if ((*child)->focus()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 Rml::Element* Pane::add_section(const Rml::String& text) {
-    auto* elem = append(mRoot, "div");
-    elem->SetClass("section-heading", true);
-    elem->SetInnerRML(escape(text));
+    auto* elem = append(mRoot, "section-heading");
+    append_text(elem, text);
     return elem;
 }
 
 Rml::Element* Pane::add_text(const Rml::String& text) {
     auto* elem = append(mRoot, "div");
-    elem->SetInnerRML(escape(text));
+    append_text(elem, text);
     return elem;
 }
 
@@ -182,22 +185,8 @@ Rml::Element* Pane::add_rml(const Rml::String& rml) {
     return elem;
 }
 
-void Pane::finalize() {
-    if (finalized) {
-        return;
-    }
-    finalized = true;
-
-    // Append spacer element to the bottom. RmlUi does not properly handle
-    // padding-bottom or margin-bottom on a scrollable flex container, so
-    // we need to create a fake spacer with an actual layout height to get
-    // padding at the bottom of a scrollable container.
-    append(mRoot, "spacer");
-}
-
 void Pane::clear() {
     clear_children();
-    finalized = false;
 }
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/pane.hpp b/src/dusk/ui/pane.hpp
index f22d89825d..fe13bd2093 100644
--- a/src/dusk/ui/pane.hpp
+++ b/src/dusk/ui/pane.hpp
@@ -2,6 +2,7 @@
 
 #include "button.hpp"
 #include "component.hpp"
+#include "group_button.hpp"
 #include "select_button.hpp"
 
 namespace dusk::ui {
@@ -16,7 +17,7 @@ public:
     explicit Pane(Rml::Element* parent, Type type);
 
     bool focus() override;
-    void update() override;
+    bool focus_last();
 
     void set_selected_item(int index);
     Component& register_control(
@@ -26,18 +27,19 @@ public:
     ControlledButton& add_button(ControlledButton::Props props) {
         return add_child<ControlledButton>(std::move(props));
     }
+    GroupButton& add_group_button(GroupButton::Props props) {
+        return add_child<GroupButton>(std::move(props));
+    }
     Button& add_button(Rml::String text) { return add_child<Button>(std::move(text)); }
     ControlledSelectButton& add_select_button(ControlledSelectButton::Props props) {
         return add_child<ControlledSelectButton>(std::move(props));
     }
     Rml::Element* add_text(const Rml::String& text);
     Rml::Element* add_rml(const Rml::String& rml);
-    void finalize();
     void clear();
 
 private:
     Type mType;
-    bool finalized = false;
 };
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/popover.cpp b/src/dusk/ui/popover.cpp
new file mode 100644
index 0000000000..7508a39bba
--- /dev/null
+++ b/src/dusk/ui/popover.cpp
@@ -0,0 +1,161 @@
+#include "popover.hpp"
+
+#include <algorithm>
+
+namespace dusk::ui {
+namespace {
+
+const Rml::String kDocumentSource = R"RML(
+<rml>
+<head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
+    <link type="text/rcss" href="res/rml/popover.rcss" />
+</head>
+<body>
+    <popover id="popover"/>
+</body>
+</rml>
+)RML";
+
+constexpr float kAnchorGapDp = 8.0f;
+constexpr float kViewportMarginDp = 8.0f;
+
+}  // namespace
+
+Popover::Popover(Rml::Element* anchor, Side side, const Rml::String& windowClass)
+    : Document{kDocumentSource}, mAnchor{anchor->GetObserverPtr()}, mSide{side},
+      mBody{mDocument->GetElementById("popover")} {
+    if (!windowClass.empty()) {
+        mBody->SetClass(windowClass, true);
+    }
+
+    listen(mBody, Rml::EventId::Transitionend, [this](Rml::Event& event) {
+        if (event.GetTargetElement() == mBody && !mBody->HasAttribute("open") &&
+            Document::visible())
+        {
+            Document::hide(mPendingClose);
+        }
+    });
+
+    listen(
+        mDocument->GetContext()->GetRootElement(), Rml::EventId::Mousedown,
+        [this](const Rml::Event& event) {
+            const auto within = [](const Rml::Element* element, const Rml::Element* container) {
+                while (element != nullptr && element != container) {
+                    element = element->GetParentNode();
+                }
+                return element != nullptr;
+            };
+            if (visible() && !within(event.GetTargetElement(), mBody)) {
+                dismiss();
+            }
+        },
+        true);
+}
+
+Popover::~Popover() {
+    notify_close(false);
+}
+
+void Popover::show() {
+    Document::show();
+    reposition();
+    mBody->SetAttribute("open", "");
+    focus();
+}
+
+void Popover::hide(bool close) {
+    notify_close(true);
+    mBody->RemoveAttribute("open");
+    mPendingClose = close;
+}
+
+bool Popover::focus() {
+    if (mOnFocus && mOnFocus()) {
+        return true;
+    }
+    return mBody != nullptr && mBody->Focus(true);
+}
+
+bool Popover::visible() const {
+    return mBody != nullptr && mBody->HasAttribute("open");
+}
+
+void Popover::update() {
+    Document::update();
+    if (!visible()) {
+        return;
+    }
+    if (mAnchor == nullptr || !mAnchor->IsVisible(true)) {
+        dismiss();
+        return;
+    }
+    reposition();
+}
+
+void Popover::dismiss() {
+    if (visible()) {
+        hide(true);
+    }
+}
+
+bool Popover::handle_nav_command(Rml::Event&, NavCommand cmd) {
+    if (cmd == NavCommand::Cancel || cmd == NavCommand::Menu) {
+        dismiss();
+        return true;
+    }
+    return false;
+}
+
+void Popover::reposition() {
+    if (!mAnchor) {
+        return;
+    }
+    auto* context = mDocument->GetContext();
+    const auto dimensions = Rml::Vector2f{context->GetDimensions()};
+    const float dpRatio = context->GetDensityIndependentPixelRatio();
+    const float gap = kAnchorGapDp * dpRatio;
+    const float margin = kViewportMarginDp * dpRatio;
+
+    const Rml::Vector2f anchorPos = mAnchor->GetAbsoluteOffset(Rml::BoxArea::Border);
+    const Rml::Vector2f anchorSize = mAnchor->GetBox().GetSize(Rml::BoxArea::Border);
+    const Rml::Vector2f size = mBody->GetBox().GetSize(Rml::BoxArea::Border);
+
+    Rml::Vector2f pos;
+    switch (mSide) {
+    case Side::Above:
+        pos = {anchorPos.x + (anchorSize.x - size.x) * 0.5f, anchorPos.y - size.y - gap};
+        break;
+    case Side::Left:
+        pos = {anchorPos.x - size.x - gap, anchorPos.y + (anchorSize.y - size.y) * 0.5f};
+        break;
+    case Side::Right:
+        pos = {anchorPos.x + anchorSize.x + gap, anchorPos.y + (anchorSize.y - size.y) * 0.5f};
+        break;
+    case Side::Below:
+    default:
+        pos = {anchorPos.x + (anchorSize.x - size.x) * 0.5f, anchorPos.y + anchorSize.y + gap};
+        break;
+    }
+
+    if (mPosition) {
+        pos = *mPosition;
+    }
+    pos.x = std::clamp(pos.x, margin, std::max(margin, dimensions.x - size.x - margin));
+    pos.y = std::clamp(pos.y, margin, std::max(margin, dimensions.y - size.y - margin));
+    mBody->SetProperty(Rml::PropertyId::Left, Rml::Property{pos.x, Rml::Unit::PX});
+    mBody->SetProperty(Rml::PropertyId::Top, Rml::Property{pos.y, Rml::Unit::PX});
+}
+
+void Popover::notify_close(bool restoreFocus) {
+    if (mOnClose) {
+        auto callback = std::move(mOnClose);
+        mOnClose = nullptr;
+        callback();
+    }
+    if (restoreFocus && mAnchor != nullptr && mAnchor->IsVisible(true)) {
+        mAnchor->Focus(true);
+    }
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/popover.hpp b/src/dusk/ui/popover.hpp
new file mode 100644
index 0000000000..c408ce600e
--- /dev/null
+++ b/src/dusk/ui/popover.hpp
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "document.hpp"
+
+#include <optional>
+
+namespace dusk::ui {
+
+class Popover : public Document {
+public:
+    enum class Side {
+        Below,
+        Above,
+        Left,
+        Right,
+    };
+
+    Popover(Rml::Element* anchor, Side side, const Rml::String& windowClass = "");
+    ~Popover() override;
+
+    void show() override;
+    void hide(bool close) override;
+    bool focus() override;
+    bool visible() const override;
+    void update() override;
+
+    Rml::Element* body() const { return mBody; }
+
+    void set_position(Rml::Vector2f position) { mPosition = position; }
+
+    void dismiss();
+    void on_close(std::function<void()> callback) { mOnClose = std::move(callback); }
+    void on_focus(std::function<bool()> callback) { mOnFocus = std::move(callback); }
+
+protected:
+    bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
+
+private:
+    void reposition();
+    void notify_close(bool restoreFocus);
+
+    Rml::ObserverPtr<Rml::Element> mAnchor;
+    std::optional<Rml::Vector2f> mPosition;
+    Side mSide;
+    Rml::Element* mBody = nullptr;
+    std::function<void()> mOnClose;
+    std::function<bool()> mOnFocus;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/prelaunch.cpp b/src/dusk/ui/prelaunch.cpp
index 8379d4bef0..4a6361a4ef 100644
--- a/src/dusk/ui/prelaunch.cpp
+++ b/src/dusk/ui/prelaunch.cpp
@@ -1,23 +1,28 @@
 #include "prelaunch.hpp"
 
+#include "dusk/app_info.hpp"
 #include "dusk/config.hpp"
 #include "dusk/data.hpp"
-#include "dusk/file_select.hpp"
+#include "dusk/game_mode.hpp"
 #include "dusk/iso_validate.hpp"
+#include "dusk/language.hpp"
 #include "dusk/main.h"
 #include "dusk/settings.h"
-#include "dusk/update_check.hpp"
+#include "dusk/ui/format.hpp"
+#include "dusk/ui/menu_bar.hpp"
 #include "modal.hpp"
 #include "mods_window.hpp"
 #include "preset.hpp"
 #include "settings.hpp"
-#include "version.h"
 
-#include <SDL3/SDL_dialog.h>
 #include <SDL3/SDL_error.h>
 #include <SDL3/SDL_misc.h>
-#include <aurora/lib/logging.hpp>
 #include <aurora/lib/window.hpp>
+#include <borealis/file_select.hpp>
+#include <borealis/io.hpp>
+#include <borealis/log.hpp>
+#include <borealis/update.hpp>
+#include <borealis/version.h>
 #include <fmt/format.h>
 
 #include <algorithm>
@@ -32,50 +37,54 @@
 
 namespace dusk::ui {
 namespace {
-aurora::Module PrelaunchLog{"dusk::ui::prelaunch"};
+constexpr borealis::Log PrelaunchLog{"dusk::ui::prelaunch"};
+constexpr ByteFormat verificationByteFormat{.gibFractionDigits = 2, .mibFractionDigits = 0};
+
+PrelaunchState sPrelaunchState;
 
 const Rml::String kDocumentSource = R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/prelaunch.rcss" />
 </head>
 <body>
-    <div class="gradient" />
-    <div class="background" />
+    <prelaunch-gradient />
+    <prelaunch-background />
     <content id="root" open>
         <menu>
             <hero class="intro-item delay-0">
-                <eyebrow><span>Twilit Realm</span> presents</eyebrow>
+                <eyebrow><studio-name>Twilit Realm</studio-name> presents</eyebrow>
                 <img src="res/logo.png" />
             </hero>
-            <div id="menu-list" />
+            <menu-list id="menu-list" />
         </menu>
         <disc-info class="intro-item delay-5">
-            <div id="disc-status">
+            <disc-status id="disc-status">
                 <icon />
-                <span id="disc-status-label" />
-            </div>
-            <span id="disc-version" class="detail" />
+                <disc-status-label id="disc-status-label" />
+            </disc-status>
+            <disc-version id="disc-version" />
         </disc-info>
         <version-info class="intro-item delay-6">
-            <div class="version">Version <span id="version-text"></span></div>
-            <div id="update-status" class="update">
-                <span id="update-message"></span>
+            <version-label>Version <version-number id="version-text"></version-number></version-label>
+            <update-status id="update-status">
+                <update-message id="update-message"></update-message>
                 <button id="update-download">
-                    <span id="update-download-label"></span>
+                    <update-download-label id="update-download-label"></update-download-label>
                     &nbsp;<icon />
                 </button>
-            </div>
+            </update-status>
         </version-info>
     </content>
 </body>
 </rml>
 )RML";
 
-constexpr std::array<SDL_DialogFileFilter, 2> kDiscFileFilters{{
+const std::vector<borealis::file_select::Filter> kDiscFileFilters{
     {"Game Disc Images", "iso;gcm;ciso;gcz;nfs;rvz;wbfs;wia;tgc"},
     {"All Files", "*"},
-}};
+};
 
 struct DiscVerificationResult {
     std::string path;
@@ -102,7 +111,7 @@ struct DiscVerificationTask {
     }
 
     ~DiscVerificationTask() {
-        status.shouldCancel.store(true, std::memory_order_relaxed);
+        status.cancelRequested.store(true, std::memory_order_relaxed);
         join();
     }
 
@@ -125,43 +134,8 @@ struct DiscVerificationTask {
 std::unique_ptr<DiscVerificationTask> sDiscVerificationTask;
 bool sDiscVerificationModalPushed = false;
 
-struct UpdateCheckTask {
-    UpdateCheckTask() {
-        worker = std::thread([this] {
-            try {
-                result = update_check::check_latest_github_release("TwilitRealm", "dusklight");
-            } catch (const std::exception& e) {
-                result = {
-                    .status = update_check::Status::Failed,
-                    .message = fmt::format("Update check failed with exception: {}", e.what()),
-                };
-            } catch (...) {
-                result = {
-                    .status = update_check::Status::Failed,
-                    .message = "Update check failed with an unknown exception",
-                };
-            }
-            done.store(true, std::memory_order_release);
-        });
-    }
-
-    ~UpdateCheckTask() { join(); }
-
-    void join() {
-        if (worker.joinable()) {
-            worker.join();
-        }
-    }
-
-    [[nodiscard]] bool finished() const { return done.load(std::memory_order_acquire); }
-
-    update_check::Result result;
-    std::atomic_bool done = false;
-    std::thread worker;
-};
-
-std::unique_ptr<UpdateCheckTask> sUpdateCheckTask;
-std::optional<update_check::Result> sUpdateCheckResult;
+borealis::Task<borealis::update::Result> sUpdateCheck;
+std::optional<borealis::update::Result> sUpdateCheckResult;
 
 bool verification_state_allows_launch(iso::ValidationError validation) noexcept {
     return validation == iso::ValidationError::Unknown ||
@@ -191,28 +165,12 @@ DiscVerificationState verification_to_config(iso::ValidationError validation) {
     }
 }
 
-std::string format_bytes(std::size_t bytes) {
-    constexpr double KiB = 1024.0;
-    constexpr double MiB = KiB * 1024.0;
-    constexpr double GiB = MiB * 1024.0;
-    if (bytes >= static_cast<std::size_t>(GiB)) {
-        return fmt::format("{:.2f} GiB", static_cast<double>(bytes) / GiB);
-    }
-    if (bytes >= static_cast<std::size_t>(MiB)) {
-        return fmt::format("{:.0f} MiB", static_cast<double>(bytes) / MiB);
-    }
-    if (bytes >= static_cast<std::size_t>(KiB)) {
-        return fmt::format("{:.0f} KiB", static_cast<double>(bytes) / KiB);
-    }
-    return fmt::format("{} B", bytes);
-}
-
 void begin_disc_verification(std::string path) noexcept {
     if (path.empty()) {
         return;
     }
     if (sDiscVerificationTask != nullptr) {
-        sDiscVerificationTask->status.shouldCancel.store(true, std::memory_order_relaxed);
+        sDiscVerificationTask->status.cancelRequested.store(true, std::memory_order_relaxed);
         sDiscVerificationTask.reset();
     }
     sDiscVerificationTask = std::make_unique<DiscVerificationTask>(std::move(path));
@@ -238,24 +196,23 @@ void begin_update_check() {
     if (!getSettings().backend.checkForUpdates.getValue()) {
         return;
     }
-    if (sUpdateCheckTask != nullptr || sUpdateCheckResult.has_value()) {
+    if (sUpdateCheck || sUpdateCheckResult.has_value()) {
         return;
     }
-    sUpdateCheckTask = std::make_unique<UpdateCheckTask>();
+    sUpdateCheck = borealis::update::check_latest_github_release(AppInfo);
 }
 
-std::optional<update_check::Result> take_finished_update_check() {
-    if (sUpdateCheckTask == nullptr || !sUpdateCheckTask->finished()) {
+std::optional<borealis::update::Result> take_finished_update_check() {
+    if (!sUpdateCheck || !sUpdateCheck.ready()) {
         return std::nullopt;
     }
 
-    sUpdateCheckTask->join();
-    auto result = std::move(sUpdateCheckTask->result);
-    sUpdateCheckTask.reset();
+    auto result = sUpdateCheck.try_take();
+    sUpdateCheck = {};
     return result;
 }
 
-std::string update_release_label(const update_check::Release& release) {
+std::string update_release_label(const borealis::update::Release& release) {
     std::string_view tagName = release.tagName;
     if (!tagName.empty() && tagName.front() == 'v') {
         tagName.remove_prefix(1);
@@ -265,7 +222,7 @@ std::string update_release_label(const update_check::Release& release) {
 
 void open_update_release() {
     if (!sUpdateCheckResult.has_value() ||
-        sUpdateCheckResult->status != update_check::Status::UpdateAvailable)
+        sUpdateCheckResult->status != borealis::update::Status::UpdateAvailable)
     {
         return;
     }
@@ -291,7 +248,7 @@ std::string get_error_msg(iso::ValidationError error) {
     case iso::ValidationError::WrongGame:
         return "The selected game is not supported by Dusklight.";
     case iso::ValidationError::WrongVersion:
-        return "Dusklight currently supports GameCube USA and PAL disc images only.";
+        return "Dusklight does not currently support the Wii's Korean version.";
     case iso::ValidationError::Canceled:
         return "Disc verification was canceled. Dusklight cannot guarantee the selected disc "
                "image is compatible.";
@@ -317,6 +274,24 @@ void persist_disc_choice(const std::string& path, iso::ValidationError validatio
     }
 }
 
+void apply_language_for_disc(const iso::DiscInfo& info) {
+    const auto langs = language::available_languages(info);
+    auto& language = getSettings().game.language;
+    const GameLanguage previous = language.getValue();
+    if (std::ranges::find(langs, previous) != langs.end()) {
+        return;
+    }
+
+    const GameLanguage fallback = langs.front();
+    language.setValue(fallback);
+    config::save();
+
+    auto& state = prelaunch_state();
+    state.initialLanguage = fallback;
+    state.unavailableLanguage = previous;
+    state.pendingLanguageUnavailableNotice = true;
+}
+
 void apply_valid_disc_result(
     const std::string& path, const iso::DiscInfo& info, iso::ValidationError validation) {
     auto& state = prelaunch_state();
@@ -329,6 +304,7 @@ void apply_valid_disc_result(
         state.activeDiscInfo = info;
     }
     persist_disc_choice(path, validation);
+    apply_language_for_disc(info);
 }
 
 void apply_disc_verification_result(const DiscVerificationResult& result) {
@@ -340,7 +316,7 @@ void apply_disc_verification_result(const DiscVerificationResult& result) {
         state.pendingDiscPath = result.path;
         state.pendingDiscInfo = result.info;
         state.pendingDiscValidation = result.validation;
-        state.errorString = escape(get_error_msg(result.validation));
+        state.errorString = get_error_msg(result.validation);
         return;
     }
 
@@ -356,41 +332,34 @@ void apply_disc_verification_result(const DiscVerificationResult& result) {
     state.pendingDiscPath.clear();
     state.pendingDiscInfo = {};
     state.pendingDiscValidation = iso::ValidationError::Unknown;
-    state.errorString = escape(get_error_msg(result.validation));
+    state.errorString = get_error_msg(result.validation);
 }
 
 class DiscVerificationModal : public WindowSmall {
 public:
-    DiscVerificationModal() : WindowSmall("modal", "modal-dialog") {
-        auto* header = append(mDialog, "div");
-        header->SetClass("modal-header", true);
+    DiscVerificationModal() : WindowSmall("modal") {
+        auto* header = append(mDialog, "modal-header");
 
-        auto* title = append(header, "div");
-        title->SetClass("modal-title", true);
-        title->SetInnerRML("Verifying disc image");
+        auto* title = append(header, "modal-title");
+        append_text(title, "Verifying disc image");
 
         auto* icon = append(header, "icon");
         icon->SetClass("verifying", true);
 
-        auto* body = append(mDialog, "div");
-        body->SetClass("modal-body", true);
+        auto* body = append(mDialog, "modal-body");
 
-        auto* content = append(body, "div");
-        content->SetClass("verification-progress", true);
+        auto* content = append(body, "verification-progress");
 
-        mFileName = append(content, "div");
-        mFileName->SetClass("verification-file", true);
+        mFileName = append(content, "verification-file");
 
         mProgress = append(content, "progress");
         mProgress->SetClass("progress-ongoing", true);
         mProgress->SetClass("verification-progress-bar", true);
         mProgress->SetAttribute("value", 0.f);
 
-        mDetail = append(content, "div");
-        mDetail->SetClass("verification-detail", true);
+        mDetail = append(content, "verification-detail");
 
-        auto* actions = append(mDialog, "div");
-        actions->SetClass("modal-actions", true);
+        auto* actions = append(mDialog, "modal-actions");
         mCancelButton = std::make_unique<Button>(actions, "Cancel");
         mCancelButton->root()->SetClass("modal-btn", true);
         mCancelButton->on_pressed([this] { request_cancel(); });
@@ -438,7 +407,7 @@ private:
         }
 
         mCancelRequested = true;
-        sDiscVerificationTask->status.shouldCancel.store(true, std::memory_order_relaxed);
+        sDiscVerificationTask->status.cancelRequested.store(true, std::memory_order_relaxed);
         if (mCancelButton != nullptr) {
             mCancelButton->set_text("Cancelling...");
             mCancelButton->set_disabled(true);
@@ -455,16 +424,16 @@ private:
         }
 
         if (mFileName != nullptr) {
-            std::string fileName = display_name_for_path(sDiscVerificationTask->path);
+            std::string fileName = borealis::io::display_name(sDiscVerificationTask->path);
             if (fileName.empty()) {
                 fileName = sDiscVerificationTask->path;
             }
-            mFileName->SetInnerRML(escape(fileName));
+            set_text_content(mFileName, fileName);
         }
 
-        const std::size_t bytesRead =
+        const size_t bytesRead =
             sDiscVerificationTask->status.bytesRead.load(std::memory_order_relaxed);
-        const std::size_t bytesTotal =
+        const size_t bytesTotal =
             sDiscVerificationTask->status.bytesTotal.load(std::memory_order_relaxed);
 
         if (bytesTotal == 0) {
@@ -472,7 +441,7 @@ private:
                 mProgress->SetAttribute("value", 0.f);
             }
             if (mDetail != nullptr) {
-                mDetail->SetInnerRML("Opening disc image...");
+                set_text_content(mDetail, "Opening disc image...");
             }
             return;
         }
@@ -483,8 +452,9 @@ private:
             mProgress->SetAttribute("value", fraction);
         }
         if (mDetail != nullptr) {
-            mDetail->SetInnerRML(escape(fmt::format("{} / {} ({:.0f}%)", format_bytes(bytesRead),
-                format_bytes(bytesTotal), fraction * 100.0f)));
+            set_text_content(mDetail,
+                fmt::format("{} / {} ({:.0f}%)", format_bytes(bytesRead, verificationByteFormat),
+                    format_bytes(bytesTotal, verificationByteFormat), fraction * 100.0f));
         }
     }
 
@@ -496,15 +466,155 @@ private:
     bool mFinished = false;
 };
 
-void file_dialog_callback(void*, const char* path, const char* error) {
-    if (path == nullptr || error != nullptr) {
+void file_dialog_callback(borealis::file_select::Result result) {
+    if (result.status != borealis::file_select::Status::Selected || result.locations.empty()) {
+        if (result.status == borealis::file_select::Status::Failed) {
+            PrelaunchLog.warn("File selection failed: {}", result.message);
+        }
         return;
     }
 
-    begin_disc_verification(path);
+    begin_disc_verification(result.locations.front());
 }
 
-PrelaunchState sPrelaunchState;
+std::vector<const gamemode::GameMode*> carousel_game_modes() {
+    const auto& registered = gamemode::getGameModeManager().getRegisteredGameModes();
+    std::vector<const gamemode::GameMode*> modes;
+    modes.reserve(registered.size());
+
+    if (const auto vanilla = registered.find(gamemode::kVanillaGameModeId);
+        vanilla != registered.end())
+    {
+        modes.push_back(&vanilla->second);
+    }
+    for (const auto& [id, mode] : registered) {
+        if (id != gamemode::kVanillaGameModeId) {
+            modes.push_back(&mode);
+        }
+    }
+    std::ranges::sort(modes.begin() + std::min<size_t>(1, modes.size()), modes.end(),
+        [](const auto* lhs, const auto* rhs) { return lhs->getFullName() < rhs->getFullName(); });
+    return modes;
+}
+
+std::string game_mode_button_text() {
+    if (prelaunch_state().activeDiscPath.empty()) {
+        return "Select Disc Image";
+    }
+    const auto* currentGameMode = gamemode::getGameModeManager().getCurrentGameMode();
+    if (currentGameMode == nullptr || currentGameMode->getId() == gamemode::kVanillaGameModeId) {
+        return "Play";
+    }
+    return currentGameMode->getFullName();
+}
+
+class GameModeButton final : public Button {
+public:
+    GameModeButton(Rml::Element* parent, ButtonCallback onPressed) : Button{parent, ""} {
+        root()->SetClass("game-mode-button", true);
+        mPrevious = append(root(), "game-mode-previous");
+        mLabelViewport = append(root(), "game-mode-label-viewport");
+        for (auto& label : mLabels) {
+            label = append(mLabelViewport, "game-mode-label");
+        }
+        mNext = append(root(), "game-mode-next");
+
+        Component::listen(mPrevious, Rml::EventId::Click, [this](Rml::Event& event) {
+            cycle(-1);
+            event.StopPropagation();
+        });
+        Component::listen(mNext, Rml::EventId::Click, [this](Rml::Event& event) {
+            cycle(1);
+            event.StopPropagation();
+        });
+        Component::listen(root(), Rml::EventId::Keydown, [this](Rml::Event& event) {
+            const auto command = map_nav_event(event);
+            if (command == NavCommand::Left || command == NavCommand::Right) {
+                cycle(command == NavCommand::Left ? -1 : 1);
+                event.StopPropagation();
+            }
+        });
+        on_pressed(std::move(onPressed));
+        refresh(0);
+    }
+
+    void update() override {
+        refresh(0);
+        Button::update();
+    }
+
+private:
+    bool can_cycle() const {
+        return !prelaunch_state().activeDiscPath.empty() &&
+               gamemode::getGameModeManager().getRegisteredGameModes().size() > 1;
+    }
+
+    void cycle(int direction) {
+        const auto modes = carousel_game_modes();
+        if (!can_cycle() || modes.empty()) {
+            return;
+        }
+
+        const auto* current = gamemode::getGameModeManager().getCurrentGameMode();
+        const auto currentIt = std::ranges::find_if(modes, [current](const auto* mode) {
+            return current != nullptr && mode->getId() == current->getId();
+        });
+        const int currentIndex =
+            currentIt == modes.end() ? 0 : static_cast<int>(currentIt - modes.begin());
+        const int count = static_cast<int>(modes.size());
+        const int nextIndex = ((currentIndex + direction) % count + count) % count;
+        const auto nextId = modes[nextIndex]->getId();
+        if (gamemode::getGameModeManager().setCurrentGameMode(nextId)) {
+            mDoAud_seStartMenu(kSoundItemChange);
+        }
+        refresh(direction);
+    }
+
+    void refresh(int direction) {
+        root()->SetClass("can-cycle", can_cycle());
+
+        const auto text = game_mode_button_text();
+        if (text == mText) {
+            return;
+        }
+        mText = text;
+        if (direction == 0) {
+            set_text_content(mLabels[mActiveLabel], text);
+            mLabels[mActiveLabel]->SetProperty(
+                Rml::PropertyId::Left, Rml::Property{0.0f, Rml::Unit::PERCENT});
+            mLabels[mActiveLabel]->SetClass("active", true);
+            mLabels[1 - mActiveLabel]->SetClass("active", false);
+            return;
+        }
+
+        constexpr float kSlideDistance = 100.0f;
+        constexpr float kSlideDuration = 0.24f;
+        auto* outgoing = mLabels[mActiveLabel];
+        mActiveLabel = 1 - mActiveLabel;
+        auto* incoming = mLabels[mActiveLabel];
+        set_text_content(incoming, text);
+
+        const Rml::Property incomingOffset{
+            static_cast<float>(direction) * kSlideDistance, Rml::Unit::PERCENT};
+        const Rml::Property outgoingOffset{
+            static_cast<float>(-direction) * kSlideDistance, Rml::Unit::PERCENT};
+
+        outgoing->Animate(Rml::PropertyId::Left, outgoingOffset, kSlideDuration,
+            Rml::Tween{Rml::Tween::Cubic, Rml::Tween::InOut});
+        incoming->Animate(Rml::PropertyId::Left, Rml::Property{0.0f, Rml::Unit::PERCENT},
+            kSlideDuration, Rml::Tween{Rml::Tween::Cubic, Rml::Tween::InOut}, 1, false, 0.0f,
+            &incomingOffset);
+        outgoing->SetClass("active", false);
+        incoming->SetClass("active", true);
+    }
+
+    Rml::Element* mPrevious = nullptr;
+    Rml::Element* mLabelViewport = nullptr;
+    std::array<Rml::Element*, 2> mLabels{};
+    Rml::Element* mNext = nullptr;
+    Rml::String mText;
+    size_t mActiveLabel = 0;
+};
 
 }  // namespace
 
@@ -545,6 +655,7 @@ void refresh_configured_disc_state() noexcept {
         if (state.configuredDiscPath == state.activeDiscPath) {
             state.activeDiscInfo = info;
         }
+        apply_language_for_disc(info);
         return;
     }
 
@@ -579,7 +690,7 @@ void try_push_verification_modal(Document& host) {
 
     if (!state.pendingDiscPath.empty()) {
         const Rml::String bodyRml =
-            state.errorString + "<br/><br/>You may proceed at your own risk.";
+            escape(state.errorString) + "<br/><br/>You may proceed at your own risk.";
         auto acceptHashMismatch = [](Modal& modal) {
             auto& st = prelaunch_state();
             std::string path = std::move(st.pendingDiscPath);
@@ -616,7 +727,7 @@ void try_push_verification_modal(Document& host) {
 
     host.push(std::make_unique<Modal>(Modal::Props{
         .title = "Disc verification error",
-        .bodyRml = state.errorString,
+        .bodyText = state.errorString,
         .actions =
             {
                 ModalAction{
@@ -629,6 +740,36 @@ void try_push_verification_modal(Document& host) {
     }));
 }
 
+void try_push_language_unavailable_modal(Document& host) {
+    auto& state = prelaunch_state();
+
+    if (!state.pendingLanguageUnavailableNotice) {
+        return;
+    }
+    state.pendingLanguageUnavailableNotice = false;
+
+    const Rml::String bodyRml = fmt::format(
+        "<b>{}</b> is not available on this disc. Language has been reset to <b>{}</b>.",
+        language::language_name(state.unavailableLanguage),
+        language::language_name(getSettings().game.language.getValue()));
+
+    auto dismiss = [](Modal& modal) { modal.pop(); };
+
+    host.push(std::make_unique<Modal>(Modal::Props{
+        .title = "Language unavailable",
+        .bodyRml = bodyRml,
+        .actions =
+            {
+                ModalAction{
+                    .label = "OK",
+                    .onPressed = dismiss,
+                },
+            },
+        .onDismiss = dismiss,
+        .icon = "warning",
+    }));
+}
+
 void ensure_initialized() noexcept {
     auto& state = prelaunch_state();
     if (state.initialized) {
@@ -649,8 +790,12 @@ void ensure_initialized() noexcept {
 
 void open_iso_picker() noexcept {
     ensure_initialized();
-    ShowFileSelect(&file_dialog_callback, nullptr, aurora::window::get_sdl_window(),
-        kDiscFileFilters.data(), kDiscFileFilters.size(), nullptr, false);
+    borealis::file_select::open_file(
+        {
+            .parentWindow = aurora::window::get_sdl_window(),
+            .filters = kDiscFileFilters,
+        },
+        &file_dialog_callback);
 }
 
 bool is_restart_pending() noexcept {
@@ -685,61 +830,25 @@ void try_apply_mirrored_layout(Rml::Element* body) {
     body->SetClass("mirrored", getSettings().game.enableMirrorMode.getValue());
 }
 
-Prelaunch::Prelaunch()
-    : Document(kDocumentSource, false, DocumentScope::Prelaunch),
-      mRoot(mDocument->GetElementById("root")) {
+void Prelaunch::refresh_menu_buttons() {
+    auto* prelaunch = static_cast<Prelaunch*>(find_document(DocumentScope::Prelaunch));
+    if (prelaunch == nullptr) {
+        return;
+    }
+    auto* menuList = prelaunch->mDocument->GetElementById("menu-list");
+    while (menuList->GetNumChildren() > 0) {
+        menuList->RemoveChild(menuList->GetChild(0));
+    }
+    prelaunch->mMenuButtons.clear();
+    prelaunch->build_menu_buttons();
+}
+
+Prelaunch::Prelaunch() : Document(kDocumentSource, false, DocumentScope::Prelaunch) {
+    mRoot = mDocument->GetElementById("root");
     ensure_initialized();
     begin_update_check();
 
-    if (auto* menuList = mDocument->GetElementById("menu-list")) {
-        auto& state = prelaunch_state();
-        const bool activeDiscLoaded = !state.activeDiscPath.empty();
-        mMenuButtons.push_back(
-            std::make_unique<Button>(menuList, activeDiscLoaded ? "Play" : "Select Disc Image"));
-        mMenuButtons.back()->on_pressed([this] {
-            if (prelaunch_state().activeDiscPath.empty()) {
-                open_iso_picker();
-                return;
-            }
-
-            mDoAud_seStartMenu(kSoundPlay);
-            show_menu_notification();
-
-            if (getSettings().audio.menuSounds) {
-                JAISoundHandle* handle = g_mEnvSeMgr.field_0x144.getHandle();
-                if (*handle) {
-                    (*handle)->stop(60);
-                    (*handle)->releaseHandle();
-                }
-            }
-
-            if (g_mDoMemCd_control.mCardCommand == mDoMemCd_Ctrl_c::Command_e::COMM_NONE_e) {
-                mDoMemCd_ThdInit();
-            }
-
-            IsGameLaunched = true;
-            pop();
-        });
-        apply_intro_animation(mMenuButtons.back()->root(), "delay-1");
-
-        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Settings"));
-        mMenuButtons.back()->on_pressed([this] {
-            mRestartSuppressed = false;
-            push(std::make_unique<SettingsWindow>(true));
-        });
-        apply_intro_animation(mMenuButtons.back()->root(), "delay-2");
-
-        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Mods"));
-        mMenuButtons.back()->on_pressed([this] {
-            mRestartSuppressed = false;
-            push(std::make_unique<ModsWindow>());
-        });
-        apply_intro_animation(mMenuButtons.back()->root(), "delay-3");
-
-        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Quit"));
-        mMenuButtons.back()->on_pressed([] { IsRunning = false; });
-        apply_intro_animation(mMenuButtons.back()->root(), "delay-4");
-    }
+    build_menu_buttons();
 
     mDiscStatus = mDocument->GetElementById("disc-status");
     mDiscDetail = mDocument->GetElementById("disc-version");
@@ -777,6 +886,68 @@ Prelaunch::Prelaunch()
     });
 }
 
+void Prelaunch::build_menu_buttons() {
+    if (auto* menuList = mDocument->GetElementById("menu-list")) {
+        // Restore the previously selected game mode before creating the play control.
+        gamemode::getGameModeManager().setGameModeToPrevious();
+
+        auto playButton = std::make_unique<GameModeButton>(menuList, [this] {
+            if (prelaunch_state().activeDiscPath.empty()) {
+                open_iso_picker();
+                return;
+            }
+
+            if (const auto* gameMode = gamemode::getGameModeManager().getCurrentGameMode();
+                gameMode != nullptr && !gameMode->invokeOnPlayFunction())
+            {
+                gamemode::getGameModeManager().setCurrentGameMode(gamemode::kVanillaGameModeId);
+                return;
+            }
+
+            mDoAud_seStartMenu(kSoundPlay);
+            show_menu_notification();
+
+            if (getSettings().audio.menuSounds) {
+                JAISoundHandle* handle = g_mEnvSeMgr.field_0x144.getHandle();
+                if (*handle) {
+                    (*handle)->stop(60);
+                    (*handle)->releaseHandle();
+                }
+            }
+
+            if (g_mDoMemCd_control.mCardCommand == mDoMemCd_Ctrl_c::Command_e::COMM_NONE_e) {
+                mDoMemCd_ThdInit();
+            }
+
+            prelaunch_state().firstLaunch = false;
+            IsGameLaunched = true;
+            hide(true);
+            MenuBar::refresh_tabs();
+        });
+        apply_intro_animation(playButton->root(), "delay-1");
+        mMenuButtons.push_back(std::move(playButton));
+
+        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Settings"));
+        mMenuButtons.back()->on_pressed([this] {
+            mRestartSuppressed = false;
+            bool showPrelaunchSettings = prelaunch_state().firstLaunch;
+            push(std::make_unique<SettingsWindow>(showPrelaunchSettings));
+        });
+        apply_intro_animation(mMenuButtons.back()->root(), "delay-2");
+
+        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Mods"));
+        mMenuButtons.back()->on_pressed([this] {
+            mRestartSuppressed = false;
+            push(std::make_unique<ModsWindow>());
+        });
+        apply_intro_animation(mMenuButtons.back()->root(), "delay-3");
+
+        mMenuButtons.push_back(std::make_unique<Button>(menuList, "Quit"));
+        mMenuButtons.back()->on_pressed([] { IsRunning = false; });
+        apply_intro_animation(mMenuButtons.back()->root(), "delay-4");
+    }
+}
+
 void Prelaunch::show() {
     Document::show();
     mDocument->SetAttribute("open", "");
@@ -788,14 +959,14 @@ void Prelaunch::show() {
             modal.pop();
         };
         std::vector<ModalAction> actions;
-        if constexpr (dusk::SupportsProcessRestart) {
+        if constexpr (SupportsProcessRestart) {
             actions.push_back(ModalAction{
                 .label = "Restart later",
                 .onPressed = dismiss,
             });
             actions.push_back(ModalAction{
                 .label = "Restart now",
-                .onPressed = [](Modal&) { dusk::RequestRestart(); },
+                .onPressed = [](Modal&) { RequestRestart(); },
             });
         } else {
             actions.push_back(ModalAction{
@@ -806,7 +977,7 @@ void Prelaunch::show() {
         push(std::make_unique<Modal>(Modal::Props{
             .title = "Apply Options",
             .bodyRml =
-                dusk::SupportsProcessRestart ?
+                SupportsProcessRestart ?
                     "A restart is required to apply selected options.<br/><br/>Restart now to "
                     "apply them immediately?" :
                     "A restart is required to apply selected options.<br/><br/>Close and reopen "
@@ -837,6 +1008,7 @@ void Prelaunch::update() {
 
     if (top_document() == this) {
         try_push_verification_modal(*this);
+        try_push_language_unavailable_modal(*this);
     }
 
     const auto& state = prelaunch_state();
@@ -855,8 +1027,8 @@ void Prelaunch::update() {
         mEntranceAnimationStarted = true;
     }
 
-    if (!mMenuButtons.empty()) {
-        mMenuButtons[0]->set_text(activeDiscLoaded ? "Play" : "Select Disc Image");
+    for (const auto& button : mMenuButtons) {
+        button->update();
     }
 
     const auto discStatusLabel = mDiscStatus->GetElementById("disc-status-label");
@@ -864,73 +1036,112 @@ void Prelaunch::update() {
     if (mDiscStatus != nullptr && discStatusLabel != nullptr) {
         if (!activeDiscLoaded) {
             mDiscStatus->RemoveAttribute("status");
-            discStatusLabel->SetInnerRML("No disc image found.");
+            set_text_content(discStatusLabel, "No disc image found.");
         } else if (discRestartPending) {
             mDiscStatus->SetAttribute("status", "pending");
-            discStatusLabel->SetInnerRML("Pending restart.");
+            set_text_content(discStatusLabel, "Pending restart.");
         } else if (state.configuredDiscValidation == iso::ValidationError::Success) {
             mDiscStatus->SetAttribute("status", "good");
-            discStatusLabel->SetInnerRML("Disc ready.");
+            set_text_content(discStatusLabel, "Disc ready.");
         } else if (state.configuredDiscValidation == iso::ValidationError::HashMismatch) {
             mDiscStatus->SetAttribute("status", "mismatch");
-            discStatusLabel->SetInnerRML("Disc hash mismatch.");
+            set_text_content(discStatusLabel, "Disc hash mismatch.");
         } else if (canLaunchConfiguredDisc) {
             mDiscStatus->SetAttribute("status", "unknown");
-            discStatusLabel->SetInnerRML("Disc not verified.");
+            set_text_content(discStatusLabel, "Disc not verified.");
         } else {
             mDiscStatus->SetAttribute("status", "bad");
-            discStatusLabel->SetInnerRML("Disc unavailable.");
+            set_text_content(discStatusLabel, "Disc unavailable.");
         }
     }
     if (mDiscDetail != nullptr) {
         if (activeDiscLoaded) {
             mDiscDetail->SetProperty(Rml::PropertyId::Display, Rml::Style::Display::Block);
-            Rml::String innerRML = "GameCube • ";
-            innerRML += state.activeDiscInfo.isPal ? "EUR" : "USA";
-            mDiscDetail->SetInnerRML(innerRML);
+            Rml::String innerRML = "";
+
+            switch (state.activeDiscInfo.platform) {
+            case iso::Platform::Unknown:
+                innerRML += "Unknown";
+                break;
+            case iso::Platform::GameCube:
+                innerRML += "GameCube";
+                break;
+            case iso::Platform::Wii:
+                innerRML += "Wii";
+                break;
+            }
+
+            innerRML += " • ";
+
+            switch (state.activeDiscInfo.region) {
+            case iso::Region::Japan:
+                innerRML += "JPN";
+                break;
+            case iso::Region::Europe:
+                innerRML += "EUR";
+                break;
+            case iso::Region::NorthAmerica:
+                innerRML += "USA";
+                if (state.activeDiscInfo.platform == iso::Platform::Wii) {
+                    innerRML += fmt::format(" Rev. {}", state.activeDiscInfo.revision);
+                }
+                break;
+            case iso::Region::Korea:
+                innerRML += "KOR";
+                break;
+            default:
+                innerRML += "Unknown";
+                break;
+            }
+            set_text_content(mDiscDetail, innerRML);
         } else {
             mDiscDetail->SetProperty(Rml::PropertyId::Display, Rml::Style::Display::None);
         }
     }
     if (mVersion != nullptr) {
-        std::string_view versionStr(DUSK_WC_DESCRIBE);
+        std::string_view versionStr(BOREALIS_APP_DESCRIBE);
         if (versionStr[0] == 'v') {
             versionStr = versionStr.substr(1);
         }
-        mVersion->SetInnerRML(escape(versionStr));
+        set_text_content(mVersion, Rml::String{versionStr});
     }
     if (mUpdateStatus != nullptr && mUpdateMessage != nullptr) {
         if (auto result = take_finished_update_check()) {
-            if (result->status == update_check::Status::Failed) {
+            if (result->status == borealis::update::Status::Failed) {
                 PrelaunchLog.error("Failed to check for updates: {}", result->message);
             }
             sUpdateCheckResult = std::move(*result);
         }
 
-        if (sUpdateCheckTask != nullptr) {
+        if (sUpdateCheck) {
             mUpdateStatus->SetAttribute("state", "checking");
-            mUpdateMessage->SetInnerRML("Checking for updates...");
+            set_text_content(mUpdateMessage, "Checking for updates...");
         } else if (!sUpdateCheckResult.has_value() ||
-                   sUpdateCheckResult->status == update_check::Status::UpToDate)
+                   sUpdateCheckResult->status == borealis::update::Status::UpToDate)
         {
             mUpdateStatus->RemoveAttribute("state");
-            mUpdateMessage->SetInnerRML("");
-        } else if (sUpdateCheckResult->status == update_check::Status::UpdateAvailable) {
+            set_text_content(mUpdateMessage, "");
+        } else if (sUpdateCheckResult->status == borealis::update::Status::UpdateAvailable) {
             mUpdateStatus->SetAttribute("state", "available");
-            mUpdateMessage->SetInnerRML("Update available!");
+            set_text_content(mUpdateMessage, "Update available!");
             if (mUpdateDownloadLabel != nullptr) {
-                mUpdateDownloadLabel->SetInnerRML(escape(
-                    fmt::format("Download {}", update_release_label(sUpdateCheckResult->latest))));
+                set_text_content(mUpdateDownloadLabel,
+                    fmt::format("Download {}", update_release_label(sUpdateCheckResult->latest)));
             }
         } else {
             mUpdateStatus->SetAttribute("state", "failed");
-            mUpdateMessage->SetInnerRML("Failed to check for updates");
+            set_text_content(mUpdateMessage, "Failed to check for updates");
         }
     }
 
     Document::update();
 }
 
+void return_to_prelaunch() noexcept {
+    close_all_documents();
+    push_document(std::make_unique<Prelaunch>(), true);
+}
+
 bool Prelaunch::focus() {
     if (mMenuButtons.empty()) {
         return false;
diff --git a/src/dusk/ui/prelaunch.hpp b/src/dusk/ui/prelaunch.hpp
index a5be868f36..5f6e2ea2fc 100644
--- a/src/dusk/ui/prelaunch.hpp
+++ b/src/dusk/ui/prelaunch.hpp
@@ -3,6 +3,7 @@
 #include "button.hpp"
 #include "document.hpp"
 #include "dusk/iso_validate.hpp"
+#include "dusk/settings.h"
 
 #include <memory>
 #include <string>
@@ -13,6 +14,7 @@ namespace dusk::ui {
 class Prelaunch : public Document {
 public:
     Prelaunch();
+    void build_menu_buttons();
 
     void show() override;
     void hide(bool close) override;
@@ -21,13 +23,15 @@ public:
     bool visible() const override;
     bool obscures_game() const override { return true; }
 
+    static void refresh_menu_buttons();
+
 protected:
     bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
 
 private:
     bool mEntranceAnimationStarted = false;
     bool mRestartSuppressed = false;
-    std::vector<std::unique_ptr<Button> > mMenuButtons;
+    std::vector<std::unique_ptr<Button>> mMenuButtons;
     Rml::Element* mRoot = nullptr;
     Rml::Element* mDiscStatus = nullptr;
     Rml::Element* mDiscDetail = nullptr;
@@ -42,6 +46,7 @@ class PrelaunchOptions;
 
 struct PrelaunchState {
     bool initialized = false;
+    bool firstLaunch = true;
     std::string configuredDiscPath;
     bool configuredDiscCanLaunch = false;
     iso::DiscInfo configuredDiscInfo{};
@@ -49,19 +54,24 @@ struct PrelaunchState {
     std::string activeDiscPath;
     iso::DiscInfo activeDiscInfo{};
     GameLanguage initialLanguage = GameLanguage::English;
+    GameLanguage unavailableLanguage = GameLanguage::English;
+    bool pendingLanguageUnavailableNotice = false;
     std::string initialGraphicsBackend;
     int initialCardFileType = 0;
     std::string errorString;
     std::string pendingDiscPath;
     iso::DiscInfo pendingDiscInfo{};
     iso::ValidationError pendingDiscValidation = iso::ValidationError::Unknown;
+    bool returnToPrelaunchOnReset = false;
 };
 
 PrelaunchState& prelaunch_state() noexcept;
+void return_to_prelaunch() noexcept;
 void ensure_initialized() noexcept;
 void refresh_configured_disc_state() noexcept;
 void open_iso_picker() noexcept;
 bool is_restart_pending() noexcept;
 void try_push_verification_modal(Document& host);
+void try_push_language_unavailable_modal(Document& host);
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/preset.cpp b/src/dusk/ui/preset.cpp
index 7fc7d956b4..a98e19426a 100644
--- a/src/dusk/ui/preset.cpp
+++ b/src/dusk/ui/preset.cpp
@@ -59,26 +59,20 @@ void applyPresetDusk() {
 
 }  // namespace
 
-PresetWindow::PresetWindow() : WindowSmall("modal", "modal-dialog") {
-    mDialog->SetClass("modal-dialog", true);
+PresetWindow::PresetWindow() : WindowSmall("modal") {
+    auto* header = append(mDialog, "modal-header");
 
-    auto* header = append(mDialog, "div");
-    header->SetClass("modal-header", true);
-
-    auto* title = append(header, "div");
-    title->SetClass("modal-title", true);
-    title->SetInnerRML("Welcome to Dusklight");
+    auto* title = append(header, "modal-title");
+    append_text(title, "Welcome to Dusklight");
 
     auto* headIcon = append(header, "icon");
     headIcon->SetClass("celebration", true);
 
-    auto* intro = append(mDialog, "div");
-    intro->SetClass("modal-body", true);
-    intro->SetInnerRML(
+    auto* intro = append(mDialog, "modal-body");
+    append_text(intro,
         "Choose a preset to get started. You can change any setting later from the Settings menu.");
 
-    auto* grid = append(mDialog, "div");
-    grid->SetClass("preset-grid", true);
+    auto* grid = append(mDialog, "preset-grid");
 
     struct PresetInfo {
         const char* name;
@@ -87,19 +81,22 @@ PresetWindow::PresetWindow() : WindowSmall("modal", "modal-dialog") {
     };
 
     static constexpr PresetInfo kPresets[] = {
-        {"Classic",
-         "Enhancements disabled to match the GameCube version. "
-         "Good for speedrunning or simple nostalgia!",
-         applyPresetClassic},
-        {"Dusklight",
-         "Graphics & quality of life tweaks, including some from the Wii U version. "
-         "Our recommended way to play!",
-         applyPresetDusk},
+        {
+            "Classic",
+            "Enhancements disabled to match the GameCube version. "
+            "Good for speedrunning or simple nostalgia!",
+            applyPresetClassic,
+        },
+        {
+            "Dusklight",
+            "Graphics & quality of life tweaks, including some from the Wii U version. "
+            "Our recommended way to play!",
+            applyPresetDusk,
+        },
     };
 
     for (const auto& preset : kPresets) {
-        auto* col = append(grid, "div");
-        col->SetClass("preset-col", true);
+        auto* col = append(grid, "preset-option");
 
         auto btn = std::make_unique<Button>(col, Rml::String(preset.name));
         btn->on_nav_command([this, apply = preset.apply](Rml::Event&, NavCommand cmd) {
@@ -108,15 +105,15 @@ PresetWindow::PresetWindow() : WindowSmall("modal", "modal-dialog") {
                 getSettings().backend.wasPresetChosen.setValue(true);
                 config::save();
                 hide(true);
+                mDoAud_seStartMenu(kSoundClick);
                 return true;
             }
             return false;
         });
         mButtons.push_back(std::move(btn));
 
-        auto* desc = append(col, "div");
-        desc->SetClass("preset-desc", true);
-        desc->SetInnerRML(preset.desc);
+        auto* desc = append(col, "preset-description");
+        append_text(desc, preset.desc);
     }
 }
 
diff --git a/src/dusk/ui/queue_window.cpp b/src/dusk/ui/queue_window.cpp
new file mode 100644
index 0000000000..28ac34de61
--- /dev/null
+++ b/src/dusk/ui/queue_window.cpp
@@ -0,0 +1,237 @@
+#include "queue_window.hpp"
+
+#include "button.hpp"
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/queue.hpp"
+#include "fmt/format.h"
+#include "format.hpp"
+#include "mod_texture_provider.hpp"
+#include "package_row.hpp"
+#include "pane.hpp"
+#include "remote_texture_provider.hpp"
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace dusk::ui {
+namespace {
+
+void set_icon_button(Button& button, const Rml::String& glyph, const Rml::String& label,
+    Rml::String& currentGlyph, Rml::String& currentLabel) {
+    if (currentGlyph != glyph) {
+        clear_children(button.root());
+        append_text(append(button.root(), "icon"), glyph);
+        currentGlyph = glyph;
+    }
+    if (currentLabel != label) {
+        button.root()->SetAttribute("aria-label", label);
+        button.root()->SetAttribute("title", label);
+        currentLabel = label;
+    }
+}
+
+class QueueRow final : public PackageRow {
+public:
+    QueueRow(Rml::Element* parent, std::string id) : PackageRow{parent}, mId{std::move(id)} {
+        auto* actions = actions_root();
+        auto pause = std::make_unique<Button>(actions, "");
+        mPause = pause.get();
+        mPause->root()->SetClass("icon-action", true);
+        mPause->on_pressed([this] {
+            const auto item = mods::queue::find(mId);
+            if (!item) {
+                return;
+            }
+            switch (item->state) {
+            case mods::queue::State::Paused:
+                mods::queue::resume(mId);
+                break;
+            case mods::queue::State::Failed:
+            case mods::queue::State::InstallFailed:
+                mods::queue::retry(mId);
+                break;
+            default:
+                mods::queue::pause(mId);
+                break;
+            }
+        });
+        mChildren.push_back(std::move(pause));
+
+        auto cancel = std::make_unique<Button>(actions, "");
+        mCancel = cancel.get();
+        mCancel->root()->SetClass("icon-action", true);
+        mCancel->on_pressed([this] {
+            const auto item = mods::queue::find(mId);
+            if (!item) {
+                return;
+            }
+            if (mods::queue::is_terminal(item->state)) {
+                if (item->state == mods::queue::State::InstallFailed) {
+                    auto& loader = mods::ModLoader::instance();
+                    if (const auto* mod = loader.find_mod(item->modId);
+                        mod != nullptr && loader.can_uninstall(*mod))
+                    {
+                        loader.request_uninstall(item->modId);
+                    }
+                }
+                mods::queue::clear(mId);
+                return;
+            }
+            mods::queue::cancel(mId);
+        });
+        set_icon_button(*mCancel, "\uE5CD", "Cancel", mCancelGlyph, mCancelLabel);
+        mChildren.push_back(std::move(cancel));
+        update();
+    }
+
+    void update() override {
+        const auto item = mods::queue::find(mId);
+        if (!item) {
+            mRoot->SetProperty("display", "none");
+            return;
+        }
+        mRoot->SetProperty("display", "flex");
+        const float progress =
+            item->total == 0 ?
+                0.0f :
+                std::clamp(static_cast<float>(item->completed) / static_cast<float>(item->total),
+                    0.0f, 1.0f);
+        std::string detail;
+        if (item->completed != 0 || item->state == mods::queue::State::Downloading ||
+            item->state == mods::queue::State::Paused)
+        {
+            detail =
+                fmt::format("{} / {}", format_bytes(item->completed), format_bytes(item->total));
+        } else {
+            detail = format_bytes(item->total);
+        }
+        if (!item->message.empty() && (item->state == mods::queue::State::Failed ||
+                                          item->state == mods::queue::State::InstallFailed))
+        {
+            detail = item->message;
+        } else if (!item->message.empty()) {
+            detail = fmt::format("{} · {}", detail, item->message);
+        }
+        auto status = state_label(*item);
+        if (item->state == mods::queue::State::Installed) {
+            status.clear();
+            detail = fmt::format("Installed · {}", format_bytes(item->total));
+        }
+        const std::optional<float> progressValue =
+            item->state == mods::queue::State::Installed ||
+                    item->state == mods::queue::State::Canceled ?
+                std::nullopt :
+                std::optional{progress};
+        set_package(item->name, item->version, std::move(status), detail,
+            queue_state_class(item->state), progressValue);
+
+        std::string iconSource;
+        if (item->icon && !item->icon->url.empty()) {
+            iconSource =
+                remote_image_source(item->icon->url, item->icon->width, item->icon->height);
+        } else if (const auto* mod = mods::ModLoader::instance().find_mod(item->modId);
+            mod != nullptr && !mod->metadata.iconPath.empty())
+        {
+            iconSource = mod_image_source(*mod, mod->metadata.iconPath);
+        }
+        set_icon(std::move(iconSource));
+
+        const bool pauseVisible = (!item->local && item->state == mods::queue::State::Queued) ||
+                                  item->state == mods::queue::State::Downloading ||
+                                  item->state == mods::queue::State::Paused ||
+                                  item->state == mods::queue::State::Retrying ||
+                                  item->state == mods::queue::State::Failed ||
+                                  item->state == mods::queue::State::InstallFailed;
+        mPause->root()->SetProperty("display", pauseVisible ? "flex" : "none");
+        if (item->state == mods::queue::State::Paused) {
+            set_icon_button(*mPause, "\uE037", "Resume", mPauseGlyph, mPauseLabel);
+        } else if (item->state == mods::queue::State::Failed ||
+                   item->state == mods::queue::State::InstallFailed)
+        {
+            set_icon_button(*mPause, "\uE5D5", "Retry", mPauseGlyph, mPauseLabel);
+        } else {
+            set_icon_button(*mPause, "\uE034", "Pause", mPauseGlyph, mPauseLabel);
+        }
+
+        mCancel->root()->SetProperty(
+            "display", item->state == mods::queue::State::Handoff ? "none" : "flex");
+        set_icon_button(*mCancel, "\uE5CD",
+            mods::queue::is_terminal(item->state) ? "Clear" : "Cancel", mCancelGlyph, mCancelLabel);
+        Component::update();
+    }
+
+private:
+    std::string mId;
+    Button* mPause = nullptr;
+    Button* mCancel = nullptr;
+    Rml::String mPauseGlyph;
+    Rml::String mPauseLabel;
+    Rml::String mCancelGlyph;
+    Rml::String mCancelLabel;
+};
+
+}  // namespace
+
+QueueWindow::QueueWindow(std::string focusId)
+    : Modal{Props{
+          .title = "Download queue",
+          .actions =
+              {
+                  ModalAction{"Close", [](Modal& modal) { modal.pop(); }, {}},
+                  ModalAction{"Pause all", [](Modal&) { mods::queue::pause_all(); },
+                      [] { return !mods::queue::has_active_items(); }},
+                  ModalAction{"Clear finished", [](Modal&) { mods::queue::clear_finished(); },
+                      [] { return mods::queue::item_count() == mods::queue::active_count(); }},
+              },
+          .variant = "install-queue",
+          .icon = "download",
+      }},
+      mFocusId{std::move(focusId)} {
+    content_pane();
+    refresh_queue();
+}
+
+void QueueWindow::update() {
+    if (!mItemIds.empty() && mods::queue::item_count() == 0) {
+        pop();
+        return;
+    }
+    refresh_queue();
+    Modal::update();
+}
+
+void QueueWindow::refresh_queue() {
+    const auto queueItems = mods::queue::items();
+    std::vector<std::string> ids;
+    ids.reserve(queueItems.size());
+    size_t active = 0;
+    for (const auto& item : queueItems) {
+        ids.push_back(item.id);
+        if (!mods::queue::is_terminal(item.state)) {
+            ++active;
+        }
+    }
+    if (ids != mItemIds) {
+        auto& pane = content_pane();
+        pane.clear();
+        mItemIds = std::move(ids);
+        if (queueItems.empty()) {
+            pane.add_text("No installs.");
+        } else {
+            for (const auto& item : queueItems) {
+                auto& row = pane.add_child<QueueRow>(item.id);
+                if (!mFocusId.empty() && item.id == mFocusId) {
+                    row.focus();
+                    mFocusId.clear();
+                }
+            }
+        }
+    }
+    set_body_text(fmt::format("{} active · {} total", active, queueItems.size()));
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/queue_window.hpp b/src/dusk/ui/queue_window.hpp
new file mode 100644
index 0000000000..8e2a2499b7
--- /dev/null
+++ b/src/dusk/ui/queue_window.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "modal.hpp"
+
+#include <string>
+#include <vector>
+
+namespace dusk::ui {
+
+class QueueWindow final : public Modal {
+public:
+    explicit QueueWindow(std::string focusId = {});
+
+    void update() override;
+
+private:
+    void refresh_queue();
+
+    std::string mFocusId;
+    std::vector<std::string> mItemIds;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/remote_texture_provider.cpp b/src/dusk/ui/remote_texture_provider.cpp
new file mode 100644
index 0000000000..fdff4077ab
--- /dev/null
+++ b/src/dusk/ui/remote_texture_provider.cpp
@@ -0,0 +1,321 @@
+#include "remote_texture_provider.hpp"
+
+#include <fmt/format.h>
+
+namespace dusk::ui {
+
+std::string remote_image_source(std::string_view url, uint32_t width, uint32_t height) {
+    url = url.substr(0, url.find('#'));
+    return fmt::format("{}#size={}x{}", url, width == 0 ? 1 : width, height == 0 ? 1 : height);
+}
+
+}  // namespace dusk::ui
+
+#ifdef AURORA_ENABLE_RMLUI
+
+#include "dusk/app_info.hpp"
+#include "runtime_image.hpp"
+
+#include <RmlUi/Core.h>
+#include <aurora/rmlui.hpp>
+#include <borealis/http.hpp>
+#include <borealis/log.hpp>
+
+#include <algorithm>
+#include <array>
+#include <charconv>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <optional>
+#include <ranges>
+#include <span>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <unordered_map>
+
+namespace dusk::ui {
+namespace {
+
+using namespace std::chrono_literals;
+
+constexpr borealis::Log Log{"dusk::ui"};
+constexpr std::string_view kScheme = "https";
+constexpr std::string_view kAllowedPrefix = "https://staging.twilitrealm.workers.dev/images/v1/";
+constexpr size_t kMaxCachedImages = 64;
+constexpr size_t kMaxCachedImageBytes = 64 * 1024 * 1024;
+constexpr size_t kMaxPendingRequests = 4;
+constexpr size_t kMaxImageFileSize = 16 * 1024 * 1024;
+// RmlUi caches the first texture dimensions in image decorators, so the async
+// placeholder must preserve the final image's aspect ratio.
+constexpr uint32_t kPlaceholderMaxDimension = 256;
+constexpr std::array<std::byte, kPlaceholderMaxDimension * kPlaceholderMaxDimension * 4>
+    kTransparentPixels{};
+
+enum class State {
+    Unrequested,
+    Pending,
+    Ready,
+    Failed,
+};
+
+struct Entry {
+    borealis::Task<borealis::http::Result> request;
+    DecodedImage image;
+    State state = State::Unrequested;
+    uint64_t lastUsed = 0;
+    uint32_t placeholderWidth = 1;
+    uint32_t placeholderHeight = 1;
+};
+
+struct RemoteSource {
+    std::string_view requestUrl;
+    uint32_t placeholderWidth = 1;
+    uint32_t placeholderHeight = 1;
+};
+
+std::unordered_map<std::string, Entry>& image_cache() {
+    static std::unordered_map<std::string, Entry> cache;
+    return cache;
+}
+
+uint64_t& use_counter() {
+    static uint64_t counter = 0;
+    return counter;
+}
+
+RemoteSource parse_remote_source(std::string_view source) noexcept {
+    constexpr std::string_view marker{"#size="};
+    const auto fragment = source.find('#');
+    RemoteSource result{.requestUrl = source.substr(0, fragment)};
+    if (fragment == std::string_view::npos || !source.substr(fragment).starts_with(marker)) {
+        return result;
+    }
+
+    const auto dimensions = source.substr(fragment + marker.size());
+    const auto separator = dimensions.find('x');
+    if (separator == std::string_view::npos) {
+        return result;
+    }
+    uint32_t width = 0;
+    uint32_t height = 0;
+    const auto widthResult =
+        std::from_chars(dimensions.data(), dimensions.data() + separator, width);
+    const auto heightResult = std::from_chars(
+        dimensions.data() + separator + 1, dimensions.data() + dimensions.size(), height);
+    if (widthResult.ec != std::errc{} || widthResult.ptr != dimensions.data() + separator ||
+        heightResult.ec != std::errc{} ||
+        heightResult.ptr != dimensions.data() + dimensions.size() || width == 0 || height == 0)
+    {
+        return result;
+    }
+
+    const auto maxDimension = std::max(width, height);
+    if (maxDimension > kPlaceholderMaxDimension) {
+        width = std::max(
+            1u, static_cast<uint32_t>(
+                    (static_cast<uint64_t>(width) * kPlaceholderMaxDimension + maxDimension / 2) /
+                    maxDimension));
+        height = std::max(
+            1u, static_cast<uint32_t>(
+                    (static_cast<uint64_t>(height) * kPlaceholderMaxDimension + maxDimension / 2) /
+                    maxDimension));
+    }
+    result.placeholderWidth = width;
+    result.placeholderHeight = height;
+    return result;
+}
+
+bool make_cache_room(size_t incomingBytes = 0, bool addingEntry = true) {
+    auto& cache = image_cache();
+    size_t cachedBytes = 0;
+    for (const auto& [source, entry] : cache) {
+        cachedBytes += entry.image.pixels.size();
+    }
+    if (incomingBytes > kMaxCachedImageBytes) {
+        return false;
+    }
+    while (cachedBytes > kMaxCachedImageBytes - incomingBytes ||
+           (addingEntry && cache.size() >= kMaxCachedImages))
+    {
+        const auto victim = std::ranges::min_element(cache, {}, [](const auto& pair) {
+            return pair.second.state == State::Pending ? std::numeric_limits<uint64_t>::max() :
+                                                         pair.second.lastUsed;
+        });
+        if (victim == cache.end() || victim->second.state == State::Pending) {
+            return false;
+        }
+        cachedBytes -= victim->second.image.pixels.size();
+        Rml::ReleaseTexture(victim->first);
+        cache.erase(victim);
+    }
+    return true;
+}
+
+aurora::rmlui::RuntimeTexture transparent_texture(const Entry& entry) {
+    const auto size = static_cast<size_t>(entry.placeholderWidth) *
+                      static_cast<size_t>(entry.placeholderHeight) * 4;
+    return {
+        .width = entry.placeholderWidth,
+        .height = entry.placeholderHeight,
+        .rgba8 = std::span{kTransparentPixels}.first(size),
+        .premultipliedAlpha = true,
+    };
+}
+
+borealis::Task<borealis::http::Result> start_request(std::string source) {
+    return borealis::http::start({
+        .url = std::move(source),
+        .headers =
+            {
+                {.name = "User-Agent", .value = borealis::user_agent(dusk::AppInfo)},
+                {.name = "Accept", .value = "image/png"},
+            },
+        .connectTimeout = 10s,
+        .idleTimeout = 10s,
+        .totalTimeout = 30s,
+        .maxBodyBytes = kMaxImageFileSize,
+    });
+}
+
+std::optional<aurora::rmlui::RuntimeTexture> remote_texture_provider(std::string_view source) {
+    const auto parsed = parse_remote_source(source);
+    if (!parsed.requestUrl.starts_with(kAllowedPrefix)) {
+        return std::nullopt;
+    }
+
+    auto& cache = image_cache();
+    const std::string key{source};
+    auto iter = cache.find(key);
+    if (iter == cache.end()) {
+        if (!make_cache_room()) {
+            Log.warn("Remote image cache is full; skipping '{}'", source);
+            return transparent_texture(Entry{
+                .placeholderWidth = parsed.placeholderWidth,
+                .placeholderHeight = parsed.placeholderHeight,
+            });
+        }
+        iter = cache
+                   .emplace(key,
+                       Entry{
+                           .placeholderWidth = parsed.placeholderWidth,
+                           .placeholderHeight = parsed.placeholderHeight,
+                       })
+                   .first;
+    }
+    iter->second.lastUsed = ++use_counter();
+    if (iter->second.state != State::Ready) {
+        return transparent_texture(iter->second);
+    }
+
+    const auto& image = iter->second.image;
+    return aurora::rmlui::RuntimeTexture{
+        .width = image.width,
+        .height = image.height,
+        .rgba8 =
+            std::span{reinterpret_cast<const std::byte*>(image.pixels.data()), image.pixels.size()},
+        .premultipliedAlpha = true,
+    };
+}
+
+void finish_request(const std::string& source, Entry& entry, borealis::http::Result result) {
+    if (result.error != borealis::http::Error::None) {
+        entry.state = State::Failed;
+        Log.warn("Failed to fetch image '{}': {}", source, result.message);
+        return;
+    }
+    if (result.response.statusCode != 200) {
+        entry.state = State::Failed;
+        Log.warn("Image '{}' returned HTTP {}", source, result.response.statusCode);
+        return;
+    }
+    const auto* data = reinterpret_cast<const uint8_t*>(result.response.body.data());
+    auto image = decode_png(std::span{data, result.response.body.size()}, source);
+    if (!image) {
+        entry.state = State::Failed;
+        return;
+    }
+    if (!make_cache_room(image->pixels.size(), false)) {
+        entry.state = State::Failed;
+        Log.warn("Image '{}' exceeds the decoded image cache budget", source);
+        return;
+    }
+    entry.image = std::move(*image);
+    entry.state = State::Ready;
+
+    // RmlUi cached the transparent placeholder while the request was in flight.
+    Rml::ReleaseTexture(source);
+}
+
+}  // namespace
+
+void register_remote_texture_provider() noexcept {
+    aurora::rmlui::register_texture_provider(std::string{kScheme}, remote_texture_provider);
+}
+
+void unregister_remote_texture_provider() noexcept {
+    aurora::rmlui::unregister_texture_provider(kScheme);
+    for (auto& [source, entry] : image_cache()) {
+        entry.request.cancel();
+        Rml::ReleaseTexture(source);
+    }
+    image_cache().clear();
+    use_counter() = 0;
+}
+
+void update_remote_texture_provider() noexcept {
+    for (auto& [source, entry] : image_cache()) {
+        if (entry.state != State::Pending || !entry.request.ready()) {
+            continue;
+        }
+        try {
+            if (auto result = entry.request.try_take()) {
+                finish_request(source, entry, std::move(*result));
+            }
+        } catch (const std::exception& exception) {
+            entry.state = State::Failed;
+            Log.warn("Failed to fetch image '{}': {}", source, exception.what());
+        } catch (...) {
+            entry.state = State::Failed;
+            Log.warn("Failed to fetch image '{}'", source);
+        }
+        entry.request = {};
+    }
+
+    size_t pending = std::ranges::count_if(
+        image_cache(), [](const auto& pair) { return pair.second.state == State::Pending; });
+    for (auto& [source, entry] : image_cache()) {
+        if (pending >= kMaxPendingRequests) {
+            break;
+        }
+        if (entry.state == State::Unrequested) {
+            try {
+                entry.request = start_request(std::string{parse_remote_source(source).requestUrl});
+                entry.state = State::Pending;
+                ++pending;
+            } catch (const std::exception& exception) {
+                entry.state = State::Failed;
+                Log.warn("Failed to request image '{}': {}", source, exception.what());
+            } catch (...) {
+                entry.state = State::Failed;
+                Log.warn("Failed to request image '{}'", source);
+            }
+        }
+    }
+}
+
+}  // namespace dusk::ui
+
+#else
+
+namespace dusk::ui {
+
+void register_remote_texture_provider() noexcept {}
+void unregister_remote_texture_provider() noexcept {}
+void update_remote_texture_provider() noexcept {}
+
+}  // namespace dusk::ui
+
+#endif
diff --git a/src/dusk/ui/remote_texture_provider.hpp b/src/dusk/ui/remote_texture_provider.hpp
new file mode 100644
index 0000000000..21ceb1162b
--- /dev/null
+++ b/src/dusk/ui/remote_texture_provider.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+namespace dusk::ui {
+
+[[nodiscard]] std::string remote_image_source(
+    std::string_view url, uint32_t width, uint32_t height);
+
+void register_remote_texture_provider() noexcept;
+void unregister_remote_texture_provider() noexcept;
+void update_remote_texture_provider() noexcept;
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/reporting.cpp b/src/dusk/ui/reporting.cpp
index 98862d8ed5..5fa821482e 100644
--- a/src/dusk/ui/reporting.cpp
+++ b/src/dusk/ui/reporting.cpp
@@ -1,39 +1,45 @@
-#if DUSK_ENABLE_SENTRY_NATIVE
+#if BOREALIS_HAS_SENTRY
 
 #include "reporting.hpp"
 
 #include "button.hpp"
-#include "dusk/crash_reporting.h"
 #include "ui.hpp"
 
+#include <borealis/sentry.hpp>
 #include <dolphin/gx/GXAurora.h>
 
 namespace dusk::ui {
 
-CrashReportWindow::CrashReportWindow() : WindowSmall("modal", "modal-dialog") {
-    mDialog->SetClass("modal-dialog", true);
+CrashReportWindow::CrashReportWindow() : WindowSmall("modal") {
+    auto* header = append(mDialog, "modal-header");
 
-    auto* header = append(mDialog, "div");
-    header->SetClass("modal-header", true);
-
-    auto* title = append(header, "div");
-    title->SetClass("modal-title", true);
-    title->SetInnerRML("Send Crash Reports");
+    auto* title = append(header, "modal-title");
+    append_text(title, "Send Crash Reports");
 
     auto* headIcon = append(header, "icon");
     headIcon->SetClass("question-mark", true);
 
-    auto* intro = append(mDialog, "div");
-    intro->SetClass("modal-body", true);
-    intro->SetInnerRML(
-        "Dusklight can automatically send crash reports to the developers. Crash reports contain the "
-        "following:"
-        "<br/>• Operating system version<br/>• CPU architecture<br/>• GPU model & driver version"
-        "<br/>• File paths (may include account username)<br/>• Stack trace<br/><br/>"
-        "This can be changed in the Settings menu at any time.");
+    auto* intro = append(mDialog, "modal-body");
+    append_text(intro,
+        "Dusklight can automatically send crash reports to the developers. Crash reports contain "
+        "the following:");
+    for (const char* item :
+        {
+            "• Operating system version",
+            "• CPU architecture",
+            "• GPU model & driver version",
+            "• File paths (may include account username)",
+            "• Stack trace",
+        })
+    {
+        append(intro, "br");
+        append_text(intro, item);
+    }
+    append(intro, "br");
+    append(intro, "br");
+    append_text(intro, "This can be changed in the Settings menu at any time.");
 
-    auto* grid = append(mDialog, "div");
-    grid->SetClass("preset-grid", true);
+    auto* grid = append(mDialog, "preset-grid");
 
     struct OptionInfo {
         const char* name;
@@ -43,33 +49,32 @@ CrashReportWindow::CrashReportWindow() : WindowSmall("modal", "modal-dialog") {
 
     static constexpr OptionInfo kOptions[] = {
         {"Enable",
-            "Send crash reports to Dusklight developers. Reports will include the information described "
-            "above.",
-            [] { crash_reporting::set_consent(true); }},
+            "Send crash reports to Dusklight developers. Reports will include the information "
+            "described above.",
+            [] { borealis::sentry::set_consent(true); }},
         {"Disable",
             "Do not send crash reports. This may make it more difficult to resolve issues you "
             "encounter.",
-            [] { crash_reporting::set_consent(false); }},
+            [] { borealis::sentry::set_consent(false); }},
     };
 
     for (const auto& option : kOptions) {
-        auto* col = append(grid, "div");
-        col->SetClass("preset-col", true);
+        auto* col = append(grid, "preset-option");
 
         auto btn = std::make_unique<Button>(col, Rml::String(option.name));
         btn->on_nav_command([this, apply = option.apply](Rml::Event&, NavCommand cmd) {
             if (cmd == NavCommand::Confirm) {
                 apply();
                 hide(true);
+                mDoAud_seStartMenu(kSoundClick);
                 return true;
             }
             return false;
         });
         mButtons.push_back(std::move(btn));
 
-        auto* desc = append(col, "div");
-        desc->SetClass("preset-desc", true);
-        desc->SetInnerRML(option.desc);
+        auto* desc = append(col, "preset-description");
+        append_text(desc, option.desc);
     }
 }
 
diff --git a/src/dusk/ui/reporting.hpp b/src/dusk/ui/reporting.hpp
index 758831f09e..926f286e2f 100644
--- a/src/dusk/ui/reporting.hpp
+++ b/src/dusk/ui/reporting.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#if DUSK_ENABLE_SENTRY_NATIVE
+#if BOREALIS_HAS_SENTRY
 
 #include "component.hpp"
 #include "window.hpp"
diff --git a/src/dusk/ui/runtime_image.cpp b/src/dusk/ui/runtime_image.cpp
new file mode 100644
index 0000000000..25ef6f358d
--- /dev/null
+++ b/src/dusk/ui/runtime_image.cpp
@@ -0,0 +1,52 @@
+#include "runtime_image.hpp"
+
+#include <borealis/log.hpp>
+#include <png.h>
+
+#include <cstddef>
+#include <memory>
+
+namespace dusk::ui {
+namespace {
+
+constexpr borealis::Log Log{"dusk::ui"};
+constexpr uint32_t kMaxImageDimension = 4096;
+
+}  // namespace
+
+std::optional<DecodedImage> decode_png(std::span<const uint8_t> data, std::string_view source) {
+    png_image png{};
+    png.version = PNG_IMAGE_VERSION;
+    const std::unique_ptr<png_image, decltype(&png_image_free)> cleanup{&png, png_image_free};
+    if (!png_image_begin_read_from_memory(&png, data.data(), data.size())) {
+        Log.warn("Failed to read image header '{}': {}", source, png.message);
+        return std::nullopt;
+    }
+    if (png.width == 0 || png.height == 0 || png.width > kMaxImageDimension ||
+        png.height > kMaxImageDimension)
+    {
+        Log.warn("Image '{}' has unsupported dimensions {}x{}", source, png.width, png.height);
+        return std::nullopt;
+    }
+
+    png.format = PNG_FORMAT_RGBA;
+    DecodedImage image{
+        .width = png.width,
+        .height = png.height,
+    };
+    image.pixels.resize(PNG_IMAGE_SIZE(png));
+    if (!png_image_finish_read(&png, nullptr, image.pixels.data(), 0, nullptr)) {
+        Log.warn("Failed to decode image '{}': {}", source, png.message);
+        return std::nullopt;
+    }
+    for (size_t offset = 0; offset < image.pixels.size(); offset += 4) {
+        const uint8_t alpha = image.pixels[offset + 3];
+        for (size_t channel = 0; channel < 3; ++channel) {
+            image.pixels[offset + channel] = static_cast<uint8_t>(
+                (static_cast<uint32_t>(image.pixels[offset + channel]) * alpha) / 255);
+        }
+    }
+    return image;
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/runtime_image.hpp b/src/dusk/ui/runtime_image.hpp
new file mode 100644
index 0000000000..9d52eba65d
--- /dev/null
+++ b/src/dusk/ui/runtime_image.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <span>
+#include <string_view>
+#include <vector>
+
+namespace dusk::ui {
+
+struct DecodedImage {
+    std::vector<uint8_t> pixels;
+    uint32_t width = 0;
+    uint32_t height = 0;
+};
+
+std::optional<DecodedImage> decode_png(std::span<const uint8_t> data, std::string_view source);
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/select_button.cpp b/src/dusk/ui/select_button.cpp
index 313594836e..68225faec8 100644
--- a/src/dusk/ui/select_button.cpp
+++ b/src/dusk/ui/select_button.cpp
@@ -2,7 +2,6 @@
 
 #include "ui.hpp"
 
-#include <fmt/format.h>
 #include <utility>
 
 namespace dusk::ui {
@@ -14,6 +13,10 @@ Rml::Element* createRoot(Rml::Element* parent) {
     return parent->AppendChild(std::move(elem));
 }
 
+Rml::String value_label(const Rml::String& value, bool modified) {
+    return modified ? Rml::String{"•\u00a0"} + value : value;
+}
+
 }  // namespace
 
 SelectButton::SelectButton(Rml::Element* parent, Props props)
@@ -32,22 +35,14 @@ bool SelectButton::modified() const {
 void SelectButton::set_modified(bool value) {
     if (mProps.modified != value) {
         mValueElem->SetClass("modified", value);
-        if (value) {
-            mValueElem->SetInnerRML(fmt::format("•&nbsp;{}", escape(mProps.value)));
-        } else {
-            mValueElem->SetInnerRML(escape(mProps.value));
-        }
+        set_text_content(mValueElem, value_label(mProps.value, value));
         mProps.modified = value;
     }
 }
 
 void SelectButton::set_value_label(const Rml::String& value) {
     if (mProps.value != value) {
-        if (mProps.modified) {
-            mValueElem->SetInnerRML(fmt::format("•&nbsp;{}", escape(value)));
-        } else {
-            mValueElem->SetInnerRML(escape(value));
-        }
+        set_text_content(mValueElem, value_label(value, mProps.modified));
         mProps.value = value;
     }
 }
@@ -67,7 +62,7 @@ SelectButton& SelectButton::on_pressed(SelectButtonCallback callback) {
 
 void SelectButton::update_props(Props props) {
     if (mProps.key != props.key) {
-        mKeyElem->SetInnerRML(escape(props.key));
+        set_text_content(mKeyElem, props.key);
     }
     if (mProps.icon != props.icon) {
         Rml::StringList iconClasses;
diff --git a/src/dusk/ui/settings.cpp b/src/dusk/ui/settings.cpp
index 1b06b782f0..4d9b8f651d 100644
--- a/src/dusk/ui/settings.cpp
+++ b/src/dusk/ui/settings.cpp
@@ -1,38 +1,38 @@
 #include "settings.hpp"
 
-#include "aurora/gfx.h"
 #include "bool_button.hpp"
 #include "controller_config.hpp"
-#include "dusk/app_info.hpp"
-#include "dusk/audio/DuskAudioSystem.h"
-#include "dusk/audio/DuskDsp.hpp"
-#include "dusk/android_frame_rate.hpp"
-#include "dusk/config.hpp"
-#include "dusk/hotkeys.h"
-#include "dusk/data.hpp"
-#include "dusk/file_select.hpp"
-#include "dusk/imgui/ImGuiEngine.hpp"
-#include "dusk/io.hpp"
-#include "dusk/livesplit.h"
-#include "dusk/discord_presence.hpp"
 #include "graphics_tuner.hpp"
-#include "m_Do/m_Do_main.h"
 #include "menu_bar.hpp"
 #include "modal.hpp"
 #include "number_button.hpp"
-#include "menu_bar.hpp"
 #include "pane.hpp"
 #include "prelaunch.hpp"
 #include "touch_controls_editor.hpp"
 #include "ui.hpp"
 
-#include <aurora/lib/window.hpp>
-#include <SDL3/SDL_filesystem.h>
-#include <fmt/format.h>
+#include "dusk/app_info.hpp"
+#include "dusk/audio/DuskAudioSystem.h"
+#include "dusk/audio/DuskDsp.hpp"
+#include "dusk/config.hpp"
+#include "dusk/data.hpp"
+#include "dusk/discord_presence.hpp"
+#include "dusk/hotkeys.h"
+#include "dusk/imgui/ImGuiEngine.hpp"
+#include "dusk/language.hpp"
+#include "dusk/livesplit.h"
+#include "dusk/presentation.hpp"
+#include "dusk/speedrun.h"
 
-#if DUSK_ENABLE_SENTRY_NATIVE
-#include "dusk/crash_reporting.h"
+#include <aurora/gfx.h>
+#include <aurora/lib/window.hpp>
+#include <borealis/file_select.hpp>
+#include <borealis/io.hpp>
+#if BOREALIS_HAS_SENTRY
+#include <borealis/sentry.hpp>
 #endif
+#include <fmt/format.h>
+#include <SDL3/SDL_filesystem.h>
 
 #include <algorithm>
 #include <filesystem>
@@ -41,7 +41,7 @@
 #include <TargetConditionals.h>
 #endif
 
-#if defined(TARGET_ANDROID) || defined(__ANDROID__) || \
+#if defined(TARGET_ANDROID) || defined(__ANDROID__) ||                                             \
     (defined(__APPLE__) && TARGET_OS_IOS && !TARGET_OS_MACCATALYST)
 #define TOUCH_CONTROLS_AVAILABLE true
 #else
@@ -51,14 +51,6 @@
 namespace dusk::ui {
 namespace {
 
-constexpr std::array kLanguageNames = {
-    "English",
-    "German",
-    "French",
-    "Spanish",
-    "Italian",
-};
-
 constexpr std::array kCardFileTypes = {
     "Card Image",
     "GCI Folder",
@@ -77,6 +69,13 @@ constexpr std::array kInterpolationModes = {
     "Unlimited",
 };
 
+constexpr std::array kAudioOutputModeNames = {
+    "Stereo (Speakers)",
+    "Stereo (Headphones)",
+    "5.1 Surround",
+    "7.1 Surround",
+};
+
 constexpr std::array kTouchTargetingLabels = {
     "Hybrid",
     "Hold",
@@ -218,106 +217,25 @@ AuroraBackend configured_backend() {
     return configuredBackend;
 }
 
-void reset_for_speedrun_mode() {
-    mDoMain::developmentMode = -1;
-
-    getSettings().game.enableTurboKeybind.setSpeedrunValue(false);
-
-    getSettings().game.damageMultiplier.setSpeedrunValue(1);
-    getSettings().game.instantDeath.setSpeedrunValue(false);
-    getSettings().game.noHeartDrops.setSpeedrunValue(false);
-    getSettings().game.autoSave.setSpeedrunValue(false);
-    getSettings().game.sunsSong.setSpeedrunValue(false);
-
-    getSettings().game.infiniteHearts.setSpeedrunValue(false);
-    getSettings().game.infiniteArrows.setSpeedrunValue(false);
-    getSettings().game.infiniteSeeds.setSpeedrunValue(false);
-    getSettings().game.infiniteBombs.setSpeedrunValue(false);
-    getSettings().game.infiniteOil.setSpeedrunValue(false);
-    getSettings().game.infiniteOxygen.setSpeedrunValue(false);
-    getSettings().game.infiniteRupees.setSpeedrunValue(false);
-    getSettings().game.enableIndefiniteItemDrops.setSpeedrunValue(false);
-    getSettings().game.moonJump.setSpeedrunValue(false);
-    getSettings().game.superClawshot.setSpeedrunValue(false);
-    getSettings().game.alwaysGreatspin.setSpeedrunValue(false);
-    getSettings().game.enableFastIronBoots.setSpeedrunValue(false);
-    getSettings().game.canTransformAnywhere.setSpeedrunValue(false);
-    getSettings().game.fastRoll.setSpeedrunValue(false);
-    getSettings().game.fastSpinner.setSpeedrunValue(false);
-    getSettings().game.armorRupeeDrain.setSpeedrunValue(MagicArmorMode::NORMAL);
-    getSettings().game.invincibleEnemies.setSpeedrunValue(false);
-
-    getSettings().game.pauseOnFocusLost.setSpeedrunValue(false);
-
-    getSettings().backend.enableAdvancedSettings.setSpeedrunValue(false);
-    getSettings().game.recordingMode.setSpeedrunValue(false);
-    getSettings().game.debugFlyCam.setSpeedrunValue(false);
+bool is_graphics_backend_restart_pending() {
+    return getSettings().backend.graphicsBackend.getValue() !=
+           prelaunch_state().initialGraphicsBackend;
 }
 
-void clear_speedrun_overrides() {
-    config::EnumerateRegistered([](config::ConfigVarBase& cvar) {
-        cvar.clearSpeedrunOverride();
-    });
-}
-
-void restore_from_speedrun_mode() {
-    clear_speedrun_overrides();
-}
-
-std::filesystem::path normalized_display_path(const std::filesystem::path& path) {
-    std::error_code ec;
-    auto normalized = std::filesystem::weakly_canonical(path, ec);
-    if (!ec) {
-        return normalized;
+Rml::String graphics_backend_display_name() {
+    if (is_graphics_backend_restart_pending()) {
+        return Rml::String{backend_name(configured_backend())};
     }
-
-    normalized = std::filesystem::absolute(path, ec);
-    if (!ec) {
-        return normalized.lexically_normal();
-    }
-
-    return path.lexically_normal();
-}
-
-std::filesystem::path user_home_path() {
-    const char* homePath = SDL_GetUserFolder(SDL_FOLDER_HOME);
-    if (homePath == nullptr || homePath[0] == '\0') {
-        return {};
-    }
-    return std::filesystem::path{reinterpret_cast<const char8_t*>(homePath)};
-}
-
-Rml::String abbreviated_data_path_string() {
-    const auto path = data::configured_data_path();
-    const auto homePath = user_home_path();
-    if (path.empty() || homePath.empty()) {
-        return io::fs_path_to_string(path);
-    }
-
-    const auto normalizedPath = normalized_display_path(path);
-    const auto normalizedHome = normalized_display_path(homePath);
-    if (normalizedPath == normalizedHome) {
-        return "~";
-    }
-
-    const auto relativePath = normalizedPath.lexically_relative(normalizedHome);
-    if (!relativePath.empty() && !relativePath.is_absolute()) {
-        const auto it = relativePath.begin();
-        if (it == relativePath.end() || *it != "..") {
-            return io::fs_path_to_string(std::filesystem::path{"~"} / relativePath);
-        }
-    }
-
-    return io::fs_path_to_string(path);
+    return Rml::String{backend_name(aurora_get_backend())};
 }
 
 Rml::String configured_data_path_display_name() {
-    const auto path = abbreviated_data_path_string();
+    const auto path = data::abbreviated_path_string(data::configured_data_path());
     if (path.empty()) {
         return "(none)";
     }
 
-    auto display = display_name_for_path(path);
+    auto display = borealis::io::display_name(path);
     if (display.empty()) {
         return path;
     }
@@ -326,20 +244,26 @@ Rml::String configured_data_path_display_name() {
 
 class DataFolderPathText : public Component {
 public:
-    explicit DataFolderPathText(Rml::Element* parent) : Component(append(parent, "div")) {}
+    explicit DataFolderPathText(Rml::Element* parent)
+        : Component(append(parent, "data-folder-path")) {
+        auto* current = append(mRoot, "data-folder-current");
+        append_text(current, "Current data folder:");
+        append(current, "br");
+        mPath = append(current, "data-folder-value");
+    }
 
     void update() override {
-        const Rml::String rml = "<span class=\"data-folder-current\">Current data folder:<br/>" +
-                                escape(abbreviated_data_path_string()) + "</span>";
-        if (rml != mCurrentRml) {
-            mRoot->SetInnerRML(rml);
-            mCurrentRml = rml;
+        const Rml::String path = data::abbreviated_path_string(data::configured_data_path());
+        if (path != mCurrentPath) {
+            set_text_content(mPath, path);
+            mCurrentPath = path;
         }
         Component::update();
     }
 
 private:
-    Rml::String mCurrentRml;
+    Rml::Element* mPath = nullptr;
+    Rml::String mCurrentPath;
 };
 
 void show_data_folder_error_modal(std::string_view message) {
@@ -349,7 +273,7 @@ void show_data_folder_error_modal(std::string_view message) {
     };
     push_document(std::make_unique<Modal>(Modal::Props{
         .title = "Data Folder Not Changed",
-        .bodyRml = escape(message),
+        .bodyText = Rml::String{message},
         .actions =
             {
                 ModalAction{
@@ -365,17 +289,17 @@ void show_data_folder_error_modal(std::string_view message) {
     }
 }
 
-void data_folder_dialog_callback(void*, const char* path, const char* error) {
-    if (error != nullptr) {
-        show_data_folder_error_modal(error);
+void data_folder_dialog_callback(borealis::file_select::Result result) {
+    if (result.status == borealis::file_select::Status::Canceled) {
         return;
     }
-    if (path == nullptr) {
+    if (result.status != borealis::file_select::Status::Selected || result.locations.empty()) {
+        show_data_folder_error_modal("Dusklight could not open the folder picker.");
         return;
     }
 
     std::string dataPathError;
-    if (data::set_custom_data_path(path, &dataPathError)) {
+    if (data::set_custom_data_path(result.locations.front(), &dataPathError)) {
         mDoAud_seStartMenu(kSoundItemChange);
         return;
     }
@@ -418,7 +342,7 @@ bool gyro_enabled() {
 }
 
 Rml::String touch_targeting_label(TouchTargeting targeting) {
-    const auto index = static_cast<std::size_t>(targeting);
+    const auto index = static_cast<size_t>(targeting);
     if (index >= kTouchTargetingLabels.size()) {
         return "Unknown";
     }
@@ -466,7 +390,7 @@ void add_speedrun_disabled_option(Pane& leftPane, Pane& rightPane, ConfigVar<boo
     config_bool_select(leftPane, rightPane, var, {
         .key = key,
         .helpText = helpText,
-        .isDisabled = [] { return getSettings().game.speedrunMode.getValue(); },
+        .isDisabled = [] { return speedrun::isActive(); },
     });
 }
 
@@ -525,24 +449,15 @@ SelectButton& config_int_select(Pane& leftPane, Pane& rightPane, ConfigVar<int>&
     return button;
 }
 
-template <typename T>
-void graphics_tuner_control(Window& window, Pane& leftPane, Pane& rightPane, ConfigVar<T>& var,
+void graphics_tuner_control(Window& window, Pane& leftPane, Pane& rightPane,
     const GraphicsTunerProps& props) {
+    const auto setting = GraphicsSetting::of(props.option);
     leftPane.register_control(
         leftPane
             .add_select_button({
                 .key = props.title,
-                .getValue =
-                    [&var, option = props.option] {
-                        if constexpr (std::is_same_v<T, float>) {
-                            return format_graphics_setting_value(
-                                option, float_setting_percent(var));
-                        } else {
-                            return format_graphics_setting_value(
-                                option, static_cast<int>(var.getValue()));
-                        }
-                    },
-                .isModified = [&var] { return var.getValue() != var.getDefaultValue(); },
+                .getValue = [setting] { return setting.text(); },
+                .isModified = [setting] { return setting.isModified(); },
                 .submit = false,
             })
             .on_nav_command([&window, props](Rml::Event&, NavCommand cmd) {
@@ -578,7 +493,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                                 if (path.empty()) {
                                     display = "(none)";
                                 } else {
-                                    display = display_name_for_path(path);
+                                    display = borealis::io::display_name(path);
                                     if (display.empty()) {
                                         display = path;
                                     }
@@ -597,66 +512,71 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                     pane.add_rml("Set the disc image that Dusklight uses to launch the game.<br/><br/>"
                                  "Changes require a restart.");
                 });
-#if DUSK_CAN_CHANGE_DATA_FOLDER
-            leftPane.register_control(
-                leftPane.add_select_button({
-                    .key = "Data Folder",
-                    .getValue = [] { return configured_data_path_display_name(); },
-                    .isModified = [] { return data::is_data_path_restart_pending(); },
-                }),
-                rightPane, [](Pane& pane) {
-                    pane.add_text("The data folder is where Dusklight stores settings, saves, "
-                                  "logs, texture replacements, and other app data.");
-                    pane.add_child<DataFolderPathText>();
+            if (data::manager().capabilities().canChangeLocation &&
+                borealis::file_select::capabilities().canOpenFolder)
+            {
+                leftPane.register_control(
+                    leftPane.add_select_button({
+                        .key = "Data Folder",
+                        .getValue = [] { return configured_data_path_display_name(); },
+                        .isModified = [] { return data::is_data_path_restart_pending(); },
+                    }),
+                    rightPane, [](Pane& pane) {
+                        pane.add_text("The data folder is where Dusklight stores settings, saves, "
+                                      "logs, texture replacements, and other app data.");
+                        pane.add_child<DataFolderPathText>();
 #if DUSK_CAN_OPEN_DATA_FOLDER
-                    pane.add_button("Open Data Folder").on_pressed([] {
-                        if (data::open_data_path()) {
-                            mDoAud_seStartMenu(kSoundClick);
-                        }
-                    });
+                        pane.add_button("Open Data Folder").on_pressed([] {
+                            if (data::open_data_path()) {
+                                mDoAud_seStartMenu(kSoundClick);
+                            }
+                        });
 #endif
-                    pane.add_button("Change Data Folder").on_pressed([] {
-                        const auto defaultLocation =
-                            io::fs_path_to_string(data::configured_data_path());
-                        ShowFolderSelect(&data_folder_dialog_callback, nullptr,
-                            aurora::window::get_sdl_window(),
-                            defaultLocation.empty() ? nullptr : defaultLocation.c_str());
-                    });
+                        pane.add_button("Change Data Folder").on_pressed([] {
+                            const auto defaultLocation =
+                                borealis::io::fs_path_to_string(data::configured_data_path());
+                            borealis::file_select::open_folder(
+                                {
+                                    .parentWindow = aurora::window::get_sdl_window(),
+                                    .defaultLocation = defaultLocation,
+                                    .requireRealPath = true,
+                                },
+                                &data_folder_dialog_callback);
+                        });
 #if defined(_WIN32)
-                    pane.add_button("Portable Mode").on_pressed([] {
-                        if (data::set_portable_data_path()) {
-                            mDoAud_seStartMenu(kSoundItemChange);
-                        }
-                    });
+                        pane.add_button("Portable Mode").on_pressed([] {
+                            if (data::set_portable_data_path()) {
+                                mDoAud_seStartMenu(kSoundItemChange);
+                            }
+                        });
 #endif
-                    pane.add_button({
-                        .text = "Reset to Default",
-                        .isDisabled = [] { return data::is_default_data_path(); },
-                    }).on_pressed([] {
-                        if (data::reset_data_path()) {
-                            mDoAud_seStartMenu(kSoundItemChange);
-                        }
+                        pane.add_button(
+                                {
+                                    .text = "Reset to Default",
+                                    .isDisabled = [] { return data::is_default_data_path(); },
+                                })
+                            .on_pressed([] {
+                                if (data::reset_data_path()) {
+                                    mDoAud_seStartMenu(kSoundItemChange);
+                                }
+                            });
+                        pane.add_rml("Data will be migrated automatically on restart.");
                     });
-                    pane.add_rml("Data will be migrated automatically on restart.");
-                });
-#endif
+            }
             leftPane.register_control(
                 leftPane.add_select_button({
                     .key = "Language",
                     .getValue =
                         [] {
-                            const auto& state = prelaunch_state();
-                            if (!state.configuredDiscCanLaunch || !state.configuredDiscInfo.isPal) {
-                                return kLanguageNames[0];
-                            }
-                            const u8 idx = static_cast<u8>(getSettings().game.language.getValue());
-                            return kLanguageNames[idx];
+                            return language::language_name(getSettings().game.language.getValue());
                         },
                     .isDisabled =
                         [] {
                             const auto& state = prelaunch_state();
-                            return !state.configuredDiscCanLaunch ||
-                                   !state.configuredDiscInfo.isPal;
+                            if (!state.configuredDiscCanLaunch) {
+                                return true;
+                            }
+                            return language::available_languages(state.configuredDiscInfo).size() <= 1;
                         },
                     .isModified =
                         [] {
@@ -665,18 +585,22 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                         },
                 }),
                 rightPane, [](Pane& pane) {
-                    for (int i = 0; i < kLanguageNames.size(); i++) {
+                    const auto& state = prelaunch_state();
+                    const auto languages = state.configuredDiscCanLaunch
+                                               ? language::available_languages(state.configuredDiscInfo)
+                                               : language::available_languages({});
+                    for (const GameLanguage language : languages) {
                         pane.add_button({
-                                            .text = kLanguageNames[i],
+                                            .text = language::language_name(language),
                                             .isSelected =
-                                                [i] {
+                                                [language] {
                                                     return getSettings().game.language.getValue() ==
-                                                           static_cast<GameLanguage>(i);
+                                                           language;
                                                 },
                                         })
-                            .on_pressed([i] {
+                            .on_pressed([language] {
                                 mDoAud_seStartMenu(kSoundItemChange);
-                                getSettings().game.language.setValue(static_cast<GameLanguage>(i));
+                                getSettings().game.language.setValue(language);
                                 config::save();
                             });
                     }
@@ -685,12 +609,8 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
             leftPane.register_control(
                 leftPane.add_select_button({
                     .key = "Graphics Backend",
-                    .getValue = [] { return Rml::String{backend_name(aurora_get_backend())}; },
-                    .isModified =
-                        [] {
-                            return getSettings().backend.graphicsBackend.getValue() !=
-                                   prelaunch_state().initialGraphicsBackend;
-                        },
+                    .getValue = [] { return graphics_backend_display_name(); },
+                    .isModified = [] { return is_graphics_backend_restart_pending(); },
                 }),
                 rightPane, [](Pane& pane) {
                     const auto availableBackends = available_backends();
@@ -783,7 +703,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
             {
                 .key = "Pause on Focus Lost",
                 .helpText = "Pause the game when window focus is lost.",
-                .isDisabled = [] { return IsMobile || getSettings().game.speedrunMode; },
+                .isDisabled = [] { return IsMobile || speedrun::isActive(); },
             });
         leftPane.register_control(
             leftPane.add_select_button({
@@ -842,93 +762,75 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .helpText = "Save and restore the previous session's window size when opening Dusklight.",
                 .onChange =
                     [](bool value) {
-                        if (value && !dusk::getSettings().video.enableFullscreen) {
+                        if (value && !getSettings().video.enableFullscreen) {
                             const auto windowSize = aurora::window::get_window_size();
-                            dusk::getSettings().video.lastWindowWidth.setValue(windowSize.width);
-                            dusk::getSettings().video.lastWindowHeight.setValue(windowSize.height);
-                            dusk::config::save();
+                            getSettings().video.lastWindowWidth.setValue(windowSize.width);
+                            getSettings().video.lastWindowHeight.setValue(windowSize.height);
+                            config::save();
                         }
                     },
                 .isDisabled = [] { return IsMobile; },
             });
+
+        config_int_select(leftPane, rightPane, getSettings().video.uiScale,
+            "UI Scale", 
+            "Scales the Dusklight interface relative to the display's DPI scale. Has no effect on the game's UI and HUD.",
+            50, 200, 25, {}, {}, "%");
+
         leftPane.add_section("Resolution");
         graphics_tuner_control(*this, leftPane, rightPane,
-            getSettings().game.internalResolutionScale,
             GraphicsTunerProps{
                 .option = GraphicsOption::InternalResolution,
                 .title = "Internal Resolution",
                 .helpText = kInternalResolutionHelpText,
-                .valueMin = 0,
-                .valueMax = 12,
-                .defaultValue = 0,
             });
         graphics_tuner_control(*this, leftPane, rightPane,
-            getSettings().game.shadowResolutionMultiplier,
             GraphicsTunerProps{
                 .option = GraphicsOption::ShadowResolution,
                 .title = "Shadow Resolution",
                 .helpText = kShadowResolutionHelpText,
-                .valueMin = 1,
-                .valueMax = 8,
-                .defaultValue = 1,
             });
-        graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.resampler,
+        graphics_tuner_control(*this, leftPane, rightPane,
             GraphicsTunerProps{
                 .option = GraphicsOption::Resampler,
                 .title = "Output Resampling",
                 .helpText = kResamplerHelpText,
-                .valueMin = static_cast<int>(Resampler::Bilinear),
-                .valueMax = static_cast<int>(Resampler::Area),
-                .defaultValue = static_cast<int>(Resampler::Bilinear),
             });
 
         leftPane.add_section("Post-Processing");
-        graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.bloomMode,
+        graphics_tuner_control(*this, leftPane, rightPane,
             GraphicsTunerProps{
                 .option = GraphicsOption::BloomMode,
                 .title = "Bloom",
                 .helpText = kBloomHelpText,
-                .valueMin = static_cast<int>(BloomMode::Off),
-                .valueMax = static_cast<int>(BloomMode::Dusk),
-                .defaultValue = static_cast<int>(BloomMode::Classic),
             });
-        graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.bloomMultiplier,
+        graphics_tuner_control(*this, leftPane, rightPane,
             GraphicsTunerProps{
                 .option = GraphicsOption::BloomMultiplier,
                 .title = "Bloom Brightness",
                 .helpText = kBloomBrightnessHelpText,
-                .valueMin = 0,
-                .valueMax = 100,
-                .defaultValue = 100,
-                .step = 10,
             });
-        graphics_tuner_control(*this, leftPane, rightPane, getSettings().game.depthOfFieldMode,
+        graphics_tuner_control(*this, leftPane, rightPane,
             GraphicsTunerProps{
                 .option = GraphicsOption::DepthOfFieldMode,
                 .title = "Depth of Field",
                 .helpText = kDepthOfFieldHelpText,
-                .valueMin = static_cast<int>(DepthOfFieldMode::Off),
-                .valueMax = static_cast<int>(DepthOfFieldMode::Dusk),
-                .defaultValue = static_cast<int>(DepthOfFieldMode::Classic),
             });
 
         leftPane.add_section("Rendering");
         graphics_tuner_control(*this, leftPane, rightPane,
-            getSettings().game.enableTextureReplacements,
             GraphicsTunerProps{
                 .option = GraphicsOption::TextureReplacements,
                 .title = "Enable Texture Replacements",
                 .helpText = kTextureReplacementHelpText,
-                .valueMin = static_cast<int>(false),
-                .valueMax = static_cast<int>(true),
-                .defaultValue = static_cast<int>(false),
             });
         leftPane.register_control(
             leftPane.add_select_button({
                 .key = "Unlock Framerate",
                 .getValue =
                     [] {
-                        return kInterpolationModes[static_cast<u8>(getSettings().game.enableFrameInterpolation.getValue())];
+                        return kInterpolationModes[static_cast<u8>(
+                            getSettings().game.enableFrameInterpolation.getValue())];
                     },
                 .isModified =
                     [] {
@@ -948,7 +850,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                         .on_pressed([i] {
                             mDoAud_seStartMenu(kSoundItemChange);
                             getSettings().game.enableFrameInterpolation.setValue(static_cast<FrameInterpMode>(i));
-                            android::update_surface_frame_rate();
+                            presentation::update_frame_rate_preference();
                             config::save();
                         });
                 }
@@ -957,7 +859,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         config_int_select(leftPane, rightPane, getSettings().video.maxFrameRate,
             "Framerate Cap", "Limit the framerate to the specified value.", 30, 540, 1,
             [] { return getSettings().game.enableFrameInterpolation.getValue() != FrameInterpMode::Capped; },
-            [](int) { android::update_surface_frame_rate(); });
+            [](int) { presentation::update_frame_rate_preference(); });
         config_bool_select(leftPane, rightPane, getSettings().game.enableMapBackground,
             {
                 .key = "Enable Mini-Map Shadows",
@@ -968,7 +870,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .key = "Disable Cutscene Pillarboxing",
                 .helpText = "Disable black bars on the left and right sides of the screen "
                             "during some cutscenes, particularly on ultra-wide displays. "
-                            "Visuals beyond the original intended framing may appear buggy."
+                            "Visuals beyond the original intended framing may appear buggy.",
             });
     });
 
@@ -987,9 +889,10 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         };
 
         leftPane.add_section("Inputs");
-        leftPane.register_control(leftPane.add_button("Configure Inputs").on_pressed([this] {
-            push(std::make_unique<ControllerConfigWindow>());
-        }),
+        leftPane.register_control(
+            leftPane.add_group_button({.text = "Configure Inputs"}).on_pressed([this] {
+                push(std::make_unique<ControllerConfigWindow>());
+            }),
             rightPane, [](Pane& pane) {
                 pane.clear();
                 pane.add_text("Open input binding configuration.");
@@ -1006,7 +909,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         addOption("Touch Controls", getSettings().game.enableTouchControls,
             "Enables controls overlay for touch screens.<br/><br/>Press and drag on the left side "
             "of the screen to move, and on the right side of the screen to control the camera.");
-        auto& customizeTouchLayout = leftPane.add_button(ControlledButton::Props{
+        auto& customizeTouchLayout = leftPane.add_group_button(GroupButton::Props{
             .text = "Customize Layout",
             .isDisabled = [] { return !getSettings().game.enableTouchControls; },
         });
@@ -1016,23 +919,20 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 pane.clear();
                 pane.add_text("Open the touch controls layout editor.");
             });
-        leftPane.register_control(leftPane.add_select_button({
-                                      .key = "Touch Targeting",
-                                      .getValue =
-                                          [] {
-                                              return touch_targeting_label(
-                                                  getSettings().game.touchTargeting.getValue());
-                                          },
-                                      .isDisabled =
-                                          [] { return !getSettings().game.enableTouchControls; },
-                                      .isModified =
-                                          [] {
-                                              const auto& targeting =
-                                                  getSettings().game.touchTargeting;
-                                              return targeting.getValue() !=
-                                                     targeting.getDefaultValue();
-                                          },
-                                  }),
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Touch Targeting",
+                .getValue =
+                    [] {
+                        return touch_targeting_label(getSettings().game.touchTargeting.getValue());
+                    },
+                .isDisabled = [] { return !getSettings().game.enableTouchControls; },
+                .isModified =
+                    [] {
+                        const auto& targeting = getSettings().game.touchTargeting;
+                        return targeting.getValue() != targeting.getDefaultValue();
+                    },
+            }),
             rightPane, [](Pane& pane) {
                 pane.clear();
                 for (int i = 0; i < static_cast<int>(kTouchTargetingLabels.size()); ++i) {
@@ -1144,7 +1044,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         leftPane.add_section("Tools");
         addOption("Turbo Key", getSettings().game.enableTurboKeybind,
             "Hold Tab to increase game speed by up to 4x.",
-            [] { return getSettings().game.speedrunMode.getValue(); });
+            [] { return speedrun::isActive(); });
         addOption("Reset Key (" + Rml::String{hotkeys::DO_RESET} + ")",
             getSettings().game.enableResetKeybind,
             "Press " + Rml::String{hotkeys::DO_RESET} + " to reset the game.");
@@ -1154,6 +1054,35 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
         auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
 
+        leftPane.add_section("Output");
+        leftPane.register_control(
+            leftPane.add_select_button({
+                .key = "Output Mode",
+                .getValue = [] {
+                    const auto idx = static_cast<int>(getSettings().audio.outputMode.getValue());
+                    return Rml::String{kAudioOutputModeNames[idx]};
+                },
+                .isModified = [] {
+                    const auto& setting = getSettings().audio.outputMode;
+                    return setting.getValue() != setting.getDefaultValue();
+                },
+            }), rightPane, [](Pane& pane) {
+                for (int i = 0; i < static_cast<int>(kAudioOutputModeNames.size()); ++i) {
+                    pane.add_button({
+                        .text = kAudioOutputModeNames[i],
+                        .isSelected = [i] {
+                            const auto& setting = getSettings().audio.outputMode;
+                            return setting.getValue() == static_cast<AudioOutputMode>(i);
+                        },
+                    }).on_pressed([i] {
+                        mDoAud_seStartMenu(kSoundItemChange);
+                        getSettings().audio.outputMode.setValue(static_cast<AudioOutputMode>(i));
+                        config::save();
+                        audio::Reinitialize();
+                    });
+                }
+            });
+
         // TODO: Individual sliders for Main Music, Sub Music, Sound Effects, and Fanfare.
         leftPane.add_section("Volume");
         leftPane.register_control(
@@ -1186,13 +1115,6 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .helpText = "Enables the reverb effect in game audio.",
                 .onChange = [](bool value) { audio::SetEnableReverb(value); },
             });
-        config_bool_select(leftPane, rightPane, getSettings().audio.enableHrtf,
-            {
-                .key = "Enable Spatial Sound",
-                .helpText =
-                    "Emulate surround sound via HRTF. Recommended only for use with headphones!",
-                .onChange = [](bool value) { audio::EnableHrtf = value; },
-            });
         config_bool_select(leftPane, rightPane, getSettings().audio.menuSounds,
             {
                 .key = "Dusklight Menu Sounds",
@@ -1257,7 +1179,7 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                         getSettings().game.damageMultiplier.setValue(value);
                         config::save();
                     },
-                .isDisabled = [] { return getSettings().game.speedrunMode.getValue(); },
+                .isDisabled = [] { return speedrun::isActive(); },
                 .isModified =
                     [] {
                         return getSettings().game.damageMultiplier.getValue() !=
@@ -1308,24 +1230,26 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
             "Allows Wolf Link to howl and change the time of day.");
         addOption("Quick Transform (R+Y)", getSettings().game.enableQuickTransform,
             "Transform instantly by pressing R and Y simultaneously.");
+        addOption("Aiming Reticle", getSettings().game.aimingReticle,
+            "Shows the aiming reticle for bow and slingshot.");
 
         leftPane.add_section("Speedrunning");
         config_bool_select(leftPane, rightPane, getSettings().game.speedrunMode,
             {
                 .key = "Speedrun Mode",
                 .helpText =
-                    "Enables speedrunning options while restricting certain gameplay modifiers.",
+                    "Enables Speedrun game mode option in the Dusklight launch menu.",
                 .onChange =
-                    [](bool enabled) {
+                    [this](bool enabled) {
                         if (enabled) {
-                            reset_for_speedrun_mode();
+                            speedrun::registerSpeedrunGameMode();
                         } else {
-                            restore_from_speedrun_mode();
-                            if (getSettings().game.liveSplitEnabled) {
-                                speedrun::disconnectLiveSplit();
+                            if (speedrun::isActive()) {
+                                pop();
                             }
+                            speedrun::unregisterSpeedrunGameMode();
                         }
-                        MenuBar::rebuild();
+                        MenuBar::refresh_tabs();
                     },
             });
         config_bool_select(leftPane, rightPane, getSettings().game.liveSplitEnabled,
@@ -1341,13 +1265,13 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                             speedrun::disconnectLiveSplit();
                         }
                     },
-                .isDisabled = [] { return IsMobile || !getSettings().game.speedrunMode; },
+                .isDisabled = [] { return IsMobile || !speedrun::isActive(); },
             });
         config_bool_select(leftPane, rightPane, getSettings().game.showSpeedrunRTATimer,
             {
                 .key = "Show RTA",
                 .helpText = "Display the RTA timer. IGT is always visible.",
-                .isDisabled = [] { return !getSettings().game.speedrunMode; },
+                .isDisabled = [] { return !speedrun::isActive(); },
             });
     });
 
@@ -1398,9 +1322,10 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .key = "Magic Armor Behavior",
                 .getValue =
                     [] {
-                        return kMagicArmorModes[static_cast<u8>(getSettings().game.armorRupeeDrain.getValue())];
+                        return kMagicArmorModes[static_cast<u8>(
+                            getSettings().game.armorRupeeDrain.getValue())];
                     },
-                .isDisabled = [] { return getSettings().game.speedrunMode.getValue(); },
+                .isDisabled = [] { return speedrun::isActive(); },
                 .isModified =
                     [] {
                         return getSettings().game.armorRupeeDrain.getValue() !=
@@ -1446,6 +1371,16 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                     "replacements, and other app data.");
             });
 #endif
+        leftPane.register_control(leftPane.add_button("Restart to Main Menu").on_pressed([this] {
+            mDoAud_seStartMenu(kSoundClick);
+            pop();
+            prelaunch_state().returnToPrelaunchOnReset = true;
+            JUTGamePad::C3ButtonReset::sResetSwitchPushing = true;
+        }),
+            rightPane, [](Pane& pane) {
+                pane.add_text("Restart Dusklight to the pre-launch menu to change settings, game "
+                              "modes, or mods.");
+            });
         leftPane.register_control(
             leftPane.add_select_button({
                 .key = "Notifications",
@@ -1510,15 +1445,16 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                     });
                 pane.add_rml("<br/>Choose which notifications can be displayed.");
             });
-#if DUSK_ENABLE_SENTRY_NATIVE
+#if BOREALIS_HAS_SENTRY
         auto& crashReporting = leftPane.add_child<BoolButton>(BoolButton::Props{
             .key = "Crash Reporting",
             .getValue =
-                [] { return crash_reporting::get_consent() == crash_reporting::Consent::Given; },
-            .setValue = [](bool enabled) { crash_reporting::set_consent(enabled); },
+                [] { return borealis::sentry::get_consent() == borealis::sentry::Consent::Given; },
+            .setValue = [](bool enabled) { borealis::sentry::set_consent(enabled); },
             .isDisabled =
                 [] {
-                    return crash_reporting::get_consent() == crash_reporting::Consent::Unavailable;
+                    return borealis::sentry::get_consent() ==
+                           borealis::sentry::Consent::Unavailable;
                 },
             .isModified = [] { return false; },
         });
@@ -1533,8 +1469,10 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
         config_bool_select(leftPane, rightPane, getSettings().backend.skipPreLaunchUI,
             {
                 .key = "Skip Dusklight Main Menu",
-                .helpText = "When starting Dusklight, skip the main menu and boot straight into the "
-                            "game if a disc image is available.",
+                .helpText =
+                    "When starting Dusklight, skip the main menu and boot straight into the "
+                    "game if a disc image is available.<br/><br/>Note: If any mods register game "
+                    "modes, this option will be ignored.",
             });
         config_bool_select(leftPane, rightPane, getSettings().backend.checkForUpdates,
             {
@@ -1542,16 +1480,16 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .helpText = "Checks GitHub releases for a new Dusklight version on startup.<br/><br/>"
                             "No personal information is transmitted or collected.",
             });
-#ifdef DUSK_DISCORD
+#if BOREALIS_HAS_DISCORD
         config_bool_select(leftPane, rightPane, getSettings().game.enableDiscordPresence,
             {
                 .key = "Enable Discord Rich Presence",
                 .helpText = "Enable Dusklight to integrate with Discord Rich Presence. This allows Discord to show your status in-game.",
                 .onChange = [](bool enabled) {
                     if (enabled) {
-                        dusk::discord::initialize();
+                        discord::initialize();
                     } else {
-                        dusk::discord::shutdown();
+                        discord::shutdown();
                     }
                 },
             });
@@ -1563,8 +1501,8 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                 .helpText = "Show advanced settings and debugging tools with "
                             "Shift+F1.<br/><br/><icon class=\"warning\"/> WARNING: Debugging tools "
                             "can easily break your game. Do not use on a regular save!",
-                .onChange = [](bool) { MenuBar::rebuild(); },
-                .isDisabled = [] { return getSettings().game.speedrunMode.getValue(); },
+                .onChange = [](bool) { MenuBar::refresh_tabs(); },
+                .isDisabled = [] { return speedrun::isActive(); },
             });
         config_bool_select(leftPane, rightPane, getSettings().game.showInputViewer,
             {
@@ -1622,11 +1560,26 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
             "Recording Mode",
             "Disables the game HUD and all background music.<br/><br/>Useful for recording footage.");
     });
+
+    add_tab("Tools", [this](Rml::Element* content) {
+        auto& leftPane = add_child<Pane>(content, Pane::Type::Controlled);
+        auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);
+
+        leftPane.add_section("Link");
+        add_speedrun_disabled_option(leftPane, rightPane, getSettings().game.enableMoveLinkCombo,
+            "Move Link (L+R+Y)",
+            "Enables the L+R+Y button combo to toggle freely repositioning Link.");
+        add_speedrun_disabled_option(leftPane, rightPane, getSettings().game.enableTeleportCombo,
+            "Teleport (R+D-pad Up/Down)",
+            "R+D-pad Up stores Link's current position.<br/>"
+            "R+D-pad Down teleports Link back to it.");
+    });
 }
 
 void SettingsWindow::update() {
     if (mPrelaunch && top_document() == this) {
         try_push_verification_modal(*this);
+        try_push_language_unavailable_modal(*this);
     }
 
     Window::update();
diff --git a/src/dusk/ui/string_button.cpp b/src/dusk/ui/string_button.cpp
index a2410ebef6..cc107eac8e 100644
--- a/src/dusk/ui/string_button.cpp
+++ b/src/dusk/ui/string_button.cpp
@@ -6,8 +6,8 @@ namespace dusk::ui {
 
 BaseStringButton::BaseStringButton(Rml::Element* parent, Props props)
     : BaseControlledSelectButton(parent, {std::move(props.key)}), mType(std::move(props.type)),
-      mMaxLength(props.maxLength) {
-    mInputListeners.reserve(4);
+      mMaxLength(props.maxLength), mSetOnChange(props.setOnChange) {
+    mInputListeners.reserve(5);
 }
 
 void BaseStringButton::update() {
@@ -35,8 +35,9 @@ void BaseStringButton::start_editing() {
     if (mInputElem == nullptr) {
         return;
     }
+    mOriginalValue = input_value();
     mInputElem->SetAttribute("type", mType);
-    mInputElem->SetAttribute("value", input_value());
+    mInputElem->SetAttribute("value", mOriginalValue);
     if (mMaxLength > -1) {
         mInputElem->SetAttribute("maxlength", mMaxLength);
     }
@@ -58,7 +59,10 @@ void BaseStringButton::start_editing() {
         mInputElem, Rml::EventId::Textinput, [this](Rml::Event& event) {
             if (event.GetTargetElement() == mInputElem) {
                 const Rml::String text = event.GetParameter("text", Rml::String{});
-                if (!text.empty() && std::ranges::all_of(text, [](const char c) { return c == '\r' || c == '\n' || c == '\t'; })) {
+                if (!text.empty() &&
+                    std::ranges::all_of(
+                        text, [](const char c) { return c == '\r' || c == '\n' || c == '\t'; }))
+                {
                     event.StopImmediatePropagation();
                 }
             }
@@ -78,6 +82,14 @@ void BaseStringButton::start_editing() {
         mInputElem, Rml::EventId::Click, [](Rml::Event& event) { event.StopPropagation(); }));
     mInputListeners.emplace_back(std::make_unique<ScopedEventListener>(mInputElem,
         Rml::EventId::Blur, [this](Rml::Event&) { request_stop_editing(true, false); }));
+    if (mSetOnChange) {
+        mInputListeners.emplace_back(std::make_unique<ScopedEventListener>(
+            mInputElem, Rml::EventId::Change, [this](Rml::Event& event) {
+                if (event.GetTargetElement() == mInputElem) {
+                    set_value(mInputElem->GetValue());
+                }
+            }));
+    }
 }
 
 void BaseStringButton::request_stop_editing(bool commit, bool refocusRoot) {
@@ -123,12 +135,15 @@ void BaseStringButton::stop_editing(bool commit, bool refocusRoot) {
     if (!is_editing()) {
         return;
     }
-    if (commit) {
+    if (!mSetOnChange && commit) {
         set_value(mInputElem->GetValue());
+    } else if (mSetOnChange && !commit) {
+        set_value(mOriginalValue);
     }
     mInputListeners.clear();
     mRoot->RemoveChild(mInputElem);
     mInputElem = nullptr;
+    mOriginalValue.clear();
 
     // Restore value element
     mValueElem->SetProperty(Rml::PropertyId::Visibility, Rml::Style::Visibility::Visible);
@@ -140,7 +155,12 @@ void BaseStringButton::stop_editing(bool commit, bool refocusRoot) {
 }
 
 StringButton::StringButton(Rml::Element* parent, Props props)
-    : BaseStringButton(parent, {.key = std::move(props.key), .maxLength = props.maxLength}),
+    : BaseStringButton(parent,
+          {
+              .key = std::move(props.key),
+              .maxLength = props.maxLength,
+              .setOnChange = props.setOnChange,
+          }),
       mGetValue(std::move(props.getValue)), mSetValue(std::move(props.setValue)),
       mIsDisabled(std::move(props.isDisabled)), mIsModified(std::move(props.isModified)) {}
 
diff --git a/src/dusk/ui/string_button.hpp b/src/dusk/ui/string_button.hpp
index 4366164de7..75e3c323d1 100644
--- a/src/dusk/ui/string_button.hpp
+++ b/src/dusk/ui/string_button.hpp
@@ -12,6 +12,7 @@ public:
         Rml::String key;
         Rml::String type = "text";
         int maxLength = -1;
+        bool setOnChange = false;
     };
 
     BaseStringButton(Rml::Element* parent, Props props);
@@ -30,13 +31,15 @@ private:
     void stop_editing(bool commit = true, bool refocusRoot = false);
 
     Rml::ElementFormControlInput* mInputElem = nullptr;
-    std::vector<std::unique_ptr<ScopedEventListener> > mInputListeners;
+    std::vector<std::unique_ptr<ScopedEventListener>> mInputListeners;
     Rml::String mType;
     int mMaxLength;
     int mPendingInputFocusFrames = 0;
     bool mPendingStopEditing = false;
     bool mPendingCommit = true;
     bool mPendingRefocusRoot = false;
+    bool mSetOnChange = false;
+    Rml::String mOriginalValue;
 };
 
 class StringButton : public BaseStringButton {
@@ -48,6 +51,7 @@ public:
         std::function<bool()> isDisabled;
         std::function<bool()> isModified;
         int maxLength = -1;
+        bool setOnChange = false;
     };
 
     StringButton(Rml::Element* parent, Props props);
diff --git a/src/dusk/ui/tab_bar.cpp b/src/dusk/ui/tab_bar.cpp
index cecaf63412..f638563e97 100644
--- a/src/dusk/ui/tab_bar.cpp
+++ b/src/dusk/ui/tab_bar.cpp
@@ -94,14 +94,14 @@ TabBar::TabBar(Rml::Element* parent, Props props)
 bool TabBar::focus() {
     if (mProps.selectedTabIndex >= 0 && mProps.selectedTabIndex < mTabs.size()) {
         // Try to focus the currently selected tab
-        if (mTabs[mProps.selectedTabIndex].button.focus()) {
+        if (mTabs[mProps.selectedTabIndex].button->focus()) {
             mLastFocusedTabIndex = mProps.selectedTabIndex;
             return true;
         }
     }
     // Otherwise, focus the first enabled tab
     for (int i = 0; i < static_cast<int>(mTabs.size()); ++i) {
-        if (mTabs[i].button.focus()) {
+        if (mTabs[i].button->focus()) {
             mLastFocusedTabIndex = i;
             return true;
         }
@@ -115,8 +115,8 @@ void TabBar::add_tab(const Rml::String& title, TabCallback callback) {
     if (selected && callback) {
         callback();
     }
-    auto& button = add_child<Button>(Button::Props{title}, "tab");
-    button.on_nav_command([this, index](Rml::Event&, NavCommand cmd) {
+    auto button = std::make_unique<Button>(mRoot, Button::Props{title}, "tab");
+    button->on_nav_command([this, index](Rml::Event&, NavCommand cmd) {
         if (cmd == NavCommand::Confirm) {
             if (mProps.autoSelect) {
                 mDoAud_seStartMenu(kSoundTabChanged);
@@ -127,7 +127,7 @@ void TabBar::add_tab(const Rml::String& title, TabCallback callback) {
         return false;
     });
     if (selected) {
-        button.set_selected(true);
+        button->set_selected(true);
     }
     if (mEndSpacer != nullptr) {
         auto spacer = mRoot->RemoveChild(mEndSpacer);
@@ -135,16 +135,26 @@ void TabBar::add_tab(const Rml::String& title, TabCallback callback) {
     }
     mTabs.emplace_back(Tab{
         .title = title,
-        .button = button,
+        .button = std::move(button),
         .callback = std::move(callback),
     });
 }
 
+void TabBar::clear_tabs() {
+    mProps.selectedTabIndex = -1;
+    mLastFocusedTabIndex = -1;
+    while (!mTabs.empty()) {
+        auto* element = mTabs.back().button->root();
+        mTabs.pop_back();
+        mRoot->RemoveChild(element);
+    }
+}
+
 bool TabBar::set_active_tab(int index) {
     if (index == -1) {
         // Clear currently selected tab
         for (auto& tab : mTabs) {
-            tab.button.set_selected(false);
+            tab.button->set_selected(false);
         }
         mProps.selectedTabIndex = -1;
         return true;
@@ -154,10 +164,10 @@ bool TabBar::set_active_tab(int index) {
         return false;
     }
     const auto& tab = mTabs[index];
-    if (tab.button.focus()) {
+    if (tab.button->focus()) {
         mLastFocusedTabIndex = index;
         for (int i = 0; i < static_cast<int>(mTabs.size()); ++i) {
-            mTabs[i].button.set_selected(i == index);
+            mTabs[i].button->set_selected(i == index);
         }
         mProps.selectedTabIndex = index;
         if (tab.callback) {
@@ -177,24 +187,36 @@ void TabBar::refresh_active_tab() {
     }
 }
 
-int TabBar::focused_tab_index() const {
-    return mLastFocusedTabIndex;
+Rml::String TabBar::focused_tab_title() const {
+    if (mLastFocusedTabIndex < 0 || mLastFocusedTabIndex >= static_cast<int>(mTabs.size())) {
+        return {};
+    }
+    return mTabs[mLastFocusedTabIndex].title;
 }
 
 bool TabBar::focus_tab(int index) {
     if (index < 0 || index >= mTabs.size() || index == mProps.selectedTabIndex) {
         return false;
     }
-    if (mTabs[index].button.focus()) {
+    if (mTabs[index].button->focus()) {
         mLastFocusedTabIndex = index;
         return true;
     }
     return false;
 }
 
+bool TabBar::focus_tab(const Rml::String& title) {
+    for (int i = 0; i < static_cast<int>(mTabs.size()); ++i) {
+        if (mTabs[i].title == title) {
+            return focus_tab(i);
+        }
+    }
+    return false;
+}
+
 int TabBar::tab_containing(Rml::Element* element) const {
     for (int i = 0; i < mTabs.size(); ++i) {
-        if (mTabs[i].button.contains(element)) {
+        if (mTabs[i].button->contains(element)) {
             return i;
         }
     }
diff --git a/src/dusk/ui/tab_bar.hpp b/src/dusk/ui/tab_bar.hpp
index e937770a33..a5618a3797 100644
--- a/src/dusk/ui/tab_bar.hpp
+++ b/src/dusk/ui/tab_bar.hpp
@@ -10,7 +10,7 @@ using TabCallback = std::function<void()>;
 
 struct Tab {
     Rml::String title;
-    Button& button;
+    std::unique_ptr<Button> button;
     TabCallback callback;
 };
 
@@ -27,10 +27,12 @@ public:
     bool focus() override;
 
     void add_tab(const Rml::String& title, TabCallback callback);
+    void clear_tabs();
     bool set_active_tab(int index);
     void refresh_active_tab();
     bool focus_tab(int index);
-    int focused_tab_index() const;
+    bool focus_tab(const Rml::String& title);
+    Rml::String focused_tab_title() const;
     bool handle_nav_command(Rml::Event& event, NavCommand cmd);
 
 private:
diff --git a/src/dusk/ui/tooltip.cpp b/src/dusk/ui/tooltip.cpp
new file mode 100644
index 0000000000..6fcc37bb5a
--- /dev/null
+++ b/src/dusk/ui/tooltip.cpp
@@ -0,0 +1,61 @@
+#include "tooltip.hpp"
+
+#include "ui.hpp"
+
+#include <algorithm>
+
+namespace dusk::ui {
+
+Tooltip::Tooltip(Rml::Element* anchor, const Rml::String& label)
+    : mAnchor{anchor}, mRoot{append(anchor->GetOwnerDocument(), "ui-tooltip")},
+      mFollowsFocus{anchor->GetContext()->GetHoverElement() == nullptr},
+      mMouseMove{anchor->GetContext()->GetRootElement(), Rml::EventId::Mousemove,
+          [this](Rml::Event&) { mFollowsFocus = false; }, true},
+      mMouseDown{anchor->GetContext()->GetRootElement(), Rml::EventId::Mousedown,
+          [this](Rml::Event&) { mFollowsFocus = false; }, true},
+      mKeyDown{anchor->GetContext()->GetRootElement(), Rml::EventId::Keydown,
+          [this](Rml::Event& event) {
+              if (map_nav_event(event) != NavCommand::None) {
+                  mFollowsFocus = true;
+              }
+          },
+          true} {
+    // Attach outside the pane so scrolling and overflow cannot clip the label.
+    append_text(mRoot, label);
+}
+
+Tooltip::~Tooltip() {
+    mRoot->GetParentNode()->RemoveChild(mRoot);
+}
+
+void Tooltip::update() {
+    auto* context = mAnchor->GetContext();
+    const bool active = mFollowsFocus ? mAnchor->Contains(context->GetFocusElement()) :
+                                        mAnchor->IsPseudoClassSet("hover");
+    const bool visible =
+        !mAnchor->IsPseudoClassSet("disabled") && mAnchor->IsVisible(true) && active;
+    const bool opening = visible && !mRoot->IsClassSet("visible");
+    mRoot->SetClass("visible", visible);
+    if (!visible) {
+        return;
+    }
+    if (opening) {
+        mRoot->GetOwnerDocument()->UpdateDocument();
+    }
+    const float margin = 8.0f * context->GetDensityIndependentPixelRatio();
+    const auto dimensions = Rml::Vector2f{context->GetDimensions()};
+    const auto anchor = mAnchor->GetAbsoluteOffset(Rml::BoxArea::Border);
+    const auto anchorSize = mAnchor->GetBox().GetSize(Rml::BoxArea::Border);
+    const auto size = mRoot->GetBox().GetSize(Rml::BoxArea::Border);
+    float x = anchor.x + (anchorSize.x - size.x) * 0.5f;
+    float y = anchor.y + anchorSize.y + margin;
+    if (y + size.y > dimensions.y - margin) {
+        y = anchor.y - size.y - margin;
+    }
+    x = std::clamp(x, margin, std::max(margin, dimensions.x - size.x - margin));
+    y = std::clamp(y, margin, std::max(margin, dimensions.y - size.y - margin));
+    mRoot->SetProperty(Rml::PropertyId::Left, Rml::Property{x, Rml::Unit::PX});
+    mRoot->SetProperty(Rml::PropertyId::Top, Rml::Property{y, Rml::Unit::PX});
+}
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/tooltip.hpp b/src/dusk/ui/tooltip.hpp
new file mode 100644
index 0000000000..0b3dbf50b4
--- /dev/null
+++ b/src/dusk/ui/tooltip.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "event.hpp"
+
+namespace dusk::ui {
+
+class Tooltip {
+public:
+    Tooltip(Rml::Element* anchor, const Rml::String& label);
+    ~Tooltip();
+
+    Tooltip(const Tooltip&) = delete;
+    Tooltip& operator=(const Tooltip&) = delete;
+
+    void update();
+
+private:
+    Rml::Element* mAnchor;
+    Rml::Element* mRoot;
+    bool mFollowsFocus;
+    ScopedEventListener mMouseMove;
+    ScopedEventListener mMouseDown;
+    ScopedEventListener mKeyDown;
+};
+
+}  // namespace dusk::ui
diff --git a/src/dusk/ui/touch_controls.cpp b/src/dusk/ui/touch_controls.cpp
index 7e2dedd996..d10ba132be 100644
--- a/src/dusk/ui/touch_controls.cpp
+++ b/src/dusk/ui/touch_controls.cpp
@@ -44,7 +44,7 @@ constexpr float kPressedScale = 0.94f;
 constexpr size_t kEquipTargetCount = 4;
 
 std::array<EquipTarget, kEquipTargetCount> sEquipTargets{};
-std::array<ControlOverride, static_cast<std::size_t>(Control::COUNT)> sControlOverrides{};
+std::array<ControlOverride, static_cast<size_t>(Control::COUNT)> sControlOverrides{};
 TouchControls* sTouchControls = nullptr;
 
 struct ControlInfo {
@@ -58,7 +58,7 @@ struct ControlInfo {
     std::optional<ActionBinds> holdAction;
 };
 
-constexpr std::array<ControlInfo, static_cast<std::size_t>(Control::COUNT)> kControls = {{
+constexpr std::array<ControlInfo, static_cast<size_t>(Control::COUNT)> kControls = {{
     {
         .id = "button-a",
         .padButton = PAD_BUTTON_A,
@@ -119,12 +119,12 @@ constexpr std::array<ControlInfo, static_cast<std::size_t>(Control::COUNT)> kCon
 }};
 
 constexpr const ControlInfo* control_info(Control control) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     return index < kControls.size() ? &kControls[index] : nullptr;
 }
 
 bool control_override_active(Control control) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     return index < sControlOverrides.size() && sControlOverrides[index] != ControlOverride::Default;
 }
 
@@ -133,6 +133,7 @@ Rml::String touch_controls_document_source() {
     return Rml::String{R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/touch_controls.rcss" />
 </head>
 <body id="root">
@@ -360,7 +361,7 @@ bool get_equip_target(int slot, EquipTarget& target) noexcept {
 }
 
 void set_control_override(Control control, ControlOverride override) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     if (index >= sControlOverrides.size()) {
         return;
     }
@@ -381,7 +382,7 @@ TouchControls::TouchControls()
       mActionBar(mDocument != nullptr ? mDocument->GetElementById("action-bar") : nullptr) {
     sTouchControls = this;
     if (mDocument != nullptr) {
-        for (std::size_t i = 0; i < kControls.size(); ++i) {
+        for (size_t i = 0; i < kControls.size(); ++i) {
             const auto& info = kControls[i];
             auto& elements = mControlElements[i];
             elements.root = info.id != nullptr ? mDocument->GetElementById(info.id) : nullptr;
@@ -404,7 +405,7 @@ TouchControls::TouchControls()
     });
 
     auto listenControl = [this](Control control) {
-        const auto index = static_cast<std::size_t>(control);
+        const auto index = static_cast<size_t>(control);
         auto* element = index < mControlElements.size() ? mControlElements[index].root : nullptr;
         if (element == nullptr) {
             return;
@@ -428,7 +429,7 @@ TouchControls::TouchControls()
             }
         });
     };
-    for (std::size_t i = 0; i < kControls.size(); ++i) {
+    for (size_t i = 0; i < kControls.size(); ++i) {
         listenControl(static_cast<Control>(i));
     }
 
@@ -571,7 +572,7 @@ bool TouchControls::fire_control_action(Control control, ControlAction action) n
         return false;
     }
 
-    const auto actionIndex = static_cast<std::size_t>(*actionBind);
+    const auto actionIndex = static_cast<size_t>(*actionBind);
     if (actionIndex >= mQueuedActions.size()) {
         return false;
     }
@@ -581,7 +582,7 @@ bool TouchControls::fire_control_action(Control control, ControlAction action) n
 }
 
 bool TouchControls::start_control_touch(SDL_FingerID id, Control control) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     if (index >= mControlTouches.size()) {
         return false;
     }
@@ -602,7 +603,7 @@ bool TouchControls::start_control_touch(SDL_FingerID id, Control control) noexce
 }
 
 void TouchControls::release_control(Control control) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     if (index < mControlTouches.size()) {
         mControlTouches[index] = {};
     }
@@ -628,7 +629,7 @@ void TouchControls::release_control(Control control) noexcept {
 
 void TouchControls::sync_control_button_mask() noexcept {
     u16 buttonMask = 0;
-    for (std::size_t i = 0; i < mControlTouches.size() && i < kControls.size(); ++i) {
+    for (size_t i = 0; i < mControlTouches.size() && i < kControls.size(); ++i) {
         if (mControlTouches[i].active) {
             buttonMask |= kControls[i].padButton;
         }
@@ -637,7 +638,7 @@ void TouchControls::sync_control_button_mask() noexcept {
 }
 
 void TouchControls::set_control_visual(Control control, bool pressed) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     auto* element = index < mControlElements.size() ? mControlElements[index].root : nullptr;
     if (index >= mControlVisualPressed.size()) {
         return;
@@ -650,7 +651,7 @@ void TouchControls::set_control_visual(Control control, bool pressed) noexcept {
 }
 
 void TouchControls::apply_control_transform(Control control) noexcept {
-    const auto index = static_cast<std::size_t>(control);
+    const auto index = static_cast<size_t>(control);
     if (index >= mControlElements.size()) {
         return;
     }
@@ -693,7 +694,7 @@ void TouchControls::clear_motion_touch_input() noexcept {
 }
 
 void TouchControls::clear_control_input() noexcept {
-    for (std::size_t i = 0; i < mControlTouches.size(); ++i) {
+    for (size_t i = 0; i < mControlTouches.size(); ++i) {
         release_control(static_cast<Control>(i));
     }
     mQueuedActions.reset();
@@ -815,12 +816,12 @@ void TouchControls::sync_virtual_input() noexcept {
 
     for (const auto& control : kControls) {
         if (control.tapAction) {
-            const bool queued = mQueuedActions.test(static_cast<std::size_t>(*control.tapAction));
+            const bool queued = mQueuedActions.test(static_cast<size_t>(*control.tapAction));
             setVirtualActionBind(
                 *control.tapAction, kPort, queued, queued && visible() && !mWasSuppressed);
         }
         if (control.holdAction) {
-            const bool queued = mQueuedActions.test(static_cast<std::size_t>(*control.holdAction));
+            const bool queued = mQueuedActions.test(static_cast<size_t>(*control.holdAction));
             setVirtualActionBind(
                 *control.holdAction, kPort, queued, queued && visible() && !mWasSuppressed);
         }
@@ -869,7 +870,7 @@ void TouchControls::sync_control_layouts() noexcept {
 
         const auto layout = resolve_control_layout(props, docSize);
         if (info.hasControl) {
-            const auto index = static_cast<std::size_t>(info.control);
+            const auto index = static_cast<size_t>(info.control);
             if (index >= mControlElements.size()) {
                 continue;
             }
@@ -898,7 +899,7 @@ void TouchControls::sync_visual_state() noexcept {
     if (mWasSuppressed || !getSettings().game.enableTouchControls) {
         clear_motion_touch_input();
         for (const auto control : {Control::L, Control::R}) {
-            const auto& elements = mControlElements[static_cast<std::size_t>(control)];
+            const auto& elements = mControlElements[static_cast<size_t>(control)];
             if (elements.root != nullptr) {
                 elements.root->SetPseudoClass("hidden", true);
             }
@@ -908,8 +909,8 @@ void TouchControls::sync_visual_state() noexcept {
     }
 
     const bool hideGameplayControls = game_controls_suppressed();
-    const auto& lTrigger = mControlElements[static_cast<std::size_t>(Control::L)];
-    const auto& rTrigger = mControlElements[static_cast<std::size_t>(Control::R)];
+    const auto& lTrigger = mControlElements[static_cast<size_t>(Control::L)];
+    const auto& rTrigger = mControlElements[static_cast<size_t>(Control::R)];
     const bool lHidden = hideGameplayControls && !control_override_active(Control::L);
     const bool rHidden = hideGameplayControls && !control_override_active(Control::R);
 
@@ -936,7 +937,7 @@ void TouchControls::sync_action_bar_state() noexcept {
         if (mActionBar != nullptr) {
             mActionBar->SetPseudoClass("hidden", true);
         }
-        const auto& skip = mControlElements[static_cast<std::size_t>(Control::SKIP)];
+        const auto& skip = mControlElements[static_cast<size_t>(Control::SKIP)];
         if (skip.root != nullptr) {
             skip.root->SetPseudoClass("hidden", true);
         }
@@ -955,7 +956,7 @@ void TouchControls::sync_action_bar_state() noexcept {
         !skipVisible &&
         (!controls_available(false) || dComIfGp_event_runCheck() ||
             (dComIfGp_getMsgObjectClass() != nullptr && dMsgObject_isTalkNowCheck()));
-    const auto& skip = mControlElements[static_cast<std::size_t>(Control::SKIP)];
+    const auto& skip = mControlElements[static_cast<size_t>(Control::SKIP)];
     if (mActionBar != nullptr) {
         mActionBar->SetPseudoClass("hidden", hidden || skipVisible);
     }
@@ -986,7 +987,7 @@ void TouchControls::sync_action_bar_state() noexcept {
 void TouchControls::sync_control_displays() noexcept {
     if (mWasSuppressed || !getSettings().game.enableTouchControls) {
         for (const auto control : {Control::A, Control::B, Control::X, Control::Y, Control::Z}) {
-            const auto& elements = mControlElements[static_cast<std::size_t>(control)];
+            const auto& elements = mControlElements[static_cast<size_t>(control)];
             if (elements.root != nullptr) {
                 elements.root->SetPseudoClass("hidden", true);
             }
@@ -1001,11 +1002,11 @@ void TouchControls::sync_control_displays() noexcept {
     const auto yState = xy_button_state(Control::Y);
     const auto zState = z_button_state();
 
-    const auto& a = mControlElements[static_cast<std::size_t>(Control::A)];
-    const auto& b = mControlElements[static_cast<std::size_t>(Control::B)];
-    const auto& x = mControlElements[static_cast<std::size_t>(Control::X)];
-    const auto& y = mControlElements[static_cast<std::size_t>(Control::Y)];
-    const auto& z = mControlElements[static_cast<std::size_t>(Control::Z)];
+    const auto& a = mControlElements[static_cast<size_t>(Control::A)];
+    const auto& b = mControlElements[static_cast<size_t>(Control::B)];
+    const auto& x = mControlElements[static_cast<size_t>(Control::X)];
+    const auto& y = mControlElements[static_cast<size_t>(Control::Y)];
+    const auto& z = mControlElements[static_cast<size_t>(Control::Z)];
 
     if (a.root != nullptr) {
         a.root->SetPseudoClass("hidden", false);
@@ -1091,7 +1092,7 @@ void TouchControls::sync_control_displays() noexcept {
             return;
         }
         countElement->SetClass("visible", !label.empty());
-        countElement->SetInnerRML(label);
+        set_text_content(countElement, label);
     };
 
     syncCount(x.count, mButtonXCountLabel, Control::X, xState);
@@ -1144,7 +1145,7 @@ void TouchControls::update() {
 }
 
 bool TouchControls::release_control_touch(SDL_FingerID id, bool cancelled) noexcept {
-    for (std::size_t i = 0; i < mControlTouches.size(); ++i) {
+    for (size_t i = 0; i < mControlTouches.size(); ++i) {
         auto& touch = mControlTouches[i];
         if (!touch.active || touch.id != id) {
             continue;
@@ -1165,7 +1166,7 @@ bool TouchControls::release_control_touch(SDL_FingerID id, bool cancelled) noexc
 
 void TouchControls::sync_control_long_presses() noexcept {
     const auto now = clock::now();
-    for (std::size_t i = 0; i < mControlTouches.size(); ++i) {
+    for (size_t i = 0; i < mControlTouches.size(); ++i) {
         auto& touch = mControlTouches[i];
         if (!touch.active || touch.longPressFired || now - touch.startTime < kHoldActionDuration) {
             continue;
@@ -1370,8 +1371,8 @@ void TouchControls::handle_mouse_move(Rml::Event& event) noexcept {
         --mMenuPointerMouseSuppressions;
         return;
     }
-    if (!visible() || mWasSuppressed || !menu_pointer::active() ||
-        !menu_pointer::enabled() || event.GetTargetElement() != mRoot)
+    if (!visible() || mWasSuppressed || !menu_pointer::active() || !menu_pointer::enabled() ||
+        event.GetTargetElement() != mRoot)
     {
         return;
     }
@@ -1387,8 +1388,8 @@ void TouchControls::handle_mouse_down(Rml::Event& event) noexcept {
         --mMenuPointerMouseSuppressions;
         return;
     }
-    if (!visible() || mWasSuppressed || !menu_pointer::active() ||
-        !menu_pointer::enabled() || event.GetTargetElement() != mRoot)
+    if (!visible() || mWasSuppressed || !menu_pointer::active() || !menu_pointer::enabled() ||
+        event.GetTargetElement() != mRoot)
     {
         return;
     }
@@ -1408,8 +1409,7 @@ void TouchControls::handle_mouse_up(Rml::Event& event) noexcept {
         --mMenuPointerMouseSuppressions;
         return;
     }
-    if (!visible() || mWasSuppressed ||
-        !menu_pointer::enabled() ||
+    if (!visible() || mWasSuppressed || !menu_pointer::enabled() ||
         (!menu_pointer::active() && !menu_pointer::mouse_capture_active()) ||
         event.GetTargetElement() != mRoot)
     {
diff --git a/src/dusk/ui/touch_controls.hpp b/src/dusk/ui/touch_controls.hpp
index 752afd58b2..ad68d5d765 100644
--- a/src/dusk/ui/touch_controls.hpp
+++ b/src/dusk/ui/touch_controls.hpp
@@ -100,7 +100,7 @@ private:
     Rml::Element* mControlStick = nullptr;
     Rml::Element* mControlKnob = nullptr;
     Rml::Element* mActionBar = nullptr;
-    std::array<ControlElements, static_cast<std::size_t>(Control::COUNT)> mControlElements{};
+    std::array<ControlElements, static_cast<size_t>(Control::COUNT)> mControlElements{};
     std::string mButtonBIconSource;
     std::string mButtonXIconSource;
     std::string mButtonYIconSource;
@@ -112,9 +112,9 @@ private:
     StickTouch mCameraTouch;
     SDL_FingerID mMenuPointerTouch = 0;
     int mMenuPointerMouseSuppressions = 0;
-    std::array<ControlTouch, static_cast<std::size_t>(Control::COUNT)> mControlTouches{};
-    std::array<bool, static_cast<std::size_t>(Control::COUNT)> mControlVisualPressed{};
-    std::bitset<static_cast<std::size_t>(ActionBinds::COUNT)> mQueuedActions;
+    std::array<ControlTouch, static_cast<size_t>(Control::COUNT)> mControlTouches{};
+    std::array<bool, static_cast<size_t>(Control::COUNT)> mControlVisualPressed{};
+    std::bitset<static_cast<size_t>(ActionBinds::COUNT)> mQueuedActions;
     LayoutState mActionBarLayout;
     Insets mSafeInsets;
     u16 mButtonMask = 0;
diff --git a/src/dusk/ui/touch_controls_common.hpp b/src/dusk/ui/touch_controls_common.hpp
index 30445479ff..461bd103c1 100644
--- a/src/dusk/ui/touch_controls_common.hpp
+++ b/src/dusk/ui/touch_controls_common.hpp
@@ -12,7 +12,7 @@
 
 namespace dusk::ui {
 
-constexpr std::size_t kTouchLayoutControlCount = 9;
+constexpr size_t kTouchLayoutControlCount = 9;
 
 struct TouchLayoutControlInfo {
     std::string_view layoutId;
diff --git a/src/dusk/ui/touch_controls_editor.cpp b/src/dusk/ui/touch_controls_editor.cpp
index 6f4f70de21..cc2ea40d8d 100644
--- a/src/dusk/ui/touch_controls_editor.cpp
+++ b/src/dusk/ui/touch_controls_editor.cpp
@@ -46,6 +46,7 @@ Rml::String touch_controls_editor_document_source() {
     return Rml::String{R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/touch_controls.rcss" />
     <link type="text/rcss" href="res/rml/touch_controls_editor.rcss" />
 </head>
@@ -87,7 +88,7 @@ bool is_vertical_edge(TouchControlsEditor::EditHandle handle) noexcept {
     return handle == EditHandle::Top || handle == EditHandle::Bottom;
 }
 
-bool control_valid(std::size_t index) noexcept {
+bool control_valid(size_t index) noexcept {
     return index < touch_layout_controls().size();
 }
 
@@ -110,7 +111,7 @@ TouchControlsEditor::TouchControlsEditor()
     mWorkingLayout.version = ControlLayout::Version;
 
     const auto controls = touch_layout_controls();
-    for (std::size_t i = 0; i < controls.size() && i < mElements.size(); ++i) {
+    for (size_t i = 0; i < controls.size() && i < mElements.size(); ++i) {
         mElements[i].root =
             mDocument != nullptr ? mDocument->GetElementById(controls[i].elementId) : nullptr;
     }
@@ -196,7 +197,7 @@ bool TouchControlsEditor::focus() {
 
 void TouchControlsEditor::bind_control_events() noexcept {
     const auto controls = touch_layout_controls();
-    for (std::size_t i = 0; i < controls.size() && i < mElements.size(); ++i) {
+    for (size_t i = 0; i < controls.size() && i < mElements.size(); ++i) {
         auto* element = mElements[i].root;
         if (element == nullptr) {
             continue;
@@ -284,7 +285,7 @@ void TouchControlsEditor::sync_control_layouts() noexcept {
     }
 
     const auto controls = touch_layout_controls();
-    for (std::size_t i = 0; i < controls.size() && i < mElements.size(); ++i) {
+    for (size_t i = 0; i < controls.size() && i < mElements.size(); ++i) {
         const auto layout = resolve_control_layout(props_for(i), docSize);
         auto& element = mElements[i];
         element.layout.visualRect = layout.visual;
@@ -308,7 +309,7 @@ void TouchControlsEditor::sync_selection_frame() noexcept {
     }
 
     mSelectionFrame->SetClass("visible", hasSelection);
-    for (std::size_t i = 0; i < mElements.size(); ++i) {
+    for (size_t i = 0; i < mElements.size(); ++i) {
         if (mElements[i].root != nullptr) {
             mElements[i].root->SetClass("editor-selected", hasSelection && i == mSelectedIndex);
         }
@@ -322,7 +323,7 @@ void TouchControlsEditor::sync_selection_frame() noexcept {
         mSelectionFrame, mAppliedSelectionFrame, *mElements[mSelectedIndex].layout.visualRect);
 }
 
-void TouchControlsEditor::set_selected_control(std::size_t index) noexcept {
+void TouchControlsEditor::set_selected_control(size_t index) noexcept {
     if (!control_valid(index)) {
         clear_selected_control();
         return;
@@ -336,7 +337,7 @@ void TouchControlsEditor::clear_selected_control() noexcept {
     sync_selection_frame();
 }
 
-ControlProps TouchControlsEditor::props_for(std::size_t index) const {
+ControlProps TouchControlsEditor::props_for(size_t index) const {
     const auto controls = touch_layout_controls();
     if (!control_valid(index)) {
         return {};
@@ -352,7 +353,7 @@ ControlProps TouchControlsEditor::props_for(std::size_t index) const {
 }
 
 void TouchControlsEditor::store_props(
-    std::size_t index, ControlRect visual, ControlProps props) noexcept {
+    size_t index, ControlRect visual, ControlProps props) noexcept {
     if (!control_valid(index)) {
         return;
     }
@@ -390,7 +391,7 @@ void TouchControlsEditor::restore_active_control() noexcept {
 }
 
 bool TouchControlsEditor::begin_edit(
-    std::size_t index, EditHandle handle, Rml::Vector2f positionPx, bool touch,
+    size_t index, EditHandle handle, Rml::Vector2f positionPx, bool touch,
     SDL_FingerID touchId) noexcept {
     if (!control_valid(index) || mPointerEdit.active) {
         return false;
@@ -542,7 +543,7 @@ ControlRect TouchControlsEditor::rect_for_edit(
     return rect;
 }
 
-ControlRect TouchControlsEditor::clamp_visual_rect(std::size_t index, ControlRect rect) const noexcept {
+ControlRect TouchControlsEditor::clamp_visual_rect(size_t index, ControlRect rect) const noexcept {
     auto* context = mDocument != nullptr ? mDocument->GetContext() : nullptr;
     const auto docSize = touch_document_size_dp(context);
     if (docSize.w <= 0.f || docSize.h <= 0.f || !control_valid(index)) {
@@ -559,7 +560,7 @@ ControlRect TouchControlsEditor::clamp_visual_rect(std::size_t index, ControlRec
     return rect;
 }
 
-Rml::Vector2f TouchControlsEditor::min_visual_size(std::size_t index) const noexcept {
+Rml::Vector2f TouchControlsEditor::min_visual_size(size_t index) const noexcept {
     if (!control_valid(index)) {
         return {kMinControlDp, kMinControlDp};
     }
@@ -594,7 +595,8 @@ void TouchControlsEditor::request_reset() {
     auto dismiss = [](Modal& modal) { modal.pop(); };
     push(std::make_unique<Modal>(Modal::Props{
         .title = "Reset Touch Layout?",
-        .bodyRml = "Reset controls to their default layout. This will not be saved until you press Save.",
+        .bodyText =
+            "Reset controls to their default layout. This will not be saved until you press Save.",
         .actions =
             {
                 ModalAction{
diff --git a/src/dusk/ui/touch_controls_editor.hpp b/src/dusk/ui/touch_controls_editor.hpp
index 4af33d8fbc..69844726e6 100644
--- a/src/dusk/ui/touch_controls_editor.hpp
+++ b/src/dusk/ui/touch_controls_editor.hpp
@@ -45,7 +45,7 @@ private:
     };
 
     struct PointerEdit {
-        std::size_t index = kTouchLayoutControlCount;
+        size_t index = kTouchLayoutControlCount;
         SDL_FingerID touchId = 0;
         Rml::Vector2f startPointerDp;
         ControlRect startVisual;
@@ -64,19 +64,19 @@ private:
         Rml::Element* element, void (TouchControlsEditor::*callback)()) noexcept;
     void sync_control_layouts() noexcept;
     void sync_selection_frame() noexcept;
-    void set_selected_control(std::size_t index) noexcept;
+    void set_selected_control(size_t index) noexcept;
     void clear_selected_control() noexcept;
-    ControlProps props_for(std::size_t index) const;
-    void store_props(std::size_t index, ControlRect visual, ControlProps props) noexcept;
+    ControlProps props_for(size_t index) const;
+    void store_props(size_t index, ControlRect visual, ControlProps props) noexcept;
     void restore_active_control() noexcept;
-    bool begin_edit(std::size_t index, EditHandle handle, Rml::Vector2f positionPx, bool touch,
+    bool begin_edit(size_t index, EditHandle handle, Rml::Vector2f positionPx, bool touch,
         SDL_FingerID touchId = 0) noexcept;
     bool continue_edit(Rml::Vector2f positionPx) noexcept;
     bool end_edit(bool touch, SDL_FingerID touchId, bool cancelled) noexcept;
     Rml::Vector2f pointer_position_dp(Rml::Vector2f positionPx) const noexcept;
     ControlRect rect_for_edit(Rml::Vector2f pointerDp, ControlProps& props) const noexcept;
-    ControlRect clamp_visual_rect(std::size_t index, ControlRect rect) const noexcept;
-    Rml::Vector2f min_visual_size(std::size_t index) const noexcept;
+    ControlRect clamp_visual_rect(size_t index, ControlRect rect) const noexcept;
+    Rml::Vector2f min_visual_size(size_t index) const noexcept;
     bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
     void save_layout();
     void request_reset();
@@ -92,7 +92,7 @@ private:
     ControlLayout mWorkingLayout;
     PointerEdit mPointerEdit;
     std::optional<ControlRect> mAppliedSelectionFrame;
-    std::size_t mSelectedIndex = kTouchLayoutControlCount;
+    size_t mSelectedIndex = kTouchLayoutControlCount;
 };
 
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/ui.cpp b/src/dusk/ui/ui.cpp
index 032937a832..bf9f6962ea 100644
--- a/src/dusk/ui/ui.cpp
+++ b/src/dusk/ui/ui.cpp
@@ -1,39 +1,45 @@
 #include "ui.hpp"
 
+#include "command_console.hpp"
+#include "drop_install_modal.hpp"
+#include "icon_provider.hpp"
+#include "input.hpp"
+#include "mod_texture_provider.hpp"
+#include "prelaunch.hpp"
+#include "remote_texture_provider.hpp"
+#include "window.hpp"
+
+#include "dusk/config.hpp"
+#include "dusk/mods/queue.hpp"
+
+#include <absl/container/flat_hash_set.h>
+#include <aurora/lib/window.hpp>
+#include <aurora/rmlui.hpp>
+#include <borealis/io.hpp>
+#include <fmt/format.h>
 #include <RmlUi/Core.h>
 #include <SDL3/SDL_events.h>
 #include <SDL3/SDL_gamepad.h>
 #include <SDL3/SDL_joystick.h>
 #include <SDL3/SDL_power.h>
 #include <SDL3/SDL_video.h>
-#include <absl/container/flat_hash_set.h>
-#include <aurora/rmlui.hpp>
-#include <fmt/format.h>
 
 #include <algorithm>
 #include <filesystem>
 #include <ranges>
-
-#include "aurora/lib/window.hpp"
-#include "dusk/config.hpp"
-#include "dusk/io.hpp"
-#include "icon_provider.hpp"
-#include "input.hpp"
-#include "mod_texture_provider.hpp"
-#include "prelaunch.hpp"
-#include "window.hpp"
+#include <utility>
 
 namespace dusk::ui {
 namespace {
 
 void load_font(const char* filename, bool fallback = false) {
-    Rml::LoadFontFace(io::fs_path_to_string(resource_path(filename)), fallback);
+    Rml::LoadFontFace(borealis::io::fs_path_to_string(resource_path(filename)), fallback);
 }
 
 bool sInitialized = false;
-std::vector<std::unique_ptr<Document> > sDocumentStack;
+std::vector<std::unique_ptr<Document>> sDocumentStack;
 // Documents that don't participate in the focus stack
-std::vector<std::unique_ptr<Document> > sPassiveDocuments;
+std::vector<std::unique_ptr<Document>> sPassiveDocuments;
 
 struct ScopedStyles {
     DocumentScope scope;
@@ -67,6 +73,13 @@ void restyle_scope(DocumentScope scope) {
 
 std::deque<Toast> sToasts;
 bool sMenuNotificationRequested = false;
+bool sConsoleShortcutHeld = false;
+std::vector<std::filesystem::path> sDroppedPackages;
+
+struct PendingDrop {
+    borealis::Task<std::vector<DropPackage>> inspection;
+};
+std::vector<PendingDrop> sPendingDrops;
 
 // Sometimes gamepads can connect and disconnect quickly, especially during
 // connection negotiation. In this case, we'll receive an _ADDED event for a
@@ -95,16 +108,25 @@ bool initialize() noexcept {
 
     register_icon_texture_provider();
     register_mod_texture_provider();
+    register_remote_texture_provider();
     sInitialized = true;
     return true;
 }
 
 void shutdown() noexcept {
+    mods::queue::shutdown();
+    for (auto& drop : sPendingDrops) {
+        drop.inspection.cancel();
+    }
+    sPendingDrops.clear();
+    sDroppedPackages.clear();
+    unregister_remote_texture_provider();
     unregister_mod_texture_provider();
     unregister_icon_texture_provider();
     sDocumentStack.clear();
     sPassiveDocuments.clear();
     sConnectedGamepads.clear();
+    sConsoleShortcutHeld = false;
     input::reset_input_state();
     input::release_input_block();
     sInitialized = false;
@@ -166,17 +188,39 @@ void handle_event(const SDL_Event& event) noexcept {
         return;
     }
 
-    if (event.type == SDL_EVENT_GAMEPAD_ADDED) {
+    if (event.type == SDL_EVENT_DROP_BEGIN) {
+        sDroppedPackages.clear();
+    } else if (event.type == SDL_EVENT_DROP_FILE && event.drop.data != nullptr) {
+        sDroppedPackages.push_back(borealis::io::fs_path_from_utf8(event.drop.data));
+    } else if (event.type == SDL_EVENT_DROP_COMPLETE) {
+        if (sDroppedPackages.empty()) {
+            push_toast({
+                .type = "warning",
+                .title = "No packages found",
+                .content = "Drop a Dusklight package to import it.",
+                .duration = std::chrono::seconds{4},
+            });
+        } else {
+            auto paths = std::exchange(sDroppedPackages, {});
+            sPendingDrops.push_back({
+                borealis::spawn([paths = std::move(paths)](borealis::TaskContext& context) {
+                    return inspect_drop_packages(paths, context);
+                }),
+            });
+        }
+    } else if (event.type == SDL_EVENT_GAMEPAD_ADDED) {
         auto* gamepad = SDL_GetGamepadFromID(event.gdevice.which);
         if (SDL_GamepadConnected(gamepad)) {
             if (getSettings().game.enableControllerToasts) {
                 const char* name = SDL_GetGamepadName(gamepad);
                 Rml::String content = fmt::format("<span>{}</span>", name ? name : "[Unknown]");
                 Rml::String title = "Device Connected";
-                if (const char* icon = connection_state_icon(SDL_GetGamepadConnectionState(gamepad))) {
+                if (const char* icon =
+                        connection_state_icon(SDL_GetGamepadConnectionState(gamepad)))
+                {
                     title = fmt::format(
-                        "<row><span>{}</span> <icon class=\"connection\">&#x{};</icon></row>", title,
-                        icon);
+                        "<row><span>{}</span> <icon class=\"connection\">&#x{};</icon></row>",
+                        title, icon);
                 }
                 int batteryLevel = -1;
                 const auto powerState = SDL_GetGamepadPowerInfo(gamepad, &batteryLevel);
@@ -211,6 +255,30 @@ void handle_event(const SDL_Event& event) noexcept {
             });
         }
         sConnectedGamepads.erase(event.gdevice.which);
+    } else if (event.type == SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED) {
+        apply_scale();
+    }
+    if (event.type == SDL_EVENT_WINDOW_FOCUS_LOST) {
+        sConsoleShortcutHeld = false;
+    }
+    if (event.type == SDL_EVENT_KEY_UP && event.key.key == SDLK_SLASH && sConsoleShortcutHeld) {
+        sConsoleShortcutHeld = false;
+        return;
+    }
+    if (event.type == SDL_EVENT_KEY_DOWN && event.key.key == SDLK_SLASH &&
+        getSettings().backend.enableAdvancedSettings)
+    {
+        auto* console = static_cast<CommandConsole*>(find_document(DocumentScope::CommandConsole));
+        if (sConsoleShortcutHeld) {
+            return;
+        }
+        if (console != nullptr && !console->input_active() && !event.key.repeat) {
+            sConsoleShortcutHeld = true;
+            bring_document_to_front(*console);
+            console->show();
+            input::sync_input_block();
+            return;
+        }
     }
     input::handle_event(event);
 }
@@ -257,6 +325,61 @@ Document& push_document(std::unique_ptr<Document> doc, bool show, bool passive)
     return ret;
 }
 
+Document& detail::pop_to_or_push_document(bool (*matches)(Document&),
+    const std::function<std::unique_ptr<Document>()>& create,
+    const std::function<void(Document&)>& configure) {
+    Document* destination = nullptr;
+    size_t destinationIndex = 0;
+    for (size_t i = sDocumentStack.size(); i > 0; --i) {
+        auto& document = *sDocumentStack[i - 1];
+        if (!document.closed() && !document.pending_close() && matches(document)) {
+            destination = &document;
+            destinationIndex = i - 1;
+            break;
+        }
+    }
+
+    if (destination != nullptr) {
+        std::vector<Document*> closing;
+        for (size_t i = sDocumentStack.size(); i > destinationIndex + 1; --i) {
+            closing.push_back(sDocumentStack[i - 1].get());
+        }
+        for (auto* document : closing) {
+            if (!document->closed() && !document->pending_close()) {
+                if (document->visible()) {
+                    document->hide(true);
+                } else {
+                    document->force_hide(true);
+                }
+            }
+        }
+        configure(*destination);
+    } else {
+        auto document = create();
+        configure(*document);
+        if (auto* current = top_document()) {
+            current->cover();
+        }
+        destination = &push_document(std::move(document), false);
+    }
+
+    destination->show();
+    destination->focus();
+    input::sync_input_block();
+    return *destination;
+}
+
+void bring_document_to_front(Document& doc) noexcept {
+    const auto it = std::ranges::find_if(
+        sDocumentStack, [&doc](const auto& entry) { return entry.get() == &doc; });
+    if (it == sDocumentStack.end() || std::next(it) == sDocumentStack.end()) {
+        return;
+    }
+    auto entry = std::move(*it);
+    sDocumentStack.erase(it);
+    sDocumentStack.push_back(std::move(entry));
+}
+
 void uncover_top_document() noexcept {
     if (auto* doc = top_document()) {
         doc->uncover();
@@ -264,9 +387,27 @@ void uncover_top_document() noexcept {
     input::sync_input_block();
 }
 
+Document* find_document(DocumentScope scope) noexcept {
+    for (auto& doc : std::views::reverse(sDocumentStack)) {
+        if (!doc->closed() && doc->scope() == scope) {
+            return doc.get();
+        }
+    }
+    return nullptr;
+}
+
+void close_all_documents() noexcept {
+    for (auto& doc : sDocumentStack) {
+        if (!doc->closed()) {
+            doc->force_hide(!doc->permanent());
+        }
+    }
+    input::sync_input_block();
+}
+
 bool any_document_visible() noexcept {
     return std::any_of(sDocumentStack.begin(), sDocumentStack.end(),
-        [](const auto& doc) { return doc && doc->visible(); });
+        [](const auto& doc) { return doc && doc->visible() && !doc->pending_close(); });
 }
 
 bool is_prelaunch_open() noexcept {
@@ -298,14 +439,39 @@ Document* top_document() noexcept {
 }
 
 void update() noexcept {
+    mods::queue::update();
     if (!aurora::rmlui::is_initialized()) {
         return;
     }
 
+    update_remote_texture_provider();
+    for (size_t index = 0; index < sPendingDrops.size();) {
+        auto& pending = sPendingDrops[index];
+        if (!pending.inspection.ready()) {
+            ++index;
+            continue;
+        }
+        try {
+            if (auto packages = pending.inspection.try_take(); packages && !packages->empty()) {
+                if (auto* current = top_document()) {
+                    current->cover();
+                }
+                push_document(std::make_unique<DropInstallModal>(std::move(*packages)));
+            }
+        } catch (const std::exception& exception) {
+            push_toast({
+                .type = "warning",
+                .title = "Could not inspect packages",
+                .content = exception.what(),
+                .duration = std::chrono::seconds{5},
+            });
+        }
+        sPendingDrops.erase(sPendingDrops.begin() + static_cast<std::ptrdiff_t>(index));
+    }
     input::update_input();
     const auto update_documents = [](auto& documents) {
-        const std::size_t count = documents.size();
-        for (std::size_t i = 0; i < count && i < documents.size(); ++i) {
+        const size_t count = documents.size();
+        for (size_t i = 0; i < count && i < documents.size(); ++i) {
             Document* doc = documents[i].get();
             if (doc != nullptr && !doc->closed()) {
                 doc->update();
@@ -327,13 +493,10 @@ void update() noexcept {
         sPassiveDocuments.erase(first, last);
     }
 
-    // If no documents have focus, explicitly focus the top one
-    if (auto* context = aurora::rmlui::get_context();
-        context != nullptr && (context->GetFocusElement() == nullptr ||
-                                  context->GetFocusElement() == context->GetRootElement()))
-    {
+    // Keep focus on the highest active document.
+    if (aurora::rmlui::get_context() != nullptr) {
         for (auto& doc : std::views::reverse(sDocumentStack)) {
-            if (doc->active() && doc->focus()) {
+            if (doc->active() && (doc->has_focus() || doc->focus())) {
                 break;
             }
         }
@@ -382,6 +545,40 @@ Rml::Element* append(Rml::Element* parent, const Rml::String& tag) noexcept {
     return parent->AppendChild(doc->CreateElement(tag));
 }
 
+Rml::Element* append_text(Rml::Element* parent, const Rml::String& text) noexcept {
+    if (parent == nullptr) {
+        return nullptr;
+    }
+    auto* doc = parent->GetOwnerDocument();
+    if (doc == nullptr) {
+        return nullptr;
+    }
+    return parent->AppendChild(doc->CreateTextNode(text));
+}
+
+Rml::Element* append_text_element(
+    Rml::Element* parent, const Rml::String& tag, const Rml::String& text) noexcept {
+    auto* element = append(parent, tag);
+    append_text(element, text);
+    return element;
+}
+
+void clear_children(Rml::Element* parent) noexcept {
+    if (parent == nullptr) {
+        return;
+    }
+    while (parent->GetNumChildren() > 0) {
+        parent->RemoveChild(parent->GetFirstChild());
+    }
+}
+
+void set_text_content(Rml::Element* parent, const Rml::String& text) noexcept {
+    clear_children(parent);
+    if (!text.empty()) {
+        append_text(parent, text);
+    }
+}
+
 NavCommand map_nav_event(const Rml::Event& event) noexcept {
     const auto key = static_cast<Rml::Input::KeyIdentifier>(
         event.GetParameter<int>("key_identifier", Rml::Input::KI_UNKNOWN));
@@ -448,10 +645,6 @@ void push_toast(Toast toast) noexcept {
     sToasts.push_back(std::move(toast));
 }
 
-std::vector<std::unique_ptr<Document> >& get_document_stack() noexcept {
-    return sDocumentStack;
-}
-
 std::deque<Toast>& get_toasts() noexcept {
     return sToasts;
 }
@@ -466,4 +659,15 @@ bool consume_menu_notification_request() noexcept {
     return requested;
 }
 
+void apply_scale() noexcept {
+    const auto userScale = getSettings().video.uiScale.getValue();
+    auto scale = 0.0f;
+    if (userScale != 0) {
+        const auto displayScale = aurora::window::get_window_size().scale;
+        scale =
+            static_cast<float>(userScale) / 100.0f * (displayScale > 0.0f ? displayScale : 1.0f);
+    }
+    aurora::rmlui::set_ui_scale(scale);
+}
+
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/ui.hpp b/src/dusk/ui/ui.hpp
index daf3c3ff03..fd4ac730c2 100644
--- a/src/dusk/ui/ui.hpp
+++ b/src/dusk/ui/ui.hpp
@@ -4,12 +4,16 @@
 #include <SDL3/SDL_events.h>
 
 #include <filesystem>
+#include <functional>
 #include <memory>
 #include <string>
 #include <string_view>
+#include <utility>
 
 #include "nav_types.hpp"
 
+#include "Z2AudioLib/Z2SeMgr.h"
+
 namespace dusk::ui {
 class Document;
 
@@ -17,6 +21,7 @@ using clock = std::chrono::steady_clock;
 
 enum class DocumentScope : u8 {
     None,
+    CommandConsole,
     Prelaunch,
     Window,
     MenuBar,
@@ -30,6 +35,7 @@ struct Toast {
     Rml::String title;
     Rml::String content;
     clock::duration duration;
+    Rml::String modId;
 };
 
 // Button clicked/pressed
@@ -84,10 +90,32 @@ void update() noexcept;
 
 Document& push_document(
     std::unique_ptr<Document> doc, bool show = true, bool passive = false) noexcept;
+
+namespace detail {
+Document& pop_to_or_push_document(bool (*matches)(Document&),
+    const std::function<std::unique_ptr<Document>()>& create,
+    const std::function<void(Document&)>& configure);
+}
+
+template <typename T, typename Configure, typename... Args>
+T& pop_to_or_push(Configure&& configure, Args&&... args) {
+    return static_cast<T&>(detail::pop_to_or_push_document(
+        [](Document& document) { return dynamic_cast<T*>(&document) != nullptr; },
+        [&]() -> std::unique_ptr<Document> {
+            return std::make_unique<T>(std::forward<Args>(args)...);
+        },
+        [&](Document& document) {
+            std::invoke(std::forward<Configure>(configure), static_cast<T&>(document));
+        }));
+}
+
+void bring_document_to_front(Document& doc) noexcept;
 bool register_scoped_styles(DocumentScope scope, std::string id, const std::string& rcss) noexcept;
 void unregister_scoped_styles(DocumentScope scope, std::string_view id) noexcept;
 void apply_scoped_styles(Document& doc) noexcept;
 void uncover_top_document() noexcept;
+Document* find_document(DocumentScope scope) noexcept;
+void close_all_documents() noexcept;
 bool any_document_visible() noexcept;
 bool is_prelaunch_open() noexcept;
 bool game_obscured_below(const Document& doc) noexcept;
@@ -96,12 +124,15 @@ Document* top_document() noexcept;
 std::filesystem::path resource_path(const std::filesystem::path& filename) noexcept;
 std::string escape(std::string_view str) noexcept;
 Rml::Element* append(Rml::Element* parent, const Rml::String& tag) noexcept;
+Rml::Element* append_text(Rml::Element* parent, const Rml::String& text) noexcept;
+Rml::Element* append_text_element(
+    Rml::Element* parent, const Rml::String& tag, const Rml::String& text) noexcept;
+void clear_children(Rml::Element* parent) noexcept;
+void set_text_content(Rml::Element* parent, const Rml::String& text) noexcept;
 
 NavCommand map_nav_event(const Rml::Event& event) noexcept;
 Insets safe_area_insets(Rml::Context* context) noexcept;
 
-std::vector<std::unique_ptr<Document>>& get_document_stack() noexcept;
-
 void push_toast(Toast toast) noexcept;
 std::deque<Toast>& get_toasts() noexcept;
 void show_menu_notification() noexcept;
@@ -110,4 +141,6 @@ bool consume_menu_notification_request() noexcept;
 const char* battery_icon(SDL_PowerState state, int level) noexcept;
 const char* connection_state_icon(SDL_JoystickConnectionState state) noexcept;
 
+void apply_scale() noexcept;
+
 }  // namespace dusk::ui
diff --git a/src/dusk/ui/warp.cpp b/src/dusk/ui/warp.cpp
index efae7f1d65..0827745fa1 100644
--- a/src/dusk/ui/warp.cpp
+++ b/src/dusk/ui/warp.cpp
@@ -4,7 +4,8 @@
 #include "pane.hpp"
 
 #include "dusk/map_loader_definitions.h"
-#include "fmt/format.h"
+
+#include <fmt/format.h>
 
 namespace dusk::ui {
 namespace {
diff --git a/src/dusk/ui/window.cpp b/src/dusk/ui/window.cpp
index f1162a09b6..a47296344f 100644
--- a/src/dusk/ui/window.cpp
+++ b/src/dusk/ui/window.cpp
@@ -1,15 +1,15 @@
 #include "window.hpp"
 
-#include "aurora/lib/window.hpp"
-#include "aurora/rmlui.hpp"
-#include "fmt/format.h"
-#include "magic_enum.hpp"
 #include "pane.hpp"
 #include "ui.hpp"
 
-#include "Z2AudioLib/Z2SeMgr.h"
 #include "m_Do/m_Do_audio.h"
 
+#include <aurora/lib/window.hpp>
+#include <aurora/rmlui.hpp>
+#include <fmt/format.h>
+#include <magic_enum.hpp>
+
 #include <algorithm>
 #include <cmath>
 
@@ -33,6 +33,7 @@ Rml::String window_document_source(const std::vector<Rml::String>& styleSheets)
     return fmt::format(R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/tabbing.rcss" />
     <link type="text/rcss" href="res/rml/window.rcss" />
 {}</head>
@@ -47,11 +48,12 @@ Rml::String window_document_source(const std::vector<Rml::String>& styleSheets)
 const Rml::String kDocumentSourceSmall = R"RML(
 <rml>
 <head>
+    <link type="text/rcss" href="res/rml/theme.rcss" />
     <link type="text/rcss" href="res/rml/window.rcss" />
 </head>
 <body>
     <window id="window" class="small">
-        <div id="dialog"/>
+        <modal-dialog id="dialog"/>
     </window>
 </body>
 </rml>
@@ -330,7 +332,7 @@ bool Window::handle_content_nav(Rml::Event& event, NavCommand cmd) noexcept {
     return false;
 }
 
-WindowSmall::WindowSmall(const Rml::String& windowClass, const Rml::String& dialogClass)
+WindowSmall::WindowSmall(const Rml::String& windowClass)
     : Document(kDocumentSourceSmall, false, DocumentScope::Window),
       mRoot(mDocument->GetElementById("window")), mDialog(mDocument->GetElementById("dialog")) {
     listen(mRoot, Rml::EventId::Transitionend, [this](Rml::Event& event) {
@@ -342,7 +344,6 @@ WindowSmall::WindowSmall(const Rml::String& windowClass, const Rml::String& dial
     });
 
     mRoot->SetClass(windowClass, true);
-    mDialog->SetClass(dialogClass, true);
 }
 
 void WindowSmall::show() {
diff --git a/src/dusk/ui/window.hpp b/src/dusk/ui/window.hpp
index e6d10b61da..c9757482c2 100644
--- a/src/dusk/ui/window.hpp
+++ b/src/dusk/ui/window.hpp
@@ -71,7 +71,7 @@ protected:
 // Shared shell for small-style windows such as Modal and PresetWindow
 class WindowSmall : public Document {
 public:
-    WindowSmall(const Rml::String& windowClass, const Rml::String& dialogClass);
+    explicit WindowSmall(const Rml::String& windowClass);
 
     void show() override;
     void hide(bool close) override;
diff --git a/src/dusk/update_check.cpp b/src/dusk/update_check.cpp
deleted file mode 100644
index 737facc027..0000000000
--- a/src/dusk/update_check.cpp
+++ /dev/null
@@ -1,351 +0,0 @@
-#include "update_check.hpp"
-
-#include "dusk/http/http.hpp"
-#include "fmt/format.h"
-#include "nlohmann/json.hpp"
-#include "version.h"
-
-#include <algorithm>
-#include <charconv>
-#include <optional>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace dusk::update_check {
-namespace {
-
-using json = nlohmann::json;
-
-constexpr std::string_view GitHubApiVersion = "2026-03-10";
-
-struct Version {
-    int major = 0;
-    int minor = 0;
-    int patch = 0;
-    std::vector<std::string_view> prerelease;
-};
-
-std::string json_string(const json& value, const char* key) {
-    const auto iter = value.find(key);
-    if (iter == value.end() || !iter->is_string()) {
-        return {};
-    }
-    return iter->get<std::string>();
-}
-
-std::optional<int> parse_component(std::string_view& value) {
-    if (value.empty() || value.front() < '0' || value.front() > '9') {
-        return std::nullopt;
-    }
-
-    int parsed = 0;
-    const char* begin = value.data();
-    const char* end = value.data() + value.size();
-    const auto [ptr, ec] = std::from_chars(begin, end, parsed);
-    if (ec != std::errc()) {
-        return std::nullopt;
-    }
-
-    value.remove_prefix(static_cast<size_t>(ptr - begin));
-    return parsed;
-}
-
-bool consume(std::string_view& value, char expected) {
-    if (value.empty() || value.front() != expected) {
-        return false;
-    }
-    value.remove_prefix(1);
-    return true;
-}
-
-bool is_digit(char value) {
-    return value >= '0' && value <= '9';
-}
-
-bool is_identifier_char(char value) {
-    return is_digit(value) || (value >= 'A' && value <= 'Z') || (value >= 'a' && value <= 'z') || value == '-';
-}
-
-bool is_numeric_identifier(std::string_view value) {
-    if (value.empty()) {
-        return false;
-    }
-    for (const char c : value) {
-        if (!is_digit(c)) {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool is_identifier_list(std::string_view value) {
-    if (value.empty()) {
-        return false;
-    }
-
-    bool expectingIdentifier = true;
-    for (const char c : value) {
-        if (c == '.') {
-            if (expectingIdentifier) {
-                return false;
-            }
-            expectingIdentifier = true;
-            continue;
-        }
-        if (!is_identifier_char(c)) {
-            return false;
-        }
-        expectingIdentifier = false;
-    }
-
-    return !expectingIdentifier;
-}
-
-std::string_view trim_git_describe_suffix(std::string_view value) {
-    if (value.ends_with("-dirty")) {
-        value.remove_suffix(6);
-    }
-    if (is_numeric_identifier(value)) {
-        return {};
-    }
-
-    const size_t suffixStart = value.rfind('-');
-    if (suffixStart != std::string_view::npos && value.substr(0, suffixStart).find('.') != std::string_view::npos
-        && is_numeric_identifier(value.substr(suffixStart + 1))) {
-        value.remove_suffix(value.size() - suffixStart);
-    }
-    return value;
-}
-
-void split_identifiers(std::string_view value, std::vector<std::string_view>& identifiers) {
-    while (!value.empty()) {
-        const size_t separator = value.find('.');
-        if (separator == std::string_view::npos) {
-            identifiers.push_back(value);
-            return;
-        }
-        identifiers.push_back(value.substr(0, separator));
-        value.remove_prefix(separator + 1);
-    }
-}
-
-std::string_view trim_leading_zeroes(std::string_view value) {
-    while (value.size() > 1 && value.front() == '0') {
-        value.remove_prefix(1);
-    }
-    return value;
-}
-
-int compare_identifier(std::string_view lhs, std::string_view rhs) {
-    const bool lhsNumeric = is_numeric_identifier(lhs);
-    const bool rhsNumeric = is_numeric_identifier(rhs);
-    if (lhsNumeric && rhsNumeric) {
-        lhs = trim_leading_zeroes(lhs);
-        rhs = trim_leading_zeroes(rhs);
-        if (lhs.size() != rhs.size()) {
-            return lhs.size() < rhs.size() ? -1 : 1;
-        }
-    } else if (lhsNumeric != rhsNumeric) {
-        return lhsNumeric ? -1 : 1;
-    }
-
-    const int result = lhs.compare(rhs);
-    if (result < 0) {
-        return -1;
-    }
-    if (result > 0) {
-        return 1;
-    }
-    return 0;
-}
-
-int compare_version(const Version& lhs, const Version& rhs) {
-    if (lhs.major != rhs.major) {
-        return lhs.major < rhs.major ? -1 : 1;
-    }
-    if (lhs.minor != rhs.minor) {
-        return lhs.minor < rhs.minor ? -1 : 1;
-    }
-    if (lhs.patch != rhs.patch) {
-        return lhs.patch < rhs.patch ? -1 : 1;
-    }
-    if (lhs.prerelease.empty() != rhs.prerelease.empty()) {
-        return lhs.prerelease.empty() ? 1 : -1;
-    }
-
-    const size_t commonSize = std::min(lhs.prerelease.size(), rhs.prerelease.size());
-    for (size_t i = 0; i < commonSize; ++i) {
-        const int result = compare_identifier(lhs.prerelease[i], rhs.prerelease[i]);
-        if (result != 0) {
-            return result;
-        }
-    }
-    if (lhs.prerelease.size() != rhs.prerelease.size()) {
-        return lhs.prerelease.size() < rhs.prerelease.size() ? -1 : 1;
-    }
-    return 0;
-}
-
-std::optional<Version> parse_version(std::string_view value) {
-    if (!value.empty() && value.front() == 'v') {
-        value.remove_prefix(1);
-    }
-
-    Version version;
-    auto major = parse_component(value);
-    if (!major || !consume(value, '.')) {
-        return std::nullopt;
-    }
-    auto minor = parse_component(value);
-    if (!minor || !consume(value, '.')) {
-        return std::nullopt;
-    }
-    auto patch = parse_component(value);
-    if (!patch) {
-        return std::nullopt;
-    }
-
-    version.major = *major;
-    version.minor = *minor;
-    version.patch = *patch;
-
-    if (value.empty()) {
-        return version;
-    }
-    if (value.front() == '+') {
-        value.remove_prefix(1);
-        if (!is_identifier_list(value)) {
-            return std::nullopt;
-        }
-        return version;
-    }
-    if (!consume(value, '-')) {
-        return std::nullopt;
-    }
-
-    const size_t buildStart = value.find('+');
-    std::string_view prerelease = value.substr(0, buildStart);
-    if (!is_identifier_list(prerelease)) {
-        return std::nullopt;
-    }
-    if (buildStart != std::string_view::npos && !is_identifier_list(value.substr(buildStart + 1))) {
-        return std::nullopt;
-    }
-
-    prerelease = trim_git_describe_suffix(prerelease);
-    if (!prerelease.empty()) {
-        split_identifiers(prerelease, version.prerelease);
-    }
-    return version;
-}
-
-Release parse_release(const json& value) {
-    Release release{
-        .tagName = json_string(value, "tag_name"),
-        .name = json_string(value, "name"),
-        .htmlUrl = json_string(value, "html_url"),
-        .body = json_string(value, "body"),
-    };
-
-    const auto assets = value.find("assets");
-    if (assets != value.end() && assets->is_array()) {
-        for (const auto& asset : *assets) {
-            if (!asset.is_object()) {
-                continue;
-            }
-            release.assets.push_back({
-                .name = json_string(asset, "name"),
-                .browserDownloadUrl = json_string(asset, "browser_download_url"),
-                .digest = json_string(asset, "digest"),
-            });
-        }
-    }
-
-    return release;
-}
-
-std::string release_url(std::string_view owner, std::string_view repo) {
-    return fmt::format("https://api.github.com/repos/{}/{}/releases/latest", owner, repo);
-}
-
-std::string user_agent() {
-    return fmt::format("Dusk/{}", DUSK_WC_DESCRIBE);
-}
-
-}  // namespace
-
-Result check_latest_github_release(std::string_view owner, std::string_view repo) {
-    if (!http::available()) {
-        return {
-            .status = Status::Disabled,
-            .message = "No HTTP backend is available",
-        };
-    }
-    if (owner.empty() || repo.empty()) {
-        return {
-            .status = Status::Failed,
-            .message = "GitHub owner and repo are required",
-        };
-    }
-
-    http::Request request{
-        .url = release_url(owner, repo),
-        .headers =
-            {
-                {.name = "User-Agent", .value = user_agent()},
-                {.name = "Accept", .value = "application/vnd.github+json"},
-                {.name = "X-GitHub-Api-Version", .value = std::string(GitHubApiVersion)},
-            },
-    };
-
-    http::Result result = http::get(request);
-    if (result.error != http::Error::None) {
-        return {
-            .status = Status::Failed,
-            .message = result.message,
-        };
-    }
-    if (result.response.statusCode != 200) {
-        return {
-            .status = Status::Failed,
-            .message = fmt::format("GitHub returned HTTP {}", result.response.statusCode),
-        };
-    }
-
-    Release latest;
-    try {
-        latest = parse_release(json::parse(result.response.body));
-    } catch (const std::exception& e) {
-        return {
-            .status = Status::Failed,
-            .message = fmt::format("Failed to parse GitHub release JSON: {}", e.what()),
-        };
-    }
-
-    const std::optional<Version> latestVersion = parse_version(latest.tagName);
-    const std::optional<Version> currentVersion = parse_version(DUSK_WC_DESCRIBE);
-    if (!latestVersion) {
-        return {
-            .status = Status::Failed,
-            .message = fmt::format("Failed to parse release tag '{}'", latest.tagName),
-            .latest = std::move(latest),
-        };
-    }
-    if (!currentVersion) {
-        return {
-            .status = Status::Failed,
-            .message = fmt::format("Failed to parse Dusklight version '{}'", DUSK_WC_DESCRIBE),
-            .latest = std::move(latest),
-        };
-    }
-
-    const bool updateAvailable = compare_version(*latestVersion, *currentVersion) > 0;
-    return {
-        .status = updateAvailable ? Status::UpdateAvailable : Status::UpToDate,
-        .message = updateAvailable ? "Update available" : "Dusklight is up to date",
-        .latest = std::move(latest),
-    };
-}
-
-}  // namespace dusk::update_check
diff --git a/src/dusk/update_check.hpp b/src/dusk/update_check.hpp
deleted file mode 100644
index 72c66449dc..0000000000
--- a/src/dusk/update_check.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef DUSK_UPDATE_CHECK_HPP
-#define DUSK_UPDATE_CHECK_HPP
-
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace dusk::update_check {
-
-enum class Status {
-    Disabled,
-    UpToDate,
-    UpdateAvailable,
-    Failed,
-};
-
-struct Asset {
-    std::string name;
-    std::string browserDownloadUrl;
-    std::string digest;
-};
-
-struct Release {
-    std::string tagName;
-    std::string name;
-    std::string htmlUrl;
-    std::string body;
-    std::vector<Asset> assets;
-};
-
-struct Result {
-    Status status = Status::Failed;
-    std::string message;
-    Release latest;
-};
-
-Result check_latest_github_release(std::string_view owner, std::string_view repo);
-
-}  // namespace dusk::update_check
-
-#endif  // DUSK_UPDATE_CHECK_HPP
diff --git a/src/dusk/utilities.cpp b/src/dusk/utilities.cpp
new file mode 100644
index 0000000000..92fe96c086
--- /dev/null
+++ b/src/dusk/utilities.cpp
@@ -0,0 +1,95 @@
+#include "utilities.hpp"
+
+#include <array>
+
+namespace dusk::utils {
+namespace {
+
+constexpr char kBase64Chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+constexpr std::array<uint32_t, 256> generate_crc32_table() {
+    std::array<uint32_t, 256> table{};
+    for (uint32_t i = 0; i < 256; ++i) {
+        uint32_t ch = i;
+        for (size_t j = 0; j < 8; ++j) {
+            ch = (ch & 1) != 0 ? 0xEDB88320 ^ ch >> 1 : ch >> 1;
+        }
+        table[i] = ch;
+    }
+    return table;
+}
+
+constexpr std::array<uint32_t, 256> kCrc32Table = generate_crc32_table();
+
+}  // namespace
+
+std::string base64_encode(const std::vector<uint8_t>& data) {
+    std::string out;
+    out.reserve((data.size() + 2) / 3 * 4);
+    for (size_t i = 0; i < data.size(); i += 3) {
+        const uint32_t rest = data.size() - i;
+        uint32_t chunk = data[i] << 16;
+        if (rest > 1) {
+            chunk |= data[i + 1] << 8;
+        }
+        if (rest > 2) {
+            chunk |= data[i + 2];
+        }
+        out.push_back(kBase64Chars[chunk >> 18 & 0x3F]);
+        out.push_back(kBase64Chars[chunk >> 12 & 0x3F]);
+        out.push_back(rest > 1 ? kBase64Chars[chunk >> 6 & 0x3F] : '=');
+        out.push_back(rest > 2 ? kBase64Chars[chunk & 0x3F] : '=');
+    }
+    return out;
+}
+
+bool base64_decode(const std::string& text, std::vector<uint8_t>& out) {
+    if (text.size() % 4 != 0) {
+        return false;
+    }
+    static const auto lookup = [] {
+        std::array<int8_t, 256> table;
+        table.fill(-1);
+        for (int i = 0; i < 64; ++i) {
+            table[static_cast<uint8_t>(kBase64Chars[i])] = static_cast<int8_t>(i);
+        }
+        return table;
+    }();
+    out.clear();
+    out.reserve(text.size() / 4 * 3);
+    for (size_t i = 0; i < text.size(); i += 4) {
+        uint32_t chunk = 0;
+        int pads = 0;
+        for (size_t j = 0; j < 4; ++j) {
+            const char c = text[i + j];
+            if (c == '=' && i + 4 == text.size() && j >= 2) {
+                ++pads;
+                chunk <<= 6;
+                continue;
+            }
+            const int8_t value = lookup[static_cast<uint8_t>(c)];
+            if (value < 0 || pads != 0) {
+                return false;
+            }
+            chunk = chunk << 6 | static_cast<uint32_t>(value);
+        }
+        out.push_back(chunk >> 16 & 0xFF);
+        if (pads < 2) {
+            out.push_back(chunk >> 8 & 0xFF);
+        }
+        if (pads < 1) {
+            out.push_back(chunk & 0xFF);
+        }
+    }
+    return true;
+}
+
+uint32_t crc32(const void* data, size_t size) {
+    const auto* bytes = static_cast<const uint8_t*>(data);
+    uint32_t crc = ~0u;
+    for (size_t i = 0; i < size; ++i) {
+        crc = crc >> 8 ^ kCrc32Table[static_cast<uint8_t>(crc ^ bytes[i])];
+    }
+    return ~crc;
+}
+}  // namespace dusk::utils
diff --git a/src/dusk/utilities.hpp b/src/dusk/utilities.hpp
new file mode 100644
index 0000000000..a559ccfe38
--- /dev/null
+++ b/src/dusk/utilities.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#ifdef crc32
+// miniz defines crc32 as an alias.
+#undef crc32
+#endif
+
+namespace dusk::utils {
+std::string base64_encode(const std::vector<uint8_t>& data);
+bool base64_decode(const std::string& text, std::vector<uint8_t>& out);
+uint32_t crc32(const void* data, size_t size);
+
+struct PaneCache {
+    uint64_t tag;
+    float origTransX;
+    float origTransY;
+    bool cached;
+};
+}  // namespace dusk::utils
diff --git a/src/dusk/version.cpp b/src/dusk/version.cpp
index e925dabaf8..fe98195126 100644
--- a/src/dusk/version.cpp
+++ b/src/dusk/version.cpp
@@ -26,8 +26,18 @@ void init() {
 
     if (game == "GZ2E"sv) {
         gameVersion = GameVersion::GcnUsa;
-    } else if (game == "GZ2P") {
+    } else if (game == "GZ2P"sv) {
         gameVersion = GameVersion::GcnPal;
+    } else if (game == "GZ2J"sv) {
+        gameVersion = GameVersion::GcnJpn;
+    } else if (game == "RZDE"sv && diskId.gameVersion == 0) {
+        gameVersion = GameVersion::WiiUsaRev0;
+    } else if (game == "RZDE"sv && diskId.gameVersion == 2) {
+        gameVersion = GameVersion::WiiUsa;
+    } else if (game == "RZDP"sv) {
+        gameVersion = GameVersion::WiiPal;
+    } else if (game == "RZDJ"sv) {
+        gameVersion = GameVersion::WiiJpn;
     } else {
         // TODO: Handle remaining valid versions.
         DuskLog.fatal("Unknown/unsupported game version in disc: {}", game);
@@ -50,8 +60,16 @@ bool isWii() {
         || getGameVersion() == GameVersion::WiiKor;
 }
 
+bool isLessThanWiiJpn() {
+    return getGameVersion() < GameVersion::WiiJpn;
+}
+
+bool isJpnOrLessThanWiiJpn() {
+    return isRegionJpn() || isLessThanWiiJpn();
+}
+
 bool isPalOrAtLeastWiiR2() {
-    return getGameVersion() == GameVersion::GcnPal || getGameVersion() >= GameVersion::WiiUsa;
+    return isRegionPal() || (isWii() && getGameVersion() != GameVersion::WiiUsaRev0);
 }
 
 bool isRegionJpn() {
diff --git a/include/dusk/version.hpp b/src/dusk/version.hpp
similarity index 73%
rename from include/dusk/version.hpp
rename to src/dusk/version.hpp
index fe393b049b..4979074d9a 100644
--- a/include/dusk/version.hpp
+++ b/src/dusk/version.hpp
@@ -1,23 +1,24 @@
-#ifndef DUSK_VERSION_HPP
-#define DUSK_VERSION_HPP
+#pragma once
 
 /**
  * Functionality for switching game behavior based on the loaded game version (e.g. PAL/JPN, GC/Wii)
  */
 namespace dusk::version {
     enum class GameVersion : u8 {
-        GcnUsa = VERSION_GCN_USA,
-        GcnPal = VERSION_GCN_PAL,
-        GcnJpn = VERSION_GCN_JPN,
-        WiiUsaRev0 = VERSION_WII_USA_R0,
-        WiiUsa = VERSION_WII_USA_R2,
-        WiiPal = VERSION_WII_PAL,
-        WiiJpn = VERSION_WII_JPN,
-        WiiKor = VERSION_WII_KOR,
+        WiiUsaRev0,
+        WiiPal,
+        WiiJpn,
+        GcnUsa,
+        GcnPal,
+        GcnJpn,
+        WiiUsa,
+        WiiKor,
     };
 
     bool isGcn();
     bool isWii();
+    bool isLessThanWiiJpn();
+    bool isJpnOrLessThanWiiJpn();
     bool isPalOrAtLeastWiiR2();
 
     bool isRegionPal();
@@ -62,6 +63,14 @@ namespace dusk::version {
 
         return defaultValue;
     }
-}  // namespace dusk::version
 
-#endif  // DUSK_VERSION_HPP
+    template<typename T>
+    T platformSelect(const T& gcn, const T& wii) {
+        return isGcn() ? gcn : wii;
+    }
+
+    template<typename T>
+    T regionSelect(const T& usa, const T& pal, const T& jpn) {
+        return isRegionUsa() ? usa : isRegionPal() ? pal : jpn;
+    }
+}  // namespace dusk::version
diff --git a/src/f_ap/f_ap_game.cpp b/src/f_ap/f_ap_game.cpp
index f4ccc32da0..a3a981eaba 100644
--- a/src/f_ap/f_ap_game.cpp
+++ b/src/f_ap/f_ap_game.cpp
@@ -1,36 +1,37 @@
 #include "f_ap/f_ap_game.h"
-#include <cstring>
-#include "DynamicLink.h"
-#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
-#include "JSystem/J3DGraphLoader/J3DModelSaver.h"
-#include "JSystem/JHostIO/JORFile.h"
-#include "JSystem/JKernel/JKRAram.h"
-#include "JSystem/JKernel/JKRAramArchive.h"
-#include "JSystem/JKernel/JKRSolidHeap.h"
-#include "JSystem/JUtility/JUTDbPrint.h"
 #include "SSystem/SComponent/c_counter.h"
-#include "d/actor/d_a_alink.h"
-#include "d/actor/d_a_grass.h"
-#include "d/actor/d_a_midna.h"
-#include "d/d_model.h"
-#include "d/d_tresure.h"
-#include "dusk/achievements.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/livesplit.h"
-#include "dusk/logging.h"
-#include "dusk/mod_loader.hpp"
 #include "f_op/f_op_camera_mng.h"
 #include "f_op/f_op_draw_tag.h"
 #include "f_op/f_op_overlap_mng.h"
 #include "f_op/f_op_scene_mng.h"
-#include "m_Do/m_Do_graphic.h"
 #include "m_Do/m_Do_main.h"
+#include "m_Do/m_Do_graphic.h"
+#include "DynamicLink.h"
+#include "JSystem/JKernel/JKRSolidHeap.h"
+#include "JSystem/JKernel/JKRAram.h"
+#include "JSystem/JKernel/JKRAramArchive.h"
+#include "JSystem/JUtility/JUTDbPrint.h"
+#include "JSystem/JHostIO/JORFile.h"
+#include "JSystem/J3DGraphLoader/J3DModelLoader.h"
+#include "JSystem/J3DGraphLoader/J3DModelSaver.h"
+#include "d/actor/d_a_alink.h"
+#include "d/actor/d_a_midna.h"
+#include "d/d_model.h"
+#include "d/actor/d_a_grass.h"
+#include "d/d_tresure.h"
+#include <cstring>
 
 #if TARGET_PC
-#include "tracy/Tracy.hpp"
-#include <dusk/gamepad_color.h>
-#include <dusk/autosave.h>
+#include "dusk/achievements.h"
+#include "dusk/autosave.h"
+#include "dusk/game_mode.hpp"
+#include "dusk/gamepad_color.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/logging.h"
 #include "dusk/menu_pointer.h"
+#include "dusk/mod_loader.hpp"
+
+#include <tracy/Tracy.hpp>
 #endif
 
 fapGm_HIO_c::fapGm_HIO_c() {
@@ -734,15 +735,15 @@ void fapGm_After() {
 
 #ifdef TARGET_PC
 static void fapGm_Before() {
-    dusk::frame_interp::begin_record();
+    dusk::interp::begin_record();
 }
 
 static void fapGm_AfterRecord() {
-    dusk::frame_interp::end_record();
+    dusk::interp::end_record();
     fapGm_After();
 }
 
-BOOL isRecording = false;
+DUSK_GAME_DATA BOOL isRecording = false;
 
 static void duskExecute() {
     dusk::menu_pointer::begin_game_frame();
@@ -759,23 +760,7 @@ static void duskExecute() {
         isRecording = false;
     }
 
-    if (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getTrigX(PAD_1)) {
-        if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
-            dynamic_cast<daAlink_c*>(link)->handleWolfHowl();
-        }
-    }
 
-    if ((mDoCPd_c::getHold(PAD_1) & (PAD_TRIGGER_R | PAD_TRIGGER_L)) == PAD_TRIGGER_R && mDoCPd_c::getTrigY(PAD_1)) {
-        if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
-            dynamic_cast<daAlink_c*>(link)->handleQuickTransform();
-        }
-    }
-
-    if (dusk::getSettings().game.moonJump && (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1))) {
-        if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
-            link->speed.y = 56.0f;
-        }
-    }
 
     if (dusk::getSettings().game.fastSpinner && mDoCPd_c::getHoldR(PAD_1)) {
         if (const auto link = g_dComIfG_gameInfo.play.getPlayer(0)) {
@@ -844,14 +829,19 @@ void fapGm_Execute() {
 #endif
 
     cCt_Counter(0);
-#ifdef TARGET_PC
-    dusk::speedrun::onGameFrame();
+#if TARGET_PC
+    dComIfGp_particle_calcMenu();
+    const dusk::gamemode::GameMode* gameMode =
+        dusk::gamemode::getGameModeManager().getCurrentGameMode();
+    if (gameMode) {
+        gameMode->invokeOnTickFunction();
+    }
     dusk::AchievementSystem::get().tick();
     dusk::menu_pointer::end_game_frame();
 #endif
 }
 
-fapGm_HIO_c g_HIO;
+DUSK_GAME_DATA fapGm_HIO_c g_HIO;
 
 void fapGm_Create() {
     // unused, unknown purpose
diff --git a/src/f_op/f_op_actor.cpp b/src/f_op/f_op_actor.cpp
index b628ebe9dd..db85ea3bf3 100644
--- a/src/f_op/f_op_actor.cpp
+++ b/src/f_op/f_op_actor.cpp
@@ -19,6 +19,10 @@
 #include "c/c_dylink.h"
 #include "m_Do/m_Do_printf.h"
 
+#if TARGET_PC
+#include "dusk/interp/dual_buffer.h"
+#endif
+
 #if DEBUG
 class print_error_check_c {
 public:
@@ -204,13 +208,13 @@ fopAc_ac_c::fopAc_ac_c() {}
 
 fopAc_ac_c::~fopAc_ac_c() {}
 
-int g_fopAc_type;
+DUSK_GAME_DATA int g_fopAc_type;
 
 BOOL fopAc_IsActor(void* i_actor) {
     return fpcM_IsJustType(g_fopAc_type, ((fopAc_ac_c*)i_actor)->actor_type);
 }
 
-u32 fopAc_ac_c::stopStatus;
+DUSK_GAME_DATA u32 fopAc_ac_c::stopStatus;
 
 static int fopAc_Draw(void* i_this) {
     fopAc_ac_c* actor = (fopAc_ac_c*)i_this;
@@ -413,6 +417,7 @@ static int fopAc_Delete(void* i_this) {
     #endif
 
     if (ret == TRUE) {
+        IF_DUSK(dusk::interp::erase_owned_buffers(actor));
         fopAcTg_ActorQTo(&actor->actor_tag);
         fopDwTg_DrawQTo(&actor->draw_tag);
         fopAcM_DeleteHeap((fopAc_ac_c*) i_this);
@@ -454,6 +459,10 @@ static int fopAc_Create(void* i_this) {
         actor->cullType = profile->cullType;
 
         fopAcM_prm_class* append = fopAcM_GetAppend(actor);
+#if TARGET_PC
+        actor->mItemGiveTag = append != NULL ? append->mItemGiveTag : 0;
+        actor->mItemGiveOriginalNo = append != NULL ? append->mItemGiveOriginalNo : 0xFF;
+#endif
         if (append != NULL) {
             fopAcM_SetParam(actor, append->base.parameters);
             actor->home.pos = append->base.position;
@@ -635,7 +644,7 @@ u8 fopAcM::HeapAdjustEntry;
 u8 fopAcM::HeapAdjustUnk;
 #endif
 
-actor_method_class g_fopAc_Method = {
+DUSK_GAME_DATA actor_method_class g_fopAc_Method = {
     (process_method_func)fopAc_Create,  (process_method_func)fopAc_Delete,
     (process_method_func)fopAc_Execute, (process_method_func)fopAc_IsDelete,
     (process_method_func)fopAc_Draw,
diff --git a/src/f_op/f_op_actor_mng.cpp b/src/f_op/f_op_actor_mng.cpp
index c9223a4d14..207a0471b3 100644
--- a/src/f_op/f_op_actor_mng.cpp
+++ b/src/f_op/f_op_actor_mng.cpp
@@ -184,19 +184,22 @@ fopAcM_prm_class* fopAcM_CreateAppend() {
         append->scale.z = 10;
         append->parent_id = fpcM_ERROR_PROCESS_ID_e;
         append->argument = -1;
+        IF_DUSK(append->mItemGiveOriginalNo = 0xFF;)
     }
     return append;
 }
 
 fopAcM_prm_class* createAppend(u16 i_setId, u32 i_parameters, const cXyz* i_pos, int i_roomNo,
-                               const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
-                               fpc_ProcID i_parentId) {
+    const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
+    fpc_ProcID i_parentId IF_DUSK_ARG(u32 i_itemGiveTag) IF_DUSK_ARG(u8 i_itemOriginalNo)) {
     fopAcM_prm_class* append = fopAcM_CreateAppend();
     if (append == NULL) {
         return NULL;
     }
 
     append->base.setID = i_setId;
+    IF_DUSK(append->mItemGiveTag = i_itemGiveTag;)
+    IF_DUSK(append->mItemGiveOriginalNo = i_itemOriginalNo;)
 
     if (i_pos != NULL) {
         append->base.position = *i_pos;
@@ -253,10 +256,11 @@ s32 fopAcM_delete(fpc_ProcID i_actorID) {
 }
 
 fpc_ProcID fopAcM_create(s16 i_procName, u16 i_setId, u32 i_parameters, const cXyz* i_pos,
-                         int i_roomNo, const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
-                         createFunc i_createFunc) {
+    int i_roomNo, const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
+    createFunc i_createFunc IF_DUSK_ARG(u32 i_itemGiveTag) IF_DUSK_ARG(u8 i_itemOriginalNo)) {
     fopAcM_prm_class* append = createAppend(i_setId, i_parameters, i_pos, i_roomNo, i_angle,
-                                            i_scale, i_argument, fpcM_ERROR_PROCESS_ID_e);
+        i_scale, i_argument, fpcM_ERROR_PROCESS_ID_e IF_DUSK_ARG(i_itemGiveTag)
+            IF_DUSK_ARG(i_itemOriginalNo));
     if (append == NULL) {
         return fpcM_ERROR_PROCESS_ID_e;
     }
@@ -265,16 +269,18 @@ fpc_ProcID fopAcM_create(s16 i_procName, u16 i_setId, u32 i_parameters, const cX
 }
 
 fpc_ProcID fopAcM_create(s16 i_procName, u32 i_parameters, const cXyz* i_pos, int i_roomNo,
-                         const csXyz* i_angle, const cXyz* i_scale, s8 i_argument) {
+    const csXyz* i_angle, const cXyz* i_scale, s8 i_argument IF_DUSK_ARG(u32 i_itemGiveTag)
+        IF_DUSK_ARG(u8 i_itemOriginalNo)) {
     return fopAcM_create(i_procName, 0xFFFF, i_parameters, i_pos, i_roomNo, i_angle, i_scale,
-                         i_argument, NULL);
+        i_argument, NULL IF_DUSK_ARG(i_itemGiveTag) IF_DUSK_ARG(i_itemOriginalNo));
 }
 
 fopAc_ac_c* fopAcM_fastCreate(s16 i_procName, u32 i_parameters, const cXyz* i_pos, int i_roomNo,
-                              const csXyz* i_angle, const cXyz* i_scale, s8 i_argument,
-                              createFunc i_createFunc, void* i_createFuncData) {
-    fopAcM_prm_class* append = createAppend(0xFFFF, i_parameters, i_pos, i_roomNo, i_angle, i_scale,
-                                            i_argument, fpcM_ERROR_PROCESS_ID_e);
+    const csXyz* i_angle, const cXyz* i_scale, s8 i_argument, createFunc i_createFunc,
+    void* i_createFuncData IF_DUSK_ARG(u32 i_itemGiveTag) IF_DUSK_ARG(u8 i_itemOriginalNo)) {
+    fopAcM_prm_class* append =
+        createAppend(0xFFFF, i_parameters, i_pos, i_roomNo, i_angle, i_scale, i_argument,
+            fpcM_ERROR_PROCESS_ID_e IF_DUSK_ARG(i_itemGiveTag) IF_DUSK_ARG(i_itemOriginalNo));
     if (append == NULL) {
         return NULL;
     }
@@ -379,14 +385,14 @@ s32 fopAcM_callCallback(fopAc_ac_c* i_actor, heapCallbackFunc i_callback, JKRHea
     return ret;
 }
 
-u8 fopAcM::HeapAdjustEntry;
-u8 fopAcM::HeapAdjustUnk;
-u8 fopAcM::HeapAdjustVerbose;
-u8 fopAcM::HeapAdjustQuiet;
-u8 fopAcM::HeapDummyCreate;
-u8 fopAcM::HeapSkipMargin;
-u8 fopAcM::HeapDummyCheck;
-int fopAcM::HeapAdjustMargin =
+DUSK_GAME_DATA u8 fopAcM::HeapAdjustEntry;
+DUSK_GAME_DATA u8 fopAcM::HeapAdjustUnk;
+DUSK_GAME_DATA u8 fopAcM::HeapAdjustVerbose;
+DUSK_GAME_DATA u8 fopAcM::HeapAdjustQuiet;
+DUSK_GAME_DATA u8 fopAcM::HeapDummyCreate;
+DUSK_GAME_DATA u8 fopAcM::HeapSkipMargin;
+DUSK_GAME_DATA u8 fopAcM::HeapDummyCheck;
+DUSK_GAME_DATA int fopAcM::HeapAdjustMargin =
 #if VERSION == VERSION_SHIELD_DEBUG
     0x1000;
 #else
@@ -914,7 +920,7 @@ bool fopAcM_checkCullingBox(Mtx m, f32 x1, f32 y1, f32 z1, f32 x2, f32 y2, f32 z
         return false;
 }
 
-cull_box l_cullSizeBox[fopAc_CULLBOX_MAX_e] = {
+DUSK_GAME_DATA cull_box l_cullSizeBox[fopAc_CULLBOX_MAX_e] = {
     {
         {-40.0f, 0.0f, -40.0f},
         {40.0f, 125.0f, 40.0f},
@@ -979,7 +985,7 @@ cull_box l_cullSizeBox[fopAc_CULLBOX_MAX_e] = {
 #endif
 };
 
-cull_sphere l_cullSizeSphere[fopAc_CULLSPHERE_MAX_e] = {
+DUSK_GAME_DATA cull_sphere l_cullSizeSphere[fopAc_CULLSPHERE_MAX_e] = {
     {
         {0.0f, 0.0f, 0.0f},
         80.0f,
@@ -1385,8 +1391,8 @@ fopAc_ac_c* fopAcM_getEventPartner(fopAc_ac_c const* i_actor) {
 }
 
 fpc_ProcID fopAcM_createItemForPresentDemo(cXyz const* i_pos, int i_itemNo, u8 param_2,
-                                           int i_itemBitNo, int i_roomNo, csXyz const* i_angle,
-                                           cXyz const* i_scale) {
+    int i_itemBitNo, int i_roomNo, csXyz const* i_angle,
+    cXyz const* i_scale IF_DUSK_ARG(u32 i_itemGiveTag)) {
     JUT_ASSERT(3214, 0 <= i_itemNo && i_itemNo < 256);
     dComIfGp_event_setGtItm(i_itemNo);
 
@@ -1395,14 +1401,14 @@ fpc_ProcID fopAcM_createItemForPresentDemo(cXyz const* i_pos, int i_itemNo, u8 p
         return fpcM_ERROR_PROCESS_ID_e;
     }
 
-    return fopAcM_createDemoItem(i_pos, i_itemNo, i_itemBitNo, i_angle, i_roomNo, i_scale, param_2);
+    return fopAcM_createDemoItem(i_pos, i_itemNo, i_itemBitNo, i_angle, i_roomNo, i_scale,
+        param_2 IF_DUSK_ARG(i_itemGiveTag));
 }
 
 fpc_ProcID fopAcM_createItemForTrBoxDemo(cXyz const* i_pos, int i_itemNo, int i_itemBitNo,
-                                         int i_roomNo, csXyz const* i_angle, cXyz const* i_scale) {
-   
-   JUT_ASSERT(3259, 0 <= i_itemNo && i_itemNo < 256);
-   dComIfGp_event_setGtItm(i_itemNo);
+    int i_roomNo, csXyz const* i_angle, cXyz const* i_scale IF_DUSK_ARG(u32 i_itemGiveTag)) {
+    JUT_ASSERT(3259, 0 <= i_itemNo && i_itemNo < 256);
+    dComIfGp_event_setGtItm(i_itemNo);
 
     if (i_itemNo == dItemNo_NONE_e) {
         OS_REPORT("ゲットデモ用なのに「ハズレ」です！[%d]\n", i_itemNo); // Even though it is for a Get Demo, it is a 'Miss'!
@@ -1410,7 +1416,8 @@ fpc_ProcID fopAcM_createItemForTrBoxDemo(cXyz const* i_pos, int i_itemNo, int i_
     }
 
     u8 param_7 = 0;
-    return fopAcM_createDemoItem(i_pos, i_itemNo, i_itemBitNo, i_angle, i_roomNo, i_scale, param_7);
+    return fopAcM_createDemoItem(i_pos, i_itemNo, i_itemBitNo, i_angle, i_roomNo, i_scale,
+        param_7 IF_DUSK_ARG(i_itemGiveTag));
 }
 
 struct ItemTableList {
@@ -1566,8 +1573,8 @@ fpc_ProcID fopAcM_createItemFromTable(cXyz const* i_pos, int i_itemNo, int i_ite
 }
 
 fpc_ProcID fopAcM_createDemoItem(const cXyz* i_pos, int i_itemNo, int i_itemBitNo,
-                                 const csXyz* i_angle, int i_roomNo, const cXyz* scale,
-                                 u8 param_7) {
+    const csXyz* i_angle, int i_roomNo, const cXyz* scale,
+    u8 param_7 IF_DUSK_ARG(u32 i_itemGiveTag)) {
     // clang-format off
     JUT_ASSERT(3824, 0 <= i_itemNo && i_itemNo < 256 && (-1 <= i_itemBitNo && i_itemBitNo < (dSv_info_c::DAN_ITEM + dSv_info_c::MEMORY_ITEM + dSv_info_c::ZONE_ITEM )) || i_itemBitNo == 255);
     // clang-format on
@@ -1577,17 +1584,52 @@ fpc_ProcID fopAcM_createDemoItem(const cXyz* i_pos, int i_itemNo, int i_itemBitN
     }
 
     u32 params = (i_itemNo & 0xFF) << 0x0 | (i_itemBitNo & 0x7F) << 0x8 | (param_7 & 0xFF) << 0x10;
-    return fopAcM_create(fpcNm_Demo_Item_e, params, i_pos, i_roomNo, i_angle, scale, -1);
+    return fopAcM_create(
+        fpcNm_Demo_Item_e, params, i_pos, i_roomNo, i_angle, scale, -1 IF_DUSK_ARG(i_itemGiveTag));
 }
 
 fpc_ProcID fopAcM_createItemForBoss(const cXyz* i_pos, int i_itemNo, int i_roomNo,
-                                    const csXyz* i_angle, const cXyz* i_scale, f32 i_speedF,
-                                    f32 i_speedY, int param_8) {
+    const csXyz* i_angle, const cXyz* i_scale, f32 i_speedF, f32 i_speedY,
+    int param_8 IF_DUSK_ARG(const char* i_itemCheckName)) {
     int _ = -1;
+#if TARGET_PC
+    const u8 originalItemNo = i_itemNo & 0xFF;
+    // Overridden item checks do not set StageLife, so boss containers
+    // also need a persistent local item bit.
+    constexpr u8 kBossHeartContainerFlag = 0x9F;
+    if (originalItemNo == dItemNo_UTAWA_HEART_e && param_8 == -1) {
+        param_8 = kBossHeartContainerFlag;
+    }
+    u32 giveTag;
+    if (i_itemCheckName != NULL) {
+        i_itemNo = dusk::mods::item_check(i_itemCheckName, originalItemNo, NULL);
+        giveTag = dusk::mods::item_give_tag(i_itemCheckName);
+    } else {
+        i_itemNo = dusk::mods::item_check_boss(originalItemNo, NULL);
+        giveTag = dusk::mods::item_give_tag_boss();
+    }
+
+    if (i_itemNo == dItemNo_NONE_e) {
+        const auto itemCheck = dusk::mods::item_check_commit(giveTag, originalItemNo, NULL);
+        i_itemNo = itemCheck.itemNo;
+        if (i_itemNo == dItemNo_NONE_e) {
+            dusk::mods::item_check_complete(itemCheck, NULL);
+            dComIfGs_onItem(param_8, i_roomNo);
+            return fpcM_ERROR_PROCESS_ID_e;
+        }
+    }
+
+    if (i_itemNo != originalItemNo) {
+        const u32 params = 0xFFFF0000 | param_8 << 8 | (i_itemNo & 0xFF);
+        dusk::mods::set_boss_item_actor_speeds(i_speedF, i_speedY);
+        return fopAcM_create(fpcNm_Obj_LifeContainer_e, params, i_pos, i_roomNo, i_angle,
+            i_scale, -1, giveTag, originalItemNo);
+    }
+#endif
     u32 params = 0xFFFF0000 | param_8 << 8 | (i_itemNo & 0xFF);
 
-    fopAc_ac_c* actor = fopAcM_fastCreate(fpcNm_Obj_LifeContainer_e, params, i_pos, i_roomNo, i_angle,
-                                          i_scale, -1, NULL, NULL);
+    fopAc_ac_c* actor = fopAcM_fastCreate(fpcNm_Obj_LifeContainer_e, params, i_pos, i_roomNo,
+        i_angle, i_scale, -1, NULL, NULL IF_DUSK_ARG(giveTag) IF_DUSK_ARG(originalItemNo));
     if (actor != NULL) {
         actor->speedF = i_speedF;
         actor->speed.y = i_speedY;
@@ -2097,11 +2139,11 @@ void fopAcM_GetRealMax(const fopAc_ac_c*) {
     static cXyz max;
 }
 
-dBgS_ObjLinChk fopAcM_lc_c::mLineCheck;
+DUSK_GAME_DATA dBgS_ObjLinChk fopAcM_lc_c::mLineCheck;
 
-dBgS_ObjGndChk fopAcM_gc_c::mGndCheck;
+DUSK_GAME_DATA dBgS_ObjGndChk fopAcM_gc_c::mGndCheck;
 
-f32 fopAcM_gc_c::mGroundY;
+DUSK_GAME_DATA f32 fopAcM_gc_c::mGroundY;
 
 void fopAcM_effSmokeSet1(u32* param_0, u32* param_1, cXyz const* param_2, csXyz const* param_3,
                          f32 param_4, dKy_tevstr_c const* param_5, int param_6) {
@@ -2316,13 +2358,13 @@ fopAc_ac_c* fopAcM_searchFromName4Event(char const* i_name, s16 i_eventID) {
     return fopAcM_Search((fopAcIt_JudgeFunc)fopAcM_findObject4EventCB, &prm);
 }
 
-dBgS_ObjRoofChk fopAcM_rc_c::mRoofCheck;
+DUSK_GAME_DATA dBgS_ObjRoofChk fopAcM_rc_c::mRoofCheck;
 
-dBgS_WtrChk fopAcM_wt_c::mWaterCheck;
+DUSK_GAME_DATA dBgS_WtrChk fopAcM_wt_c::mWaterCheck;
 
-f32 fopAcM_rc_c::mRoofY;
+DUSK_GAME_DATA f32 fopAcM_rc_c::mRoofY;
 
-f32 fopAcM_wt_c::mWaterY;
+DUSK_GAME_DATA f32 fopAcM_wt_c::mWaterY;
 
 s32 fopAcM_getWaterY(cXyz const* param_0, f32* o_waterY) {
     if (fopAcM_wt_c::waterCheck(param_0) && fopAcM_wt_c::getPolyAtt0() != 6) {
diff --git a/src/f_op/f_op_actor_tag.cpp b/src/f_op/f_op_actor_tag.cpp
index 2f0518b595..9b8b9fe9a9 100644
--- a/src/f_op/f_op_actor_tag.cpp
+++ b/src/f_op/f_op_actor_tag.cpp
@@ -6,7 +6,7 @@
 #include "f_op/f_op_actor_tag.h"
 #include "SSystem/SComponent/c_list.h"
 
-node_list_class g_fopAcTg_Queue = {NULL, NULL, 0};
+DUSK_GAME_DATA node_list_class g_fopAcTg_Queue = {NULL, NULL, 0};
 
 int fopAcTg_ToActorQ(create_tag_class* i_createTag) {
     return cTg_Addition(&g_fopAcTg_Queue, i_createTag);
diff --git a/src/f_op/f_op_camera.cpp b/src/f_op/f_op_camera.cpp
index 567f80904f..42bf619d69 100644
--- a/src/f_op/f_op_camera.cpp
+++ b/src/f_op/f_op_camera.cpp
@@ -101,7 +101,7 @@ static int fopCam_Create(void* i_this) {
     return ret;
 }
 
-leafdraw_method_class g_fopCam_Method = {
+DUSK_GAME_DATA leafdraw_method_class g_fopCam_Method = {
     (process_method_func)fopCam_Create,  (process_method_func)fopCam_Delete,
     (process_method_func)fopCam_Execute, (process_method_func)fopCam_IsDelete,
     (process_method_func)fopCam_Draw,
diff --git a/src/f_op/f_op_draw_tag.cpp b/src/f_op/f_op_draw_tag.cpp
index d158723fd2..7026d4d153 100644
--- a/src/f_op/f_op_draw_tag.cpp
+++ b/src/f_op/f_op_draw_tag.cpp
@@ -8,7 +8,7 @@
 #include "SSystem/SComponent/c_tag.h"
 #include "global.h"
 
-node_lists_tree_class g_fopDwTg_Queue = {NULL, 0};
+DUSK_GAME_DATA node_lists_tree_class g_fopDwTg_Queue = {NULL, 0};
 
 void fopDwTg_ToDrawQ(create_tag_class* i_createTag, int i_priority) {
     cTg_AdditionToTree(&g_fopDwTg_Queue, i_priority, i_createTag);
diff --git a/src/f_op/f_op_kankyo.cpp b/src/f_op/f_op_kankyo.cpp
index 00e2eb838c..1c8a2dfb8b 100644
--- a/src/f_op/f_op_kankyo.cpp
+++ b/src/f_op/f_op_kankyo.cpp
@@ -107,7 +107,7 @@ static int fopKy_Create(void* i_this) {
     return ret;
 }
 
-leafdraw_method_class g_fopKy_Method = {
+DUSK_GAME_DATA leafdraw_method_class g_fopKy_Method = {
     (process_method_func)fopKy_Create,  (process_method_func)fopKy_Delete,
     (process_method_func)fopKy_Execute, (process_method_func)fopKy_IsDelete,
     (process_method_func)fopKy_Draw,
diff --git a/src/f_op/f_op_msg.cpp b/src/f_op/f_op_msg.cpp
index f5cbf98b1c..bc24f1d539 100644
--- a/src/f_op/f_op_msg.cpp
+++ b/src/f_op/f_op_msg.cpp
@@ -88,7 +88,7 @@ int fopMsg_Create(void* i_this) {
             a_this->talk_actor = append->talk_actor;
             a_this->pos = append->pos;
             a_this->msg_idx = append->msg_idx;
-            a_this->field_0xf0 = append->field_0x14;
+            a_this->select_msg_idx = append->select_msg_idx;
             a_this->field_0xf4 = append->field_0x18;
         }
     }
@@ -101,7 +101,7 @@ int fopMsg_Create(void* i_this) {
     return ret;
 }
 
-leafdraw_method_class g_fopMsg_Method = {
+DUSK_GAME_DATA leafdraw_method_class g_fopMsg_Method = {
     (process_method_func)fopMsg_Create,  (process_method_func)fopMsg_Delete,
     (process_method_func)fopMsg_Execute, (process_method_func)fopMsg_IsDelete,
     (process_method_func)fopMsg_Draw,
diff --git a/src/f_op/f_op_msg_mng.cpp b/src/f_op/f_op_msg_mng.cpp
index a9ce8c78d0..812c9ec2cd 100644
--- a/src/f_op/f_op_msg_mng.cpp
+++ b/src/f_op/f_op_msg_mng.cpp
@@ -31,7 +31,7 @@ void fopMsgM_Delete(void* i_this) {
 }
 
 static fopMsg_prm_class* createAppend(fopAc_ac_c* i_talkActor, cXyz* i_pos, u32* i_msgIdx,
-                                      u32* param_3, fpc_ProcID param_4) {
+                                      u32* i_selectMsgIdx, fpc_ProcID param_4) {
     fopMsg_prm_class* append = (fopMsg_prm_class*)cMl::memalignB(-4, sizeof(fopMsg_prm_class));
     if (append == NULL) {
         return NULL;
@@ -46,10 +46,10 @@ static fopMsg_prm_class* createAppend(fopAc_ac_c* i_talkActor, cXyz* i_pos, u32*
         i_msgIdx = NULL;
     }
 
-    if (param_3 != NULL) {
-        append->field_0x14 = *param_3;
+    if (i_selectMsgIdx != NULL) {
+        append->select_msg_idx = *i_selectMsgIdx;
     } else {
-        param_3 = NULL;
+        i_selectMsgIdx = NULL;
     }
 
     if (i_pos != NULL) {
@@ -73,7 +73,7 @@ static fopMsg_prm_timer* createTimerAppend(int i_mode, u32 i_limitMs, u8 i_type,
 
     appen->talk_actor = NULL;
     appen->msg_idx = 0;
-    appen->field_0x14 = 0;
+    appen->select_msg_idx = 0;
     appen->pos = cXyz(0.0f, 0.0f, 0.0f);
     appen->field_0x18 = param_8;
     appen->timer_mode = i_mode;
@@ -88,9 +88,9 @@ static fopMsg_prm_timer* createTimerAppend(int i_mode, u32 i_limitMs, u8 i_type,
 }
 
 fpc_ProcID fopMsgM_create(s16 i_procName, fopAc_ac_c* i_talkActor, cXyz* i_pos, u32* i_msgIdx,
-                          u32* param_4, FastCreateReqFunc i_createFunc) {
+                          u32* i_selectMsgIdx, FastCreateReqFunc i_createFunc) {
     fopMsg_prm_class* append =
-        createAppend(i_talkActor, i_pos, i_msgIdx, param_4, fpcM_ERROR_PROCESS_ID_e);
+        createAppend(i_talkActor, i_pos, i_msgIdx, i_selectMsgIdx, fpcM_ERROR_PROCESS_ID_e);
     if (append == NULL) {
         return fpcM_ERROR_PROCESS_ID_e;
     }
@@ -115,7 +115,7 @@ void dummySet() {
     csXyz().set(0, 0, 0);
 }
 
-fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, fopAc_ac_c* i_talkActor, u32 param_2) {
+fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, fopAc_ac_c* i_talkActor, u32 i_selectMsgIdx) {
     if (dComIfGp_isHeapLockFlag() == 8) {
         dMeter2Info_getMeterClass()->emphasisButtonDelete();
     }
@@ -146,16 +146,16 @@ fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, fopAc_ac_c* i_talkActor, u32 param_2
     if (msg != NULL && msg->mode == fopMsg_MODE_MSG_PREPARING_e) {
         msg->pos.set(pos);
         msg->msg_idx = i_msgIdx;
-        msg->field_0xf0 = param_2;
+        msg->select_msg_idx = i_selectMsgIdx;
         msg->talk_actor = i_talkActor;
-        msg->setMessageIndex(i_msgIdx, param_2, false);
+        msg->setMessageIndex(i_msgIdx, i_selectMsgIdx, false);
         return i_msgID;
     }
 
     return 0;
 }
 
-fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, u32 param_1) {
+fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, u32 i_selectMsgIdx) {
     if (dComIfGp_isHeapLockFlag() == 8) {
         dMeter2Info_getMeterClass()->emphasisButtonDelete();
     }
@@ -177,15 +177,15 @@ fpc_ProcID fopMsgM_messageSet(u32 i_msgIdx, u32 param_1) {
         if (msg->mode == fopMsg_MODE_MSG_PREPARING_e) {
             msg->pos.set(pos);
             msg->msg_idx = i_msgIdx;
-            msg->field_0xf0 = param_1;
+            msg->select_msg_idx = i_selectMsgIdx;
             msg->talk_actor = actor;
             msg->setTalkPartner(NULL);
-            msg->setMessageIndex(i_msgIdx, param_1, false);
+            msg->setMessageIndex(i_msgIdx, i_selectMsgIdx, false);
             return i_msgID;
         } else if (msg->mode == fopMsg_MODE_MSG_CONTINUE_e) {
             msg->pos.set(pos);
             msg->msg_idx = i_msgIdx;
-            msg->field_0xf0 = param_1;
+            msg->select_msg_idx = i_selectMsgIdx;
             msg->talk_actor = actor;
             return i_msgID;
         }
@@ -217,7 +217,7 @@ fpc_ProcID fopMsgM_messageSetDemo(u32 i_msgidx) {
     if (msg != NULL && msg->mode == fopMsg_MODE_MSG_PREPARING_e) {
         msg->pos.set(pos);
         msg->msg_idx = i_msgidx;
-        msg->field_0xf0 = 1000;
+        msg->select_msg_idx = 1000;
         msg->talk_actor = NULL_;
         msg->setMessageIndexDemo(i_msgidx, false);
         return i_msgID;
diff --git a/src/f_op/f_op_overlap.cpp b/src/f_op/f_op_overlap.cpp
index 5cdaea666b..56a81b4a23 100644
--- a/src/f_op/f_op_overlap.cpp
+++ b/src/f_op/f_op_overlap.cpp
@@ -59,7 +59,7 @@ static s32 fopOvlp_Create(void* i_this) {
     return ret;
 }
 
-leafdraw_method_class g_fopOvlp_Method = {
+DUSK_GAME_DATA leafdraw_method_class g_fopOvlp_Method = {
     (process_method_func)fopOvlp_Create,  (process_method_func)fopOvlp_Delete,
     (process_method_func)fopOvlp_Execute, (process_method_func)fopOvlp_IsDelete,
     (process_method_func)fopOvlp_Draw,
diff --git a/src/f_op/f_op_overlap_req.cpp b/src/f_op/f_op_overlap_req.cpp
index 37b901c706..a5a7fa0e70 100644
--- a/src/f_op/f_op_overlap_req.cpp
+++ b/src/f_op/f_op_overlap_req.cpp
@@ -7,7 +7,10 @@
 #include "f_op/f_op_overlap_req.h"
 #include "f_pc/f_pc_manager.h"
 
+#ifdef TARGET_PC
+#include "dusk/game_mode.hpp"
 #include "dusk/speedrun.h"
+#endif
 
 void fopOvlpReq_SetPeektime(overlap_request_class*, u16);
 
@@ -19,15 +22,16 @@ static int fopOvlpReq_phase_Done(overlap_request_class* i_overlapReq) {
         i_overlapReq->field_0x8 = 0;
         i_overlapReq->field_0xc = 0;
 
-        #if TARGET_PC
-        if (dusk::getSettings().game.speedrunMode) {
-            if (dusk::m_speedrunInfo.m_isRunStarted) {
-                dusk::m_speedrunInfo.m_isPauseIGT = false;
-                dusk::m_speedrunInfo.m_totalLoadTime += OSGetTime() - dusk::m_speedrunInfo.m_loadStartTimestamp;
-                dusk::m_speedrunInfo.m_loadStartTimestamp = OSGetTime();
+#if TARGET_PC
+        if (dusk::speedrun::isActive()) {
+            if (dusk::speedrun::g_speedrunInfo.m_isRunStarted) {
+                dusk::speedrun::g_speedrunInfo.m_isPauseIGT = false;
+                dusk::speedrun::g_speedrunInfo.m_totalLoadTime +=
+                    OSGetTime() - dusk::speedrun::g_speedrunInfo.m_loadStartTimestamp;
+                dusk::speedrun::g_speedrunInfo.m_loadStartTimestamp = OSGetTime();
             }
         }
-        #endif
+#endif
         return cPhs_NEXT_e;
     }
 
@@ -95,9 +99,9 @@ static int fopOvlpReq_phase_Create(overlap_request_class* i_overlapReq) {
         fpcM_Create(i_overlapReq->procname, NULL, NULL);
 
 #if TARGET_PC
-    if (dusk::m_speedrunInfo.m_isRunStarted) {
-        dusk::m_speedrunInfo.m_isPauseIGT = true;
-        dusk::m_speedrunInfo.m_loadStartTimestamp = OSGetTime();
+    if (dusk::speedrun::isActive() && dusk::speedrun::g_speedrunInfo.m_isRunStarted) {
+        dusk::speedrun::g_speedrunInfo.m_isPauseIGT = true;
+        dusk::speedrun::g_speedrunInfo.m_loadStartTimestamp = OSGetTime();
     }
 #endif
 
diff --git a/src/f_op/f_op_scene.cpp b/src/f_op/f_op_scene.cpp
index ba1a8e0175..17292ac03d 100644
--- a/src/f_op/f_op_scene.cpp
+++ b/src/f_op/f_op_scene.cpp
@@ -62,7 +62,7 @@ static int fopScn_Create(void* i_this) {
     return ret;
 }
 
-leafdraw_method_class g_fopScn_Method = {
+DUSK_GAME_DATA leafdraw_method_class g_fopScn_Method = {
     (process_method_func)fopScn_Create,  
     (process_method_func)fopScn_Delete,
     (process_method_func)fopScn_Execute, 
diff --git a/src/f_op/f_op_scene_tag.cpp b/src/f_op/f_op_scene_tag.cpp
index 632f9fd159..a093deb6e3 100644
--- a/src/f_op/f_op_scene_tag.cpp
+++ b/src/f_op/f_op_scene_tag.cpp
@@ -9,7 +9,7 @@ void fopScnTg_QueueTo(scene_tag_class* i_sceneTag) {
     cTg_SingleCut(&i_sceneTag->base);
 }
 
-node_list_class g_fopScnTg_SceneList = {NULL, NULL, 0};
+DUSK_GAME_DATA node_list_class g_fopScnTg_SceneList = {NULL, NULL, 0};
 
 void fopScnTg_ToQueue(scene_tag_class* i_sceneTag) {
     cTg_Addition(&g_fopScnTg_SceneList, &i_sceneTag->base);
diff --git a/src/f_op/f_op_view.cpp b/src/f_op/f_op_view.cpp
index c48f7eb0f7..39792a88a1 100644
--- a/src/f_op/f_op_view.cpp
+++ b/src/f_op/f_op_view.cpp
@@ -38,7 +38,7 @@ s32 fopVw_Create(void* i_this) {
     return ret;
 }
 
-leafdraw_method_class g_fopVw_Method = {
+DUSK_GAME_DATA leafdraw_method_class g_fopVw_Method = {
     (process_method_func)fopVw_Create,  (process_method_func)fopVw_Delete,
     (process_method_func)fopVw_Execute, (process_method_func)fopVw_IsDelete,
     (process_method_func)fopVw_Draw,
diff --git a/src/f_pc/f_pc_base.cpp b/src/f_pc/f_pc_base.cpp
index 7bb53ae634..f876774214 100644
--- a/src/f_pc/f_pc_base.cpp
+++ b/src/f_pc/f_pc_base.cpp
@@ -41,7 +41,7 @@ BOOL fpcBs_Is_JustOfType(int i_typeA, int i_typeB) {
     }
 }
 
-int g_fpcBs_type;
+DUSK_GAME_DATA int g_fpcBs_type;
 
 int fpcBs_MakeOfType(int* i_type) {
     static int t_type = 0x9130000;
diff --git a/src/f_pc/f_pc_create_tag.cpp b/src/f_pc/f_pc_create_tag.cpp
index 89578cd54b..bdafc280c0 100644
--- a/src/f_pc/f_pc_create_tag.cpp
+++ b/src/f_pc/f_pc_create_tag.cpp
@@ -5,7 +5,7 @@
 
 #include "f_pc/f_pc_create_tag.h"
 
-node_list_class g_fpcCtTg_Queue = {NULL, NULL, 0};
+DUSK_GAME_DATA node_list_class g_fpcCtTg_Queue = {NULL, NULL, 0};
 
 void fpcCtTg_ToCreateQ(create_tag* i_createTag) {
     cTg_Addition(&g_fpcCtTg_Queue, &i_createTag->base);
diff --git a/src/f_pc/f_pc_delete_tag.cpp b/src/f_pc/f_pc_delete_tag.cpp
index e627f5ec8c..38c12ab1e2 100644
--- a/src/f_pc/f_pc_delete_tag.cpp
+++ b/src/f_pc/f_pc_delete_tag.cpp
@@ -7,7 +7,7 @@
 #include "f_pc/f_pc_delete_tag.h"
 #include "f_pc/f_pc_debug_sv.h"
 
-node_list_class g_fpcDtTg_Queue = {NULL, NULL, 0};
+DUSK_GAME_DATA node_list_class g_fpcDtTg_Queue = {NULL, NULL, 0};
 
 BOOL fpcDtTg_IsEmpty() {
     if (g_fpcDtTg_Queue.mSize == 0) {
diff --git a/src/f_pc/f_pc_draw.cpp b/src/f_pc/f_pc_draw.cpp
index 8b775257fc..8c53618219 100644
--- a/src/f_pc/f_pc_draw.cpp
+++ b/src/f_pc/f_pc_draw.cpp
@@ -8,9 +8,10 @@
 #include "f_pc/f_pc_leaf.h"
 #include "f_pc/f_pc_node.h"
 #include "f_pc/f_pc_pause.h"
-#include "dusk/frame_interpolation.h"
-#include <cstdio>
+
+#if TARGET_PC
 #include "dusk/logging.h"
+#endif
 
 int fpcDw_Execute(base_process_class* i_proc) {
     if (!fpcPause_IsEnable(i_proc, 2)) {
diff --git a/src/f_pc/f_pc_layer.cpp b/src/f_pc/f_pc_layer.cpp
index 2f5da47251..81cea8fd1c 100644
--- a/src/f_pc/f_pc_layer.cpp
+++ b/src/f_pc/f_pc_layer.cpp
@@ -82,7 +82,7 @@ void fpcLy_CreatedMesg(layer_class* i_layer) {
     }
 }
 
-layer_class l_fpcLy_Crear = {
+DUSK_GAME_DATA layer_class l_fpcLy_Crear = {
     NULL, NULL, 0, 0xFFFFFFFF, NULL, 0, NULL, NULL, NULL, 0, 0, 0,
 };
 
diff --git a/src/f_pc/f_pc_leaf.cpp b/src/f_pc/f_pc_leaf.cpp
index 6737e58f67..e2fdd97fb0 100644
--- a/src/f_pc/f_pc_leaf.cpp
+++ b/src/f_pc/f_pc_leaf.cpp
@@ -7,7 +7,7 @@
 #include "f_pc/f_pc_debug_sv.h"
 
 #if TARGET_PC
-#include "dusk/frame_interpolation.h"
+#include "dusk/game_clock.h"
 #endif
 
 s16 fpcLf_GetPriority(const leafdraw_class* i_leaf) {
@@ -21,7 +21,7 @@ int fpcLf_DrawMethod(leafdraw_method_class DUSK_CONST* i_methods, void* i_proces
 int fpcLf_Draw(leafdraw_class* i_leaf) {
     int ret = 0;
 #if TARGET_PC
-    if (!i_leaf->draw_interp_frame && !dusk::frame_interp::is_sim_frame()) {
+    if (!i_leaf->draw_interp_frame && !dusk::game_clock::is_sim_frame()) {
         return ret;
     }
 #endif
@@ -56,7 +56,7 @@ int fpcLf_Delete(leafdraw_class* i_leaf) {
     return ret;
 }
 
-int g_fpcLf_type;
+DUSK_GAME_DATA int g_fpcLf_type;
 
 int fpcLf_Create(leafdraw_class* i_leaf) {
     if (LEAFDRAW_BASE(i_leaf).state.init_state == 0) {
@@ -65,16 +65,14 @@ int fpcLf_Create(leafdraw_class* i_leaf) {
         LEAFDRAW_BASE(i_leaf).subtype = fpcBs_MakeOfType(&g_fpcLf_type);
         fpcDwPi_Init(&i_leaf->draw_priority, pprofile->priority);
         i_leaf->unk_0xBC = 0;
-#if TARGET_PC
-        i_leaf->draw_interp_frame = false;
-#endif
+        IF_DUSK(i_leaf->draw_interp_frame = false);
     }
 
     int ret = fpcMtd_Create(&i_leaf->leaf_methods->base, i_leaf);
     return ret;
 }
 
-leafdraw_method_class DUSK_CONST g_fpcLf_Method = {
+DUSK_GAME_DATA leafdraw_method_class DUSK_CONST g_fpcLf_Method = {
     (process_method_func)fpcLf_Create,  (process_method_func)fpcLf_Delete,
     (process_method_func)fpcLf_Execute, (process_method_func)fpcLf_IsDelete,
     (process_method_func)fpcLf_Draw,
diff --git a/src/f_pc/f_pc_line.cpp b/src/f_pc/f_pc_line.cpp
index 6473dfbee3..7cd392f7a2 100644
--- a/src/f_pc/f_pc_line.cpp
+++ b/src/f_pc/f_pc_line.cpp
@@ -16,7 +16,7 @@ void fpcLn_Create() {
         cLs_Create(line_node++);
 }
 
-node_lists_tree_class g_fpcLn_Queue = {
+DUSK_GAME_DATA node_lists_tree_class g_fpcLn_Queue = {
     l_fpcLn_Line,
     ARRAY_SIZEU(l_fpcLn_Line),
 };
diff --git a/src/f_pc/f_pc_manager.cpp b/src/f_pc/f_pc_manager.cpp
index ad226b4d1d..d2276bf8cb 100644
--- a/src/f_pc/f_pc_manager.cpp
+++ b/src/f_pc/f_pc_manager.cpp
@@ -21,7 +21,11 @@
 #include "f_pc/f_pc_priority.h"
 #include "m_Do/m_Do_controller_pad.h"
 
-#include "tracy/Tracy.hpp"
+#if TARGET_PC
+#include "dusk/game_clock.h"
+
+#include <tracy/Tracy.hpp>
+#endif
 
 void fpcM_Draw(void* i_proc) {
     fpcDw_Execute((base_process_class*)i_proc);
@@ -64,8 +68,8 @@ void fpcM_Management(fpcM_ManagementFunc i_preExecuteFn, fpcM_ManagementFunc i_p
             }
 
 #ifdef TARGET_PC
-            // FRAME INTERP NOTE: Called in m_Do_main when interp is enabled
-            if (!dusk::frame_interp::is_enabled())
+            // The main loop manages painting when simulation and presentation are separated.
+            if (!dusk::game_clock::g_frameTiming.separatePresentation)
 #endif
             {
                 cAPIGph_Painter();
@@ -97,11 +101,13 @@ void fpcM_Management(fpcM_ManagementFunc i_preExecuteFn, fpcM_ManagementFunc i_p
                 fpcDw_Handler((fpcDw_HandlerFuncFunc)fpcM_DrawIterater, (fpcDw_HandlerFunc)fpcM_Draw);
             }
 
+            IF_DUSK(dComIfGp_drawSimpleModel());
+
             if (i_postExecuteFn != NULL) {
                 i_postExecuteFn();
             }
 
-            dComIfGp_drawSimpleModel();
+            IF_NOT_DUSK(dComIfGp_drawSimpleModel());
         } else if (!l_dvdError) {
             dLib_time_c::stopTime();
             Z2GetSoundMgr()->pauseAllGameSound(true);
diff --git a/src/f_pc/f_pc_node.cpp b/src/f_pc/f_pc_node.cpp
index ca7bcc044b..7cc88ec0db 100644
--- a/src/f_pc/f_pc_node.cpp
+++ b/src/f_pc/f_pc_node.cpp
@@ -8,10 +8,10 @@
 #include "f_pc/f_pc_debug_sv.h"
 
 #if TARGET_PC
+#include "dusk/game_clock.h"
+
 #include "f_op/f_op_draw_iter.h"
 #include "f_pc/f_pc_manager.h"
-
-#include "dusk/frame_interpolation.h"
 #endif
 
 int fpcNd_DrawMethod(nodedraw_method_class* i_method_class, void* i_data) {
@@ -26,7 +26,7 @@ int fpcNd_Draw(process_node_class* i_procNode) {
         layer_class* save_layer = fpcLy_CurrentLayer();
         fpcLy_SetCurrentLayer(&var_r28->layer);
 #if TARGET_PC
-        if (!i_procNode->draw_interp_frame && !dusk::frame_interp::is_sim_frame()) {
+        if (!i_procNode->draw_interp_frame && !dusk::game_clock::is_sim_frame()) {
             for (create_tag_class* i = fopDwIt_Begin(); i != NULL; i = fopDwIt_Next(i)) {
                 void* process = i->mpTagData;
                 fpcM_Draw(process);
@@ -61,7 +61,7 @@ int fpcNd_Execute(process_node_class* i_procNode) {
     return ret;
 }
 
-int g_fpcNd_type;
+DUSK_GAME_DATA int g_fpcNd_type;
 
 void* fpcNd_IsCreatingFromUnder(void* i_procNode) {
     if (i_procNode != NULL && fpcBs_Is_JustOfType(g_fpcNd_type, ((process_node_class*)i_procNode)->base.subtype) != FALSE)
@@ -79,7 +79,7 @@ void* fpcNd_IsCreatingFromUnder(void* i_procNode) {
     return NULL;
 }
 
-BOOL g_fpcNd_IsCheckOfDeleteTiming = TRUE;
+DUSK_GAME_DATA BOOL g_fpcNd_IsCheckOfDeleteTiming = TRUE;
 
 int fpcNd_IsDeleteTiming(process_node_class* i_procNode) {
     if (g_fpcNd_IsCheckOfDeleteTiming == TRUE && fpcNd_IsCreatingFromUnder(i_procNode) != NULL) {
@@ -124,7 +124,7 @@ int fpcNd_Create(process_node_class* i_procNode) {
     return ret;
 }
 
-nodedraw_method_class g_fpcNd_Method = {
+DUSK_GAME_DATA nodedraw_method_class g_fpcNd_Method = {
     (process_method_func)fpcNd_Create, (process_method_func)fpcNd_Delete,
     (process_method_func)fpcNd_Execute, (process_method_func)fpcNd_IsDelete,
     (process_method_func)fpcNd_Draw,
diff --git a/src/f_pc/f_pc_profile.cpp b/src/f_pc/f_pc_profile.cpp
index e248873a07..34eafc1701 100644
--- a/src/f_pc/f_pc_profile.cpp
+++ b/src/f_pc/f_pc_profile.cpp
@@ -5,18 +5,36 @@
 
 #include "f_pc/f_pc_profile.h"
 
+#if TARGET_PC
+#include "dusk/mods/svc/actor.hpp"
+#include "f_pc/f_pc_name.h"
+#endif
 
 #ifndef __MWERKS__
 // Forward declare the static list from f_pc_profile_lst.cpp
-extern process_profile_definition DUSK_CONST* DUSK_CONST g_fpcPfLst_ProfileList[];
+DUSK_GAME_EXTERN process_profile_definition DUSK_CONST* DUSK_CONST g_fpcPfLst_ProfileList[];
 // On PC: Direct pointer to static array
-process_profile_definition DUSK_CONST* DUSK_CONST* DUSK_CONST g_fpcPf_ProfileList_p = g_fpcPfLst_ProfileList;
+DUSK_GAME_DATA process_profile_definition DUSK_CONST* DUSK_CONST* DUSK_CONST g_fpcPf_ProfileList_p =
+    g_fpcPfLst_ProfileList;
 #else
 // On Console: Pointer initialized by REL module prolog
 process_profile_definition** g_fpcPf_ProfileList_p;
 #endif
 
 process_profile_definition DUSK_CONST* fpcPf_Get(s16 i_profname) {
+#if TARGET_PC
+    // Check if a mod has registered an actor with i_profname. Fallback to the profile list if it
+    // doesn't exist.
+    process_profile_definition* profile =
+        dusk::mods::svc::actor_impl::get_profile_from_proc_name(i_profname);
+    if (profile != nullptr) {
+        return profile;
+    }
+    if (i_profname < 0 || i_profname >= fpcNm_MAX_NUM) {
+        return nullptr;
+    }
+#endif
+
     int index = i_profname;
     return g_fpcPf_ProfileList_p[index];
 }
diff --git a/src/f_pc/f_pc_profile_lst.cpp b/src/f_pc/f_pc_profile_lst.cpp
index 39fbd2068e..06b9eb68a6 100644
--- a/src/f_pc/f_pc_profile_lst.cpp
+++ b/src/f_pc/f_pc_profile_lst.cpp
@@ -811,7 +811,7 @@ extern "C" void ModuleEpilog() {
 }
 
 #else
-process_profile_definition DUSK_CONST* DUSK_CONST g_fpcPfLst_ProfileList[] = {
+DUSK_GAME_DATA process_profile_definition DUSK_CONST* DUSK_CONST g_fpcPfLst_ProfileList[] = {
     &g_profile_OVERLAP0.base.base,
     &g_profile_OVERLAP1.base.base,
     &g_profile_OVERLAP3.base.base,
diff --git a/src/dusk/batch.cpp b/src/helpers/batch.cpp
similarity index 97%
rename from src/dusk/batch.cpp
rename to src/helpers/batch.cpp
index 04cba52b0d..ea77363e24 100644
--- a/src/dusk/batch.cpp
+++ b/src/helpers/batch.cpp
@@ -1,10 +1,11 @@
-#include "dusk/batch.hpp"
+#include "helpers/batch.hpp"
+
 #include "dusk/logging.h"
 
 #include <aurora/dl.hpp>
 #include <dolphin/gx/GXEnum.h>
 
-namespace dusk::batch {
+namespace batch {
 
 void decode_leaf_template(const u8* dl, u32 size, LeafTemplate& out) {
     out.vtxCount = 0;
@@ -69,4 +70,4 @@ void decode_leaf_template(const u8* dl, u32 size, LeafTemplate& out) {
     }
 }
 
-}  // namespace dusk::batch
+}  // namespace batch
diff --git a/src/dusk/endian.cpp b/src/helpers/endian.cpp
similarity index 92%
rename from src/dusk/endian.cpp
rename to src/helpers/endian.cpp
index 777ed8ae69..885527da85 100644
--- a/src/dusk/endian.cpp
+++ b/src/helpers/endian.cpp
@@ -1,7 +1,8 @@
-#include "dusk/endian.h"
-#include <dolphin/gx.h>
+#include "helpers/endian.h"
+
+#include "helpers/endian_gx.hpp"
+
 #include "SSystem/SComponent/c_xyz.h"
-#include "dusk/endian_gx.hpp"
 
 #define IMPL_ENUM(type) \
     template <> \
diff --git a/src/dusk/offset_ptr.cpp b/src/helpers/offset_ptr.cpp
similarity index 92%
rename from src/dusk/offset_ptr.cpp
rename to src/helpers/offset_ptr.cpp
index f26fae3db5..59ca70a4de 100644
--- a/src/dusk/offset_ptr.cpp
+++ b/src/helpers/offset_ptr.cpp
@@ -1,8 +1,7 @@
-#include "dusk/offset_ptr.h"
+#include "helpers/offset_ptr.h"
 
 #include "JSystem/JUtility/JUTAssert.h"
 
-#if TARGET_PC
 bool OffsetPtr::isRelocated() {
     return value & 0x8000'0000;
 }
@@ -25,4 +24,3 @@ bool OffsetPtr::setBase(void* base) {
     value = newDiff | 0x8000'0000;
     return true;
 }
-#endif
diff --git a/src/dusk/string.cpp b/src/helpers/string.cpp
similarity index 95%
rename from src/dusk/string.cpp
rename to src/helpers/string.cpp
index 7666f9d9ae..67b8115c51 100644
--- a/src/dusk/string.cpp
+++ b/src/helpers/string.cpp
@@ -1,5 +1,6 @@
-#include "dusk/string.hpp"
-#include "fmt/format.h"
+#include "helpers/string.hpp"
+
+#include <fmt/format.h>
 
 namespace {
 void strncpyProxy(char* dst, const char* src, size_t count) {
@@ -14,8 +15,6 @@ void strncpyProxy(char* dst, const char* src, size_t count) {
 }
 }  // namespace
 
-namespace dusk {
-
 void TextSpan::CrashSpawnEmpty() {
     CRASH("Span is empty!");
 }
@@ -81,5 +80,3 @@ int SafeStringVPrintf(char* buffer, size_t bufSize, const char* src, std::va_lis
 
     return vsnprintf(buffer, bufSize, src, args);
 }
-
-}  // namespace dusk
\ No newline at end of file
diff --git a/src/m_Do/m_Do_DVDError.cpp b/src/m_Do/m_Do_DVDError.cpp
index 2cfef5fbb4..a38f2a6f5f 100644
--- a/src/m_Do/m_Do_DVDError.cpp
+++ b/src/m_Do/m_Do_DVDError.cpp
@@ -16,13 +16,13 @@ const int stack_size = 3072;
 const int stack_size = 8192;
 #endif
 
-bool mDoDvdErr_initialized;
+DUSK_GAME_DATA bool mDoDvdErr_initialized;
 
 static OSThread DvdErr_thread;
 
 #pragma push
 #pragma force_active on
-static u8 DvdErr_stack[stack_size] ATTRIBUTE_ALIGN(16);
+ATTRIBUTE_ALIGN(16) static u8 DvdErr_stack[stack_size];
 #pragma pop
 
 static OSAlarm Alarm;
diff --git a/src/m_Do/m_Do_MemCard.cpp b/src/m_Do/m_Do_MemCard.cpp
index dbf962b173..b6ef973cc3 100644
--- a/src/m_Do/m_Do_MemCard.cpp
+++ b/src/m_Do/m_Do_MemCard.cpp
@@ -3,35 +3,35 @@
  * Memory Card Control
  */
 
-#include <card.h>
 #include "m_Do/m_Do_MemCard.h"
+#include <card.h>
 #include "JSystem/JKernel/JKRAssertHeap.h"
-#include "m_Do/m_Do_ext.h"
+#include "dusk/main.h"
+#include "dusk/os.h"
+#include "dusk/version.hpp"
 #include "m_Do/m_Do_MemCardRWmng.h"
 #include "m_Do/m_Do_Reset.h"
+#include "m_Do/m_Do_ext.h"
 #include "os_report.h"
-#include "dusk/os.h"
-#include "dusk/main.h"
-#include "dusk/version.hpp"
 
 #if PLATFORM_WII || PLATFORM_SHIELD
+#include <cstring>
 #include <revolution/nand.h>
 #include <revolution/sc.h>
-#include <cstring>
 #endif
 
 #define SLOT_A 0
 
-#define CHECKSPACE_RESULT_READY    0
+#define CHECKSPACE_RESULT_READY 0
 #define CHECKSPACE_RESULT_INSSPACE 1
-#define CHECKSPACE_RESULT_NOENT    2
-#define CHECKSPACE_RESULT_ERROR    3
+#define CHECKSPACE_RESULT_NOENT 2
+#define CHECKSPACE_RESULT_ERROR 3
 
 #if PLATFORM_WII
 s32 my_CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo) {
     CARDStat stat;
     DVDDiskID* diskID = DVDGetCurrentDiskID();
-    
+
     for (int i = 0; i < CARD_MAX_FILE; i++) {
         s32 ret = CARDGetStatus(chan, i, &stat);
         if (ret == CARD_RESULT_READY) {
@@ -57,10 +57,10 @@ s32 my_CARDOpen(s32 chan, const char* fileName, CARDFileInfo* fileInfo) {
 #endif
 
 #if PLATFORM_WII
-#define NAND_OPEN  NANDSafeOpen
+#define NAND_OPEN NANDSafeOpen
 #define NAND_CLOSE NANDSafeClose
 #elif PLATFORM_SHIELD
-#define NAND_OPEN  NANDSimpleSafeOpen
+#define NAND_OPEN NANDSimpleSafeOpen
 #define NAND_CLOSE NANDSimpleSafeClose
 #endif
 
@@ -77,15 +77,20 @@ static u8 MemCardStack[STACK_SIZE];
 static OSThread MemCardThread;
 
 void mDoMemCd_Ctrl_c::ThdInit() {
-    #if !PLATFORM_SHIELD
+#ifdef TARGET_PC
+    if (mInitialized) {
+        return;
+    }
     CARDSetLoadType((CARDFileType)dusk::getSettings().backend.cardFileType.getValue());
+#endif
 
+#if !PLATFORM_SHIELD
     char version[5] = {};
     char maker[3] = {};
     std::memcpy(version, dusk::version::getDiskID().gameName, 4);
     std::memcpy(maker, dusk::version::getDiskID().company, 2);
     CARDInit(version, maker);
-    #endif
+#endif
 
     mCopyToPos = 0;
     mProbeStat = 2;
@@ -93,6 +98,7 @@ void mDoMemCd_Ctrl_c::ThdInit() {
 
 #if TARGET_PC
     mCardCommand = COMM_ATTACH_e;
+    mInitialized = true;
 #else
     mCardCommand = COMM_NONE_e;
 #endif
@@ -101,8 +107,9 @@ void mDoMemCd_Ctrl_c::ThdInit() {
 
     OSInitMutex(&mMutex);
     OSInitCond(&mCond);
-    OSCreateThread(&MemCardThread, (void*(*)(void*))mDoMemCd_main, NULL, MemCardStack + sizeof(MemCardStack),
-                   sizeof(MemCardStack), OSGetThreadPriority(OSGetCurrentThread()) + 1, 1);
+    OSCreateThread(&MemCardThread, (void* (*)(void*))mDoMemCd_main, NULL,
+        MemCardStack + sizeof(MemCardStack), sizeof(MemCardStack),
+        OSGetThreadPriority(OSGetCurrentThread()) + 1, 1);
     OSResumeThread(&MemCardThread);
 
     // "Memory Card Thread Init\n"
@@ -112,23 +119,26 @@ void mDoMemCd_Ctrl_c::ThdInit() {
 void mDoMemCd_Ctrl_c::main() {
     do {
         OSLockMutex(&mMutex);
-        while (mCardCommand == COMM_NONE_e
 #ifdef TARGET_PC
-            && !dusk::IsShuttingDown
-#endif
-        ) {
+        bool shutdownThread = dusk::IsShuttingDown;
+        while (mCardCommand == COMM_NONE_e && !shutdownThread) {
             OSWaitCond(&mCond, &mMutex);
+            shutdownThread = dusk::IsShuttingDown;
         }
         OSUnlockMutex(&mMutex);
 
-#ifdef TARGET_PC
-        if (dusk::IsShuttingDown) {
+        if (shutdownThread) {
             break;
         }
+#else
+        while (mCardCommand == COMM_NONE_e) {
+            OSWaitCond(&mCond, &mMutex);
+        }
+        OSUnlockMutex(&mMutex);
 #endif
 
         switch (mCardCommand) {
-        #if PLATFORM_GCN || PLATFORM_WII
+#if PLATFORM_GCN || PLATFORM_WII
         case COMM_RESTORE_e:
             restore();
             break;
@@ -144,16 +154,16 @@ void mDoMemCd_Ctrl_c::main() {
         case COMM_DETACH_e:
             detach();
             break;
-        #elif PLATFORM_SHIELD
+#elif PLATFORM_SHIELD
         case COMM_RESTORE_e:
         case COMM_STORE_e:
         case COMM_FORMAT_e:
         case COMM_ATTACH_e:
         case COMM_DETACH_e:
             break;
-        #endif
+#endif
 
-        #if PLATFORM_WII || PLATFORM_SHIELD
+#if PLATFORM_WII || PLATFORM_SHIELD
         case COMM_RESTORE_NAND_e:
             restoreNAND();
             break;
@@ -163,7 +173,7 @@ void mDoMemCd_Ctrl_c::main() {
         case COMM_STORE_SETUP_NAND_e:
             storeSetUpNAND();
             break;
-        #endif
+#endif
         }
 
         OSLockMutex(&mMutex);
@@ -180,7 +190,7 @@ void mDoMemCd_Ctrl_c::update() {
         OSUnlockMutex(&mMutex);
         OSSignalCond(&mCond);
     } else if (getStatus(0) != 14) {
-        #if PLATFORM_GCN || PLATFORM_WII
+#if PLATFORM_GCN || PLATFORM_WII
         if (CARDProbe(SLOT_A) && getStatus(0) == 0) {
             OSLockMutex(&mMutex);
             mProbeStat = 0;
@@ -196,7 +206,7 @@ void mDoMemCd_Ctrl_c::update() {
             OSUnlockMutex(&mMutex);
             OSSignalCond(&mCond);
         }
-        #endif
+#endif
     }
 }
 
@@ -214,7 +224,12 @@ void mDoMemCd_Ctrl_c::restore() {
     CARDFileInfo file;
     field_0x1fc8 = 0;
 
-    s32 ret = CARD_OPEN(mChannel, "gczelda2", &file);
+#ifdef TARGET_PC
+    const char* fileName = getFileName();
+#else
+    const char* fileName = "gczelda2";
+#endif
+    s32 ret = CARD_OPEN(mChannel, fileName, &file);
     OS_REPORT("\x1b[43;30mCret=%d\n\x1b[m", ret);
     if (ret == CARD_RESULT_READY) {
         s32 ret2 = mDoMemCdRWm_Restore(&file, this, sizeof(mData));
@@ -271,12 +286,18 @@ void mDoMemCd_Ctrl_c::store() {
     s32 ret;
     field_0x1fc8 = 0;
 
+#ifdef TARGET_PC
+    const char* fileName = getFileName();
+#else
+    const char* fileName = "gczelda2";
+#endif
+
     if (mCardState == CARD_STATE_NO_FILE_e) {
-        #if PLATFORM_GCN
-        ret = CARDCreate(mChannel, "gczelda2", CARD_FILE_SIZE, &file);
-        #else
+#if PLATFORM_GCN
+        ret = CARDCreate(mChannel, fileName, CARD_FILE_SIZE, &file);
+#else
         ret = CARDCreate(mChannel, "zeldaTp.dat", CARD_FILE_SIZE, &file);
-        #endif
+#endif
         if (ret == CARD_RESULT_READY || ret == CARD_RESULT_EXIST) {
             mCardState = CARD_STATE_READY_e;
         } else {
@@ -285,7 +306,7 @@ void mDoMemCd_Ctrl_c::store() {
     }
 
     if (mCardState == CARD_STATE_READY_e) {
-        ret = CARD_OPEN(mChannel, "gczelda2", &file);
+        ret = CARD_OPEN(mChannel, fileName, &file);
         if (ret == CARD_RESULT_READY) {
             ret = mDoMemCdRWm_Store(&file, this, sizeof(mData));
             if (ret != CARD_RESULT_READY) {
@@ -484,7 +505,7 @@ void mDoMemCd_Ctrl_c::detach() {
     mCardState = CARD_STATE_NO_CARD_e;
 }
 
-static u8 MemCardWorkArea0[CARD_WORKAREA_SIZE] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 MemCardWorkArea0[CARD_WORKAREA_SIZE];
 
 s32 mDoMemCd_Ctrl_c::mount() {
     s32 result = CARDMount(mChannel, MemCardWorkArea0, NULL);
@@ -527,7 +548,13 @@ s32 mDoMemCd_Ctrl_c::mount() {
 s32 mDoMemCd_Ctrl_c::loadfile() {
     CARDFileInfo file;
 
-    s32 ret = CARD_OPEN(mChannel, "gczelda2", &file);
+#ifdef TARGET_PC
+    const char* fileName = getFileName();
+#else
+    const char* fileName = "gczelda2";
+#endif
+
+    s32 ret = CARD_OPEN(mChannel, fileName, &file);
     if (ret == CARD_RESULT_READY) {
         CARDClose(&file);
         return TRUE;
@@ -543,7 +570,7 @@ s32 mDoMemCd_Ctrl_c::checkspace() {
 
     if (result != CARD_RESULT_READY) {
         setCardState(result);
-        return CHECKSPACE_RESULT_ERROR;  
+        return CHECKSPACE_RESULT_ERROR;
     }
 
     if (bytesNotUsed < CARD_FILE_SIZE) {
@@ -553,7 +580,7 @@ s32 mDoMemCd_Ctrl_c::checkspace() {
     if (filesNotUsed < 1) {
         return CHECKSPACE_RESULT_NOENT;
     }
-    
+
     return CHECKSPACE_RESULT_READY;
 }
 
@@ -596,7 +623,7 @@ void mDoMemCd_Ctrl_c::restoreNAND() {
     NANDFileInfo file;
     s32 ret, ret2;
 
-    field_0x1fc8 = 0;    
+    field_0x1fc8 = 0;
 
     ret = NANDOpen("zeldaTp.dat", &file, NAND_ACCESS_RW);
     OS_REPORT("\x1b[43;30mCret=%d\n\x1b[m", ret);
@@ -668,7 +695,8 @@ void mDoMemCd_Ctrl_c::storeNAND() {
         ret = NANDCreate("banner.bin", NAND_PERM_RUSR | NAND_PERM_WUSR | NAND_PERM_RGRP, 0);
         printf("NAND bannerFile Create ret:%d\n", ret);
         if (ret == NAND_RESULT_OK || ret == NAND_RESULT_EXISTS) {
-            ret = NAND_OPEN("banner.bin", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
+            ret = NAND_OPEN(
+                "banner.bin", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
             if (ret == NAND_RESULT_OK) {
                 ret = mDoMemCdRWm_StoreBannerNAND(&file);
                 if (ret == NAND_RESULT_OK) {
@@ -686,7 +714,8 @@ void mDoMemCd_Ctrl_c::storeNAND() {
         }
 
         if (ret == NAND_RESULT_OK) {
-            ret = NAND_OPEN("zeldaTp.dat", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
+            ret = NAND_OPEN(
+                "zeldaTp.dat", &file, NAND_ACCESS_RW, l_safeCopyBuf, sizeof(l_safeCopyBuf));
             if (ret == NAND_RESULT_OK) {
                 ret = mDoMemCdRWm_StoreNAND(&file, this, sizeof(mData));
                 if (ret == NAND_RESULT_OK) {
@@ -732,10 +761,11 @@ s32 mDoMemCd_Ctrl_c::SaveSyncNAND() {
 
 void mDoMemCd_Ctrl_c::storeSetUpNAND() {
     field_0x1fc8 = 0;
-    
-    while ((int)SCCheckStatus() != 0) {}
 
-    #if PLATFORM_WII
+    while ((int)SCCheckStatus() != 0) {
+    }
+
+#if PLATFORM_WII
     if (!SCFlush()) {
         mNandState = NAND_STATE_WRITE_e;
         printf("== 本体設定Write OK ==\n");
@@ -743,9 +773,9 @@ void mDoMemCd_Ctrl_c::storeSetUpNAND() {
         mNandState = NAND_STATE_FATAL_ERROR_e;
         printf("== 本体設定Write ERR ==\n");
     }
-    #else
+#else
     mNandState = NAND_STATE_WRITE_e;
-    #endif
+#endif
 
     field_0x1fc8 = 1;
 }
@@ -866,7 +896,7 @@ s32 mDoMemCd_Ctrl_c::checkspaceNAND() {
     s32 result = NANDCheck(3, 2, &answer);
     if (result != NAND_RESULT_OK) {
         setNandState(result);
-        return CHECKSPACE_RESULT_ERROR;  
+        return CHECKSPACE_RESULT_ERROR;
     }
 
     if (answer == 0) {
@@ -876,12 +906,38 @@ s32 mDoMemCd_Ctrl_c::checkspaceNAND() {
     } else if (answer & 10) {
         ret = 2;
     }
-    
+
     return ret;
 }
 #endif
 
-mDoMemCd_Ctrl_c g_mDoMemCd_control;
+#ifdef TARGET_PC
+void mDoMemCd_Ctrl_c::setFileName(const std::string& fileName) {
+    if (mInitialized == false) {
+        mFileName = fileName;
+    } else {
+        OSLockMutex(&mMutex);
+        mFileName = fileName;
+        OSUnlockMutex(&mMutex);
+    }
+}
+
+const char* mDoMemCd_Ctrl_c::getFileName() {
+    const char* fileName = "gczelda2";
+    if (mInitialized) {
+        OSLockMutex(&mMutex);
+    }
+    if (!mFileName.empty()) {
+        fileName = mFileName.c_str();
+    }
+    if (mInitialized) {
+        OSUnlockMutex(&mMutex);
+    }
+    return fileName;
+}
+#endif
+
+DUSK_GAME_DATA mDoMemCd_Ctrl_c g_mDoMemCd_control;
 
 static int mDoMemCd_main(void*) {
     JKRThread(OSGetCurrentThread(), 0);
diff --git a/src/m_Do/m_Do_MemCardRWmng.cpp b/src/m_Do/m_Do_MemCardRWmng.cpp
index d7739d6158..bb0326f623 100644
--- a/src/m_Do/m_Do_MemCardRWmng.cpp
+++ b/src/m_Do/m_Do_MemCardRWmng.cpp
@@ -320,7 +320,7 @@ static void mDoMemCdRWm_BuildHeader(mDoMemCdRWm_HeaderData* header) {
 #endif
 
     OSCalendarTime time;
-    OSTicksToCalendarTime(OSGetTime(), &time);
+    OSTicksToCalendarTime(DUSK_IF_ELSE(OSGetSystemTime(), OSGetTime()), &time);
 
 #if TARGET_PC
     if (dusk::version::isRegionPal()) {
@@ -348,9 +348,10 @@ static void mDoMemCdRWm_BuildHeader(mDoMemCdRWm_HeaderData* header) {
 
         snprintf(header->mComment, sizeof(header->mComment), HEADER_COMMENT, time.mon + 1, time.mday);
     } else {
-        // TODO JPN SHIFT-JIS
-        // snprintf(header->mTitle, sizeof(header->mTitle), "ゼルダの伝説 ﾄﾜｲﾗｲﾄﾌﾟﾘﾝｾｽ");
-        // snprintf(header->mComment, sizeof(header->mComment), "%d月%d日のセーブデータです", time.mon + 1, time.mday);
+        // shift-jis "ゼルダの伝説 ﾄﾜｲﾗｲﾄﾌﾟﾘﾝｾｽ"
+        snprintf(header->mTitle, sizeof(header->mTitle), "\x83\x5b\x83\x8b\x83\x5f\x82\xcc\x93\x60\x90\xe0\x20\xc4\xdc\xb2\xd7\xb2\xc4\xcc\xdf\xd8\xdd\xbe\xbd");
+        // shift-jis "%d月%d日のセーブデータです"
+        snprintf(header->mComment, sizeof(header->mComment), "\x25\x64\x8c\x8e\x25\x64\x93\xfa\x82\xcc\x83\x5a\x81\x5b\x83\x75\x83\x66\x81\x5b\x83\x5e\x82\xc5\x82\xb7", time.mon + 1, time.mday);
     }
 #elif VERSION == VERSION_GCN_PAL
     switch (dComIfGs_getPalLanguage()) {
diff --git a/src/m_Do/m_Do_Reset.cpp b/src/m_Do/m_Do_Reset.cpp
index c3a5fea739..900c602c29 100644
--- a/src/m_Do/m_Do_Reset.cpp
+++ b/src/m_Do/m_Do_Reset.cpp
@@ -4,21 +4,26 @@
  */
 
 #include "m_Do/m_Do_Reset.h"
+#include <gx.h>
 #include "JSystem/JAudio2/JASDvdThread.h"
 #include "JSystem/JUtility/JUTGamePad.h"
 #include "JSystem/JUtility/JUTXfb.h"
 #include "SSystem/SComponent/c_API_controller_pad.h"
-#include <gx.h>
-#include "m_Do/m_Do_audio.h"
 #include "m_Do/m_Do_DVDError.h"
-#include "m_Do/m_Do_ext.h"
 #include "m_Do/m_Do_MemCard.h"
+#include "m_Do/m_Do_audio.h"
+#include "m_Do/m_Do_ext.h"
 
 #if !PLATFORM_GCN
 #include <revolution/os.h>
 #endif
 #include "os_report.h"
 
+#ifdef TARGET_PC
+#include "dusk/game_mode.hpp"
+#include "dusk/ui/prelaunch.hpp"
+#endif
+
 static void my_OSCancelAlarmAll() {}
 
 static void destroyVideo() {
@@ -30,7 +35,7 @@ static void destroyVideo() {
     return;
 }
 
-mDoRstData* mDoRst::mResetData;
+DUSK_GAME_DATA mDoRstData* mDoRst::mResetData;
 
 void mDoRst_reset(int reset, u32 resetCode, int forceMenu) {
     JUT_ASSERT(83, mDoExt_GetCurrentRunningThread() != 0);
@@ -104,6 +109,14 @@ void checkDiskCallback(s32 result, DVDCommandBlock* block) {
 }
 
 void mDoRst_resetCallBack(int port, void*) {
+#ifdef TARGET_PC
+    const dusk::gamemode::GameMode* gameMode =
+        dusk::gamemode::getGameModeManager().getCurrentGameMode();
+    if (gameMode) {
+        gameMode->invokeOnGameResetFunction();
+    }
+#endif
+
     if (mDoRst::isReset()) {
         return;
     }
@@ -129,7 +142,8 @@ void mDoRst_resetCallBack(int port, void*) {
 #else
     DVDCommandBlock block;
     block.userData = (void*)-1;
-    while (DVDCheckDiskAsync(&block, checkDiskCallback));
+    while (DVDCheckDiskAsync(&block, checkDiskCallback))
+        ;
     do {
         check = (int)block.userData;
     } while (check == -1);
@@ -141,6 +155,12 @@ void mDoRst_resetCallBack(int port, void*) {
         }
     }
     mDoRst::onReset();
+#ifdef TARGET_PC
+    if (dusk::ui::prelaunch_state().returnToPrelaunchOnReset) {
+        dusk::ui::return_to_prelaunch();
+        dusk::ui::prelaunch_state().returnToPrelaunchOnReset = false;
+    }
+#endif
 }
 
 void mDoRst_shutdownCallBack() {
diff --git a/src/m_Do/m_Do_audio.cpp b/src/m_Do/m_Do_audio.cpp
index fc44eb7fb6..9be3b5dde0 100644
--- a/src/m_Do/m_Do_audio.cpp
+++ b/src/m_Do/m_Do_audio.cpp
@@ -12,18 +12,35 @@
 #include "d/d_debug_viewer.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_dvd_thread.h"
-#include "tracy/Tracy.hpp"
+
+#if TARGET_PC
+#include "dusk/settings.h"
+
+#include <tracy/Tracy.hpp>
+#endif
 
 #if PLATFORM_WII || PLATFORM_SHIELD
 #include "Z2AudioCS/Z2AudioCS.h"
 #include <revolution/sc.h>
 #endif
 
-u8 mDoAud_zelAudio_c::mInitFlag;
+DUSK_GAME_DATA u8 mDoAud_zelAudio_c::mInitFlag;
 
-u8 mDoAud_zelAudio_c::mResetFlag;
+DUSK_GAME_DATA u8 mDoAud_zelAudio_c::mResetFlag;
 
-u8 mDoAud_zelAudio_c::mBgmSet;
+DUSK_GAME_DATA u8 mDoAud_zelAudio_c::mBgmSet;
+
+#if TARGET_PC
+void mDoAud_seStartMenu(u32 i_sfxID) {
+    if (!mDoAud_zelAudio_c::isInitFlag()) {
+        return;
+    }
+    if (!dusk::getSettings().audio.menuSounds.getValue()) {
+        return;
+    }
+    mDoAud_seStart(i_sfxID, nullptr, 0, 0);
+}
+#endif
 
 void mDoAud_zelAudio_c::reset() {
     mBgmSet = false;
@@ -31,7 +48,7 @@ void mDoAud_zelAudio_c::reset() {
 
 static mDoAud_zelAudio_c g_mDoAud_zelAudio;
 
-JKRSolidHeap* g_mDoAud_audioHeap;
+DUSK_GAME_DATA JKRSolidHeap* g_mDoAud_audioHeap;
 
 static mDoDvdThd_toMainRam_c* l_affCommand;
 
diff --git a/src/m_Do/m_Do_controller_pad.cpp b/src/m_Do/m_Do_controller_pad.cpp
index f7eaa92ca2..f1a8e66637 100644
--- a/src/m_Do/m_Do_controller_pad.cpp
+++ b/src/m_Do/m_Do_controller_pad.cpp
@@ -10,17 +10,35 @@
 #include "f_ap/f_ap_game.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_main.h"
-#include "tracy/Tracy.hpp"
 
 #if TARGET_PC
 #include "dusk/menu_pointer.h"
+#include "dusk/settings.h"
 #include "dusk/ui/touch_controls.hpp"
+
+#include <tracy/Tracy.hpp>
 #endif
 
-JUTGamePad* mDoCPd_c::m_gamePad[4];
+DUSK_GAME_DATA JUTGamePad* mDoCPd_c::m_gamePad[4];
 
-interface_of_controller_pad mDoCPd_c::m_cpadInfo[4];
-interface_of_controller_pad mDoCPd_c::m_debugCpadInfo[4];
+DUSK_GAME_DATA interface_of_controller_pad mDoCPd_c::m_cpadInfo[4];
+DUSK_GAME_DATA interface_of_controller_pad mDoCPd_c::m_debugCpadInfo[4];
+
+#if TARGET_PC
+s16 mDoCPd_c::getStickAngle3D(u32 pad) {
+    if (dusk::getSettings().game.enableMirrorMode) {
+        return -getCpadInfo(pad).mMainStickAngle;
+    }
+    return getCpadInfo(pad).mMainStickAngle;
+}
+
+f32 mDoCPd_c::getSubStickX3D(u32 pad) {
+    if (dusk::getSettings().game.enableMirrorMode) {
+        return -getCpadInfo(pad).mCStickPosX;
+    }
+    return getCpadInfo(pad).mCStickPosX;
+}
+#endif
 
 void mDoCPd_c::create() {
     #if PLATFORM_GCN || PLATFORM_SHIELD
diff --git a/src/m_Do/m_Do_dvd_thread.cpp b/src/m_Do/m_Do_dvd_thread.cpp
index 08197ed30b..35f918accf 100644
--- a/src/m_Do/m_Do_dvd_thread.cpp
+++ b/src/m_Do/m_Do_dvd_thread.cpp
@@ -27,11 +27,11 @@ s32 mDoDvdThd::main(void* param_0) {
     return 0;
 }
 
-OSThread mDoDvdThd::l_thread;
+DUSK_GAME_DATA OSThread mDoDvdThd::l_thread;
 
-mDoDvdThdStack mDoDvdThd::l_threadStack;
+DUSK_GAME_DATA mDoDvdThdStack mDoDvdThd::l_threadStack;
 
-mDoDvdThd_param_c mDoDvdThd::l_param;
+DUSK_GAME_DATA mDoDvdThd_param_c mDoDvdThd::l_param;
 
 #if DEBUG
 u8 mDoDvdThd::verbose;
@@ -44,10 +44,10 @@ const char* mDoDvdHack::FstStringStart;
 u32 mDoDvdHack::MaxEntryNum;
 mDoDvdHack::Manager mDoDvdHack::Manager::sManager;
 #else
-bool mDoDvdThd::SyncWidthSound;
+DUSK_GAME_DATA bool mDoDvdThd::SyncWidthSound;
 #endif
 
-u8 sDefaultDirection;
+DUSK_GAME_DATA u8 sDefaultDirection;
 
 #pragma push
 #pragma force_active on
diff --git a/src/m_Do/m_Do_ext.cpp b/src/m_Do/m_Do_ext.cpp
index ac4e6c740e..a53275b7fb 100644
--- a/src/m_Do/m_Do_ext.cpp
+++ b/src/m_Do/m_Do_ext.cpp
@@ -24,12 +24,28 @@
 #include "m_Do/m_Do_mtx.h"
 #include <cstdio>
 #include <cstring>
-#include "dusk/logging.h"
-#include "dusk/frame_interpolation.h"
 
-u8 mDoExt::CurrentHeapAdjustVerbose;
-u8 mDoExt::HeapAdjustVerbose;
-u8 mDoExt::HeapAdjustQuiet;
+#if TARGET_PC
+#include "dusk/game_clock.h"
+#include "dusk/interp/frame_interpolation.h"
+#include "dusk/interp/line.h"
+#include "dusk/logging.h"
+#include "dusk/version.hpp"
+#endif
+
+DUSK_GAME_DATA u8 mDoExt::CurrentHeapAdjustVerbose;
+DUSK_GAME_DATA u8 mDoExt::HeapAdjustVerbose;
+DUSK_GAME_DATA u8 mDoExt::HeapAdjustQuiet;
+
+#if TARGET_PC
+namespace {
+enum InterpKind : u8 {
+    LINE_NONE,
+    LINE_UNIFORM_WIDTH,
+    LINE_PER_POINT_WIDTH,
+};
+}  // namespace
+#endif
 
 static void mDoExt_setJ3DData(Mtx mtx, const J3DTransformInfo* transformInfo, u16 param_2) {
     bool local_28;
@@ -309,6 +325,11 @@ static void mDoExt_modelDiff(J3DModel* i_model) {
     modelMtxErrorCheck(i_model);
     i_model->calcMaterial();
     i_model->diff();
+#if TARGET_PC
+    if (!dusk::game_clock::is_sim_frame()) {
+        return;
+    }
+#endif
     i_model->entry();
 }
 
@@ -351,10 +372,11 @@ void mDoExt_modelUpdateDL(J3DModel* i_model) {
 
 void mDoExt_modelEntryDL(J3DModel* i_model) {
 #if TARGET_PC
-    if (!dusk::frame_interp::is_sim_frame()) {
+    if (!dusk::game_clock::is_sim_frame()) {
         // FRAME INTERP NOTE: This fixes issue #355 where some lights would flicker.
         // This is likely better solved by updating J3DMaterial::needsInterpCallBack,
         // but it's unclear what exactly needs to be added.
+        i_model->calcMaterial();
         i_model->diff();
         return;
     }
@@ -691,7 +713,7 @@ JKRExpHeap* mDoExt_getDbPrintHeap() {
     return DbPrintHeap;
 }
 
-JKRExpHeap* gameHeap;
+DUSK_GAME_DATA JKRExpHeap* gameHeap;
 static intptr_t safeGameHeapSize = -1;
 
 JKRExpHeap* mDoExt_createGameHeap(u32 heapSize, JKRHeap* parentHeap) {
@@ -724,8 +746,8 @@ size_t mDoExt_getSafeGameHeapSize() {
     return safeGameHeapSize;
 }
 
-JKRExpHeap* zeldaHeap;
-intptr_t safeZeldaHeapSize = -1;
+DUSK_GAME_DATA JKRExpHeap* zeldaHeap;
+DUSK_GAME_DATA intptr_t safeZeldaHeapSize = -1;
 
 JKRExpHeap* mDoExt_createZeldaHeap(u32 heapSize, JKRHeap* parentHeap) {
     JUT_ASSERT(1815, zeldaHeap == NULL || heapSize == 0);
@@ -758,8 +780,8 @@ intptr_t mDoExt_getSafeZeldaHeapSize() {
     return safeZeldaHeapSize;
 }
 
-JKRExpHeap* commandHeap;
-intptr_t safeCommandHeapSize = -1;
+DUSK_GAME_DATA JKRExpHeap* commandHeap;
+DUSK_GAME_DATA intptr_t safeCommandHeapSize = -1;
 
 JKRExpHeap* mDoExt_createCommandHeap(u32 heapSize, JKRHeap* parentHeap) {
     JUT_ASSERT(1894, commandHeap == 0 || heapSize == 0);
@@ -785,8 +807,8 @@ intptr_t mDoExt_getSafeCommandHeapSize() {
     return safeCommandHeapSize;
 }
 
-JKRExpHeap* archiveHeap;
-intptr_t safeArchiveHeapSize = -1;
+DUSK_GAME_DATA JKRExpHeap* archiveHeap;
+DUSK_GAME_DATA intptr_t safeArchiveHeapSize = -1;
 
 JKRExpHeap* mDoExt_createArchiveHeap(u32 heapSize, JKRHeap* parentHeap) {
     JUT_ASSERT(1966, archiveHeap == 0 || heapSize == 0);
@@ -824,7 +846,7 @@ JKRExpHeap* mDoExt_getArchiveHeapPtr() {
 }
 
 static JKRExpHeap* j2dHeap;
-intptr_t safeJ2dHeapSize = -1;
+DUSK_GAME_DATA intptr_t safeJ2dHeapSize = -1;
 
 JKRExpHeap* mDoExt_createJ2dHeap(u32 heapSize, JKRHeap* parentHeap) {
     JUT_ASSERT(2059, j2dHeap == 0 || heapSize == 0);
@@ -2238,7 +2260,7 @@ void mDoExt_invJntPacket::draw() {
             } while (shapePkt != NULL);
         }
     } else {
-        static u8 l_invisibleMat[] ATTRIBUTE_ALIGN(32) = {
+        ATTRIBUTE_ALIGN(32) static u8 l_invisibleMat[] = {
             0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,
             0x00, 0x04, 0x00, 0x61, 0x28, 0x38, 0x00, 0x00, 0x61, 0xC0, 0x08, 0xFF, 0xFC, 0x61, 0xC1,
             0x08, 0xFF, 0xF0, 0x61, 0xF3, 0x7F, 0x00, 0x00, 0x61, 0x43, 0x00, 0x00, 0x41, 0x61, 0x40,
@@ -2353,10 +2375,16 @@ int mDoExt_3DlineMat0_c::init(u16 param_0, u16 param_1, int param_2) {
 
     field_0x4 = NULL;
     field_0x16 = 0;
+#if TARGET_PC
+    mInterpWidth = 0.0f;
+    mInterpTaper = 0;
+    mInterpKind = LINE_NONE;
+    dusk::interp::line::reset(this);
+#endif
     return 1;
 }
 
-static u8 l_matDL[132] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_matDL[132] = {
     0x08, 0x30, 0x3C, 0xF3, 0xCF, 0x00, 0x10, 0x00, 0x00, 0x10, 0x18, 0x3C, 0xF3, 0xCF, 0x00,
     0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x7F, 0x32, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00,
     0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0C, 0xFF, 0xFF, 0xFF, 0xFF, 0x61, 0x28, 0x38,
@@ -2412,7 +2440,7 @@ void mDoExt_3DlineMat0_c::draw() {
     }
 
 #if TARGET_PC
-    if (!dusk::frame_interp::is_enabled())
+    if (!dusk::interp::is_enabled())
 #endif
     {
         field_0x16 ^= (u8)1;
@@ -2432,6 +2460,12 @@ void mDoExt_3DlineMat0_c::update(int param_0, f32 param_1, GXColor& param_2, u16
         field_0x14 = (u16)param_0;
     }
 
+#if TARGET_PC
+    mInterpWidth = param_1;
+    mInterpTaper = param_3;
+    mInterpKind = LINE_UNIFORM_WIDTH;
+#endif
+
     view_class* sp_2c = dComIfGd_getView();
 
     mDoExt_3Dline_c* sp_28 = field_0x18;
@@ -2550,6 +2584,8 @@ void mDoExt_3DlineMat0_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* pa
         field_0x14 = (u16)param_0;
     }
 
+    IF_DUSK(mInterpKind = LINE_PER_POINT_WIDTH);
+
     view_class* sp_34 = dComIfGd_getView();
 
     mDoExt_3Dline_c* sp_30 = field_0x18;
@@ -2667,7 +2703,10 @@ int mDoExt_3DlineMat1_c::init(u16 param_0, u16 param_1, ResTIMG* param_2, int pa
     field_0x4 = 0;
     mIsDrawn = 0;
 #if TARGET_PC
-    mInterpLineKind = 0;
+    mInterpWidth = 0.0f;
+    mInterpTaper = 0;
+    mInterpKind = LINE_NONE;
+    dusk::interp::line::reset(this);
 #endif
 
     GXInitTexObj(&mTextureObject, (void*)((intptr_t)param_2 + param_2->imageOffset), param_2->width,
@@ -2681,7 +2720,7 @@ int mDoExt_3DlineMat1_c::init(u16 param_0, u16 param_1, ResTIMG* param_2, int pa
     return 1;
 }
 
-static u8 l_mat1DL[141] ATTRIBUTE_ALIGN(32) = {
+ATTRIBUTE_ALIGN(32) static u8 l_mat1DL[141] = {
     0x10, 0x00, 0x00, 0x10, 0x40, 0xFF, 0xFF, 0x42, 0x80, 0x08, 0x30, 0x3C, 0xF3, 0xCF, 0x00, 0x10,
     0x00, 0x00, 0x10, 0x18, 0x3C, 0xF3, 0xCF, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0E, 0x00, 0x00, 0x7F,
     0x32, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x05, 0x00, 0x10, 0x00, 0x00, 0x10, 0x0C, 0xFF,
@@ -2744,18 +2783,14 @@ void mDoExt_3DlineMat1_c::draw() {
     }
     GXSetTexCoordScaleManually(GX_TEXCOORD0, 0, 0, 0);
 #if TARGET_PC
-    if (!dusk::frame_interp::is_enabled())
+    if (!dusk::interp::is_enabled())
 #endif
     {
         mIsDrawn ^= (u8)1;
     }
 }
 
-#if TARGET_PC
-void mDoExt_3DlineMat1_c::update(int param_0, f32 param_1, GXColor& param_2, u16 param_3, dKy_tevstr_c* param_4, const cXyz* presentationEye) {
-#else
 void mDoExt_3DlineMat1_c::update(int param_0, f32 param_1, GXColor& param_2, u16 param_3, dKy_tevstr_c* param_4) {
-#endif
     mColor = param_2;
     this->mpTevStr = param_4;
     if (param_0 < 0) {
@@ -2767,9 +2802,9 @@ void mDoExt_3DlineMat1_c::update(int param_0, f32 param_1, GXColor& param_2, u16
     }
 
 #if TARGET_PC
-    mInterpLineKind = 1;
-    mInterpLineF = param_1;
-    mInterpLineU16 = param_3;
+    mInterpWidth = param_1;
+    mInterpTaper = param_3;
+    mInterpKind = LINE_UNIFORM_WIDTH;
 #endif
 
     view_class* sp_3c = dComIfGd_getView();
@@ -2825,12 +2860,7 @@ void mDoExt_3DlineMat1_c::update(int param_0, f32 param_1, GXColor& param_2, u16
             local_f31 += local_f30 * 0.02f * (8.0f / param_1);
         }
 
-#if TARGET_PC
-        const cXyz& lineEye = (presentationEye != nullptr && dusk::frame_interp::is_enabled()) ? *presentationEye : sp_3c->lookat.eye;
-        sp_13c = *local_r27 - lineEye;
-#else
         sp_13c = *local_r27 - sp_3c->lookat.eye;
-#endif
         sp_130 = sp_130.outprod(sp_13c);
         sp_130.normalizeZP();
 
@@ -2865,11 +2895,7 @@ void mDoExt_3DlineMat1_c::update(int param_0, f32 param_1, GXColor& param_2, u16
                 local_f31 += local_f30 * 0.02f * (8.0f / param_1);
             }
 
-#if TARGET_PC
-            sp_13c = local_r27[0] - lineEye;
-#else
             sp_13c = local_r27[0] - sp_3c->lookat.eye;
-#endif
             sp_130 = sp_130.outprod(sp_13c);
             sp_130.normalizeZP();
 
@@ -2942,11 +2968,7 @@ void mDoExt_3DlineMat2_c::setMaterial() {
     GXLoadNrmMtxImm(cMtx_getIdentity(), 0);
 }
 
-#if TARGET_PC
-void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* param_4, const cXyz* presentationEye) {
-#else
-void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* param_4
-#endif
+void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* param_4) {
     mColor = param_2;
     this->mpTevStr = param_4;
     if (param_0 < 0) {
@@ -2957,9 +2979,7 @@ void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* pa
         field_0x34 = param_0;
     }
 
-#if TARGET_PC
-    mInterpLineKind = 2;
-#endif
+    IF_DUSK(mInterpKind = LINE_PER_POINT_WIDTH);
 
     view_class* stack_3c = dComIfGd_getView();
     mDoExt_3Dline_c* sp_38 = mpLines;
@@ -2986,12 +3006,6 @@ void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* pa
     for (s32 sp_14 = 0; sp_14 < mNumLines; sp_14++) {
         local_r27 = sp_38[0].field_0x0;
         size_p = sp_38->field_0x4;
-#if TARGET_PC
-        if (presentationEye != nullptr && dusk::frame_interp::is_enabled() && size_p == NULL) {
-            sp_38 += 1;
-            continue;
-        }
-#endif
         JUT_ASSERT(5875, size_p != NULL);
         sp_24 = sp_38->field_0x8[mIsDrawn];
         sp_28 = sp_24;
@@ -3005,12 +3019,7 @@ void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* pa
         sp_130 = local_r27[1] - local_r27[0];
         local_f30 = sp_130.abs();
         local_f31 += local_f30 * 0.1f;
-#if TARGET_PC
-        const cXyz& lineEye = (presentationEye != nullptr && dusk::frame_interp::is_enabled()) ? *presentationEye : stack_3c->lookat.eye;
-        sp_13c = local_r27[0] - lineEye;
-#else
         sp_13c = local_r27[0] - stack_3c->lookat.eye;
-#endif
         sp_130 = sp_130.outprod(sp_13c);
         sp_130.normalizeZP();
         local_r30->x = sp_130.x * 64.0f;
@@ -3032,11 +3041,7 @@ void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* pa
             sp_130 = local_r27[1] - local_r27[0];
             local_f30 = sp_130.abs();
             local_f31 += local_f30 * 0.1f;
-#if TARGET_PC
-            sp_13c = local_r27[0] - lineEye;
-#else
             sp_13c = local_r27[0] - stack_3c->lookat.eye;
-#endif
             sp_130 = sp_130.outprod(sp_13c);
             sp_130.normalizeZP();
             local_r30 += 2;
@@ -3081,16 +3086,42 @@ void mDoExt_3DlineMat1_c::update(int param_0, GXColor& param_2, dKy_tevstr_c* pa
 }
 
 #if TARGET_PC
-void mDoExt_3DlineMat1_c::refreshGeometryForPresentationEye(const cXyz& eye) {
-    if (!dusk::frame_interp::is_enabled()) {
+namespace {
+
+template <typename Material>
+void refresh_3dline_geometry(Material* material, dusk::interp::line::Points points, u8 kind,
+                             f32 width, u16 taper, GXColor& color, dKy_tevstr_c* tevStr) {
+    if (!dusk::interp::is_enabled()) {
         return;
     }
-    if (mInterpLineKind == 1) {
-        update(field_0x34, mInterpLineF, mColor, mInterpLineU16, mpTevStr, &eye);
-    } else if (mInterpLineKind == 2) {
-        update(field_0x34, mColor, mpTevStr, &eye);
+
+    dusk::interp::line::write(material, points);
+    if (kind == LINE_UNIFORM_WIDTH) {
+        material->update(points.point_count, width, color, taper, tevStr);
+    } else if (kind == LINE_PER_POINT_WIDTH) {
+        material->update(points.point_count, color, tevStr);
     }
 }
+
+}  // namespace
+
+void mDoExt_3DlineMat0_c::captureInterpPoints() {
+    dusk::interp::line::capture(this, {field_0x18, field_0x10, field_0x14});
+}
+
+void mDoExt_3DlineMat0_c::refreshGeometryForPresentation() {
+    refresh_3dline_geometry(this, {field_0x18, field_0x10, field_0x14}, mInterpKind,
+                            mInterpWidth, mInterpTaper, field_0x8, field_0xc);
+}
+
+void mDoExt_3DlineMat1_c::captureInterpPoints() {
+    dusk::interp::line::capture(this, {mpLines, mNumLines, field_0x34});
+}
+
+void mDoExt_3DlineMat1_c::refreshGeometryForPresentation() {
+    refresh_3dline_geometry(this, {mpLines, mNumLines, field_0x34}, mInterpKind,
+                            mInterpWidth, mInterpTaper, mColor, mpTevStr);
+}
 #endif
 
 void mDoExt_3DlineMatSortPacket::setMat(mDoExt_3DlineMat_c* i_3DlineMat) {
@@ -3099,6 +3130,7 @@ void mDoExt_3DlineMatSortPacket::setMat(mDoExt_3DlineMat_c* i_3DlineMat) {
     }
     i_3DlineMat->field_0x4 = mp3DlineMat;
     mp3DlineMat = i_3DlineMat;
+    IF_DUSK(i_3DlineMat->captureInterpPoints());
 }
 
 void mDoExt_3DlineMatSortPacket::draw() {
@@ -3645,12 +3677,22 @@ void mDoExt_cylinderMPacket::draw() {
     GXSetCullMode(GX_CULL_BACK);
     GXSetClipMode(GX_CLIP_ENABLE);
 
+#if TARGET_PC
+    Mtx modelViewMtx;
+    cMtx_concat(j3dSys.getViewMtx(), mMatrix, modelViewMtx);
+    GXLoadPosMtxImm(modelViewMtx, 0);
+
+    Mtx normalMtx;
+    cMtx_inverseTranspose(modelViewMtx, normalMtx);
+    GXLoadNrmMtxImm(normalMtx, 0);
+#else
     cMtx_concat(j3dSys.getViewMtx(), mMatrix, mMatrix);
 
     GXLoadPosMtxImm(mMatrix, 0);
     cMtx_inverseTranspose(mMatrix, mMatrix);
 
     GXLoadNrmMtxImm(mMatrix, 0);
+#endif
     GXSetCurrentMtx(0);
 
     GXDrawCylinder(8);
@@ -3711,7 +3753,15 @@ static ResFONT* mDoExt_resfont0;
 
 static void mDoExt_initFont0() {
     static char const fontdata[] = "rodan_b_24_22.bfn";
-#if REGION_JPN
+#if TARGET_PC
+    if (dusk::version::isRegionJpn()) {
+        mDoExt_initFontCommon(&mDoExt_font0, &mDoExt_resfont0, mDoExt_getZeldaHeap(),
+                              fontdata, dComIfGp_getFontArchive(), 0, 200, 512);
+    } else {
+        mDoExt_initFontCommon(&mDoExt_font0, &mDoExt_resfont0, mDoExt_getZeldaHeap(),
+                              fontdata, dComIfGp_getFontArchive(), 1, 0, 0);
+    }
+#elif REGION_JPN
     mDoExt_initFontCommon(&mDoExt_font0, &mDoExt_resfont0, mDoExt_getZeldaHeap(),
                           fontdata, dComIfGp_getFontArchive(), 0, 200, 512);
 #else
@@ -3738,7 +3788,13 @@ void mDoExt_removeMesgFont() {
             JKR_DELETE(mDoExt_font0);
             mDoExt_font0 = NULL;
             if (mDoExt_resfont0 != NULL) {
-#if REGION_JPN
+#if TARGET_PC
+                if (dusk::version::isRegionJpn()) {
+                    JKRFileLoader::removeResource(mDoExt_resfont0, NULL);
+                } else {
+                    JKRFree(mDoExt_resfont0);
+                }
+#elif REGION_JPN
                 JKRFileLoader::removeResource(mDoExt_resfont0, NULL);
 #else
                 JKRFree(mDoExt_resfont0);
@@ -3850,7 +3906,7 @@ J3DModel* mDoExt_J3DModel__create(J3DModelData* i_modelData, u32 i_modelFlag, u3
     return NULL;
 }
 
-DummyCheckHeap* dch;
+DUSK_GAME_DATA DummyCheckHeap* dch;
 
 DummyCheckHeap::DummyCheckHeap() {
     mAlloc = NULL;
@@ -3958,7 +4014,7 @@ void DummyCheckHeap_check() {
     }
 }
 
-u32 aram_cache_size;
+DUSK_GAME_DATA u32 aram_cache_size;
 
 u32 mDoExt_getAraCacheSize() {
     return aram_cache_size;
diff --git a/src/m_Do/m_Do_graphic.cpp b/src/m_Do/m_Do_graphic.cpp
index caf823b065..f83f151724 100644
--- a/src/m_Do/m_Do_graphic.cpp
+++ b/src/m_Do/m_Do_graphic.cpp
@@ -36,7 +36,6 @@
 #include "m_Do/m_Do_graphic.h"
 #include "m_Do/m_Do_machine.h"
 #include "m_Do/m_Do_main.h"
-#include "tracy/Tracy.hpp"
 
 #if PLATFORM_WII || PLATFORM_SHIELD
 #include <revolution/sc.h>
@@ -47,16 +46,18 @@
 #endif
 
 #if TARGET_PC
-#include <SDL3/SDL_video.h>
-#include "aurora/lib/window.hpp"
-#include "d/actor/d_a_horse.h"
 #include "dusk/dusk.h"
-#include "dusk/endian.h"
-#include "dusk/frame_interpolation.h"
-#include "dusk/gx_helper.h"
+#include "dusk/gfx.hpp"
 #include "dusk/imgui/ImGuiConsole.hpp"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/logging.h"
 #include "dusk/settings.h"
+#include "helpers/endian.h"
+#include "helpers/gx_helper.h"
+
+#include <aurora/lib/window.hpp>
+#include <SDL3/SDL_video.h>
+#include <tracy/Tracy.hpp>
 #endif
 
 class mDoGph_HIO_c : public JORReflexible {
@@ -265,36 +266,36 @@ static ResTIMG* createTimg(u16 width, u16 height, u32 format) {
     return timg;
 }
 
-JUTFader* mDoGph_gInf_c::mFader;
+DUSK_GAME_DATA JUTFader* mDoGph_gInf_c::mFader;
 
 #if PLATFORM_WII || PLATFORM_SHIELD || TARGET_PC
-ResTIMG* mDoGph_gInf_c::m_fullFrameBufferTimg;
-void* mDoGph_gInf_c::m_fullFrameBufferTex;
+DUSK_GAME_DATA ResTIMG* mDoGph_gInf_c::m_fullFrameBufferTimg;
+DUSK_GAME_DATA void* mDoGph_gInf_c::m_fullFrameBufferTex;
 #endif
 
-ResTIMG* mDoGph_gInf_c::mFrameBufferTimg;
+DUSK_GAME_DATA ResTIMG* mDoGph_gInf_c::mFrameBufferTimg;
 
-void* mDoGph_gInf_c::mFrameBufferTex;
+DUSK_GAME_DATA void* mDoGph_gInf_c::mFrameBufferTex;
 
-ResTIMG* mDoGph_gInf_c::mZbufferTimg;
+DUSK_GAME_DATA ResTIMG* mDoGph_gInf_c::mZbufferTimg;
 
-void* mDoGph_gInf_c::mZbufferTex;
+DUSK_GAME_DATA void* mDoGph_gInf_c::mZbufferTex;
 
-f32 mDoGph_gInf_c::mFadeRate;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::mFadeRate;
 
-f32 mDoGph_gInf_c::mFadeSpeed;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::mFadeSpeed;
 
-GXColor mDoGph_gInf_c::mBackColor = {0, 0, 0, 0};
+DUSK_GAME_DATA GXColor mDoGph_gInf_c::mBackColor = {0, 0, 0, 0};
 
-GXColor mDoGph_gInf_c::mFadeColor = {0, 0, 0, 0};
+DUSK_GAME_DATA GXColor mDoGph_gInf_c::mFadeColor = {0, 0, 0, 0};
 
-u8 mDoGph_gInf_c::mBlureFlag;
+DUSK_GAME_DATA u8 mDoGph_gInf_c::mBlureFlag;
 
-u8 mDoGph_gInf_c::mBlureRate;
+DUSK_GAME_DATA u8 mDoGph_gInf_c::mBlureRate;
 
-u8 mDoGph_gInf_c::mFade;
+DUSK_GAME_DATA u8 mDoGph_gInf_c::mFade;
 
-bool mDoGph_gInf_c::mAutoForcus;
+DUSK_GAME_DATA bool mDoGph_gInf_c::mAutoForcus;
 
 void mDoGph_gInf_c::create() {
     #if PLATFORM_WII || PLATFORM_SHIELD
@@ -399,16 +400,16 @@ void mDoGph_gInf_c::onBlure() {
 }
 
 #if PLATFORM_WII || PLATFORM_SHIELD || TARGET_PC
-TGXTexObj mDoGph_gInf_c::m_fullFrameBufferTexObj;
+DUSK_GAME_DATA TGXTexObj mDoGph_gInf_c::m_fullFrameBufferTexObj;
 #endif
 
-TGXTexObj mDoGph_gInf_c::mFrameBufferTexObj;
+DUSK_GAME_DATA TGXTexObj mDoGph_gInf_c::mFrameBufferTexObj;
 
-TGXTexObj mDoGph_gInf_c::mZbufferTexObj;
+DUSK_GAME_DATA TGXTexObj mDoGph_gInf_c::mZbufferTexObj;
 
-mDoGph_gInf_c::bloom_c mDoGph_gInf_c::m_bloom;
+DUSK_GAME_DATA mDoGph_gInf_c::bloom_c mDoGph_gInf_c::m_bloom;
 
-Mtx mDoGph_gInf_c::mBlureMtx;
+DUSK_GAME_DATA Mtx mDoGph_gInf_c::mBlureMtx;
 
 #if !PLATFORM_GCN
 cXyz mDoGph_gInf_c::csr_c::m_nowEffPos(0.0f, 0.0f, 0.0f);
@@ -473,38 +474,35 @@ void darwFilter(GXColor matColor) {
 }
 
 void mDoGph_gInf_c::calcFade() {
-#if TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        if (mFade != 0) {
-            mFadeRate += mFadeSpeed;
+    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+    if (mFade != 0) {
+        mFadeRate += mFadeSpeed;
 
-            if (mFadeRate < 0.0f) {
-                mFadeRate = 0.0f;
-                mFade = 0;
-            } else {
-                if (mFadeRate > 1.0f) {
-                    mFadeRate = 1.0f;
-                }
-            }
-            mFadeColor.a = 255.0f * mFadeRate;
+        if (mFadeRate < 0.0f) {
+            mFadeRate = 0.0f;
+            mFade = 0;
         } else {
-            if (dComIfG_getBrightness() != 255) {
-                mFadeColor.r = 0;
-                mFadeColor.g = 0;
-                mFadeColor.b = 0;
-                mFadeColor.a = 255 - dComIfG_getBrightness();
-            } else {
-                mFadeColor.a = 0;
+            if (mFadeRate > 1.0f) {
+                mFadeRate = 1.0f;
             }
         }
+        mFadeColor.a = 255.0f * mFadeRate;
+    } else {
+        if (dComIfG_getBrightness() != 255) {
+            mFadeColor.r = 0;
+            mFadeColor.g = 0;
+            mFadeColor.b = 0;
+            mFadeColor.a = 255 - dComIfG_getBrightness();
+        } else {
+            mFadeColor.a = 0;
+        }
     }
+    IF_DUSK_BLOCK_END
 
     if (mFadeColor.a != 0) {
-#ifdef TARGET_PC
-        if (dusk::frame_interp::is_enabled() && mFade != 0) {
-            const auto step = dusk::frame_interp::get_interpolation_step();
+#if TARGET_PC
+        if (dusk::interp::is_enabled() && mFade != 0) {
+            const auto step = dusk::interp::get_interpolation_step();
             const auto progress = mFadeSpeed < 0.0f ? 1.0f - mFadeRate : mFadeRate;
             const auto fade_amt = mFadeRate + mFadeSpeed * (step - 1.0f + progress);
             mFadeColor.a = 255.0f * std::clamp(fade_amt, 0.0f, 1.0f);
@@ -523,15 +521,15 @@ void mDoGph_gInf_c::csr_c::particleExecute() {
 #endif
 
 #if WIDESCREEN_SUPPORT
-u8 mDoGph_gInf_c::mWideZoom;
+DUSK_GAME_DATA u8 mDoGph_gInf_c::mWideZoom;
 
-int mDoGph_gInf_c::m_minX;
+DUSK_GAME_DATA int mDoGph_gInf_c::m_minX;
 
-int mDoGph_gInf_c::m_minY;
+DUSK_GAME_DATA int mDoGph_gInf_c::m_minY;
 
-f32 mDoGph_gInf_c::m_minXF;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_minXF;
 
-f32 mDoGph_gInf_c::m_minYF;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_minYF;
 
 #if PLATFORM_WII || PLATFORM_SHIELD
 mDoGph_gInf_c::csr_c* mDoGph_gInf_c::m_baseCsr;
@@ -543,29 +541,29 @@ mDoGph_gInf_c::csr_c* mDoGph_gInf_c::m_csr;
 JKRHeap* mDoGph_gInf_c::m_heap;
 #endif
 
-u8 mDoGph_gInf_c::mWide = 1;
+DUSK_GAME_DATA u8 mDoGph_gInf_c::mWide = 1;
 
-f32 mDoGph_gInf_c::m_aspect = 1.3571428f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_aspect = 1.3571428f;
 
-f32 mDoGph_gInf_c::m_scale = 1.0f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_scale = 1.0f;
 
-f32 mDoGph_gInf_c::m_invScale = 1.0f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_invScale = 1.0f;
 
-int mDoGph_gInf_c::m_maxX = FB_WIDTH_BASE - 1;
+DUSK_GAME_DATA int mDoGph_gInf_c::m_maxX = FB_WIDTH_BASE - 1;
 
-int mDoGph_gInf_c::m_maxY = FB_HEIGHT_BASE - 1;
+DUSK_GAME_DATA int mDoGph_gInf_c::m_maxY = FB_HEIGHT_BASE - 1;
 
-int mDoGph_gInf_c::m_width = FB_WIDTH_BASE;
+DUSK_GAME_DATA int mDoGph_gInf_c::m_width = FB_WIDTH_BASE;
 
-int mDoGph_gInf_c::m_height = FB_HEIGHT_BASE;
+DUSK_GAME_DATA int mDoGph_gInf_c::m_height = FB_HEIGHT_BASE;
 
-f32 mDoGph_gInf_c::m_maxXF = FB_WIDTH_BASE - 1;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_maxXF = FB_WIDTH_BASE - 1;
 
-f32 mDoGph_gInf_c::m_maxYF = FB_HEIGHT_BASE - 1;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_maxYF = FB_HEIGHT_BASE - 1;
 
-f32 mDoGph_gInf_c::m_widthF = FB_WIDTH_BASE;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_widthF = FB_WIDTH_BASE;
 
-f32 mDoGph_gInf_c::m_heightF = FB_HEIGHT_BASE;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_heightF = FB_HEIGHT_BASE;
 
 struct tvSize {
     u16 width;
@@ -574,7 +572,7 @@ struct tvSize {
 #ifndef TARGET_PC
 const
 #endif
-tvSize l_tvSize[2] = {
+DUSK_GAME_DATA tvSize l_tvSize[2] = {
     {FB_WIDTH_BASE, FB_HEIGHT_BASE},
     {808, FB_HEIGHT_BASE},
 };
@@ -719,14 +717,14 @@ void mDoGph_gInf_c::setWideZoomLightProjection(Mtx& m) {
 #endif
 
 #if TARGET_PC
-f32 mDoGph_gInf_c::hudAspectScaleDown = 1.0f;
-f32 mDoGph_gInf_c::hudAspectScaleUp = 1.0f;
-f32 mDoGph_gInf_c::m_safeMinXF = 0.0f;
-f32 mDoGph_gInf_c::m_safeMinYF = 0.0f;
-f32 mDoGph_gInf_c::m_safeMaxXF = FB_WIDTH_BASE;
-f32 mDoGph_gInf_c::m_safeMaxYF = FB_HEIGHT_BASE;
-f32 mDoGph_gInf_c::m_safeWidthF = FB_WIDTH_BASE;
-f32 mDoGph_gInf_c::m_safeHeightF = FB_HEIGHT_BASE;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::hudAspectScaleDown = 1.0f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::hudAspectScaleUp = 1.0f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_safeMinXF = 0.0f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_safeMinYF = 0.0f;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_safeMaxXF = FB_WIDTH_BASE;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_safeMaxYF = FB_HEIGHT_BASE;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_safeWidthF = FB_WIDTH_BASE;
+DUSK_GAME_DATA f32 mDoGph_gInf_c::m_safeHeightF = FB_HEIGHT_BASE;
 
 void mDoGph_gInf_c::updateSafeAreaBounds() {
     m_safeMinXF = m_minXF;
@@ -2169,7 +2167,7 @@ static void captureScreenPerspDrawInfo(JPADrawInfo& info) {
 static void drawItem3D() {
     ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::frame_interp::is_enabled()) {
+    if (dusk::interp::is_enabled()) {
         // FRAME INTERP NOTE: Title screen needs 0.0f while everything else that runs through this is -100.0f.
         if (fopAcM_SearchByName(fpcNm_TITLE_e) != nullptr) {
             dMenu_Collect3D_c::setViewPortOffsetY(0.0f);
@@ -2212,12 +2210,7 @@ int mDoGph_Painter() {
     drawHeapMap();
     #endif
 
-#ifdef TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        dComIfGp_particle_calcMenu();
-    }
+    IF_NOT_DUSK(dComIfGp_particle_calcMenu());
 
     JFWDisplay::getManager()->setFader(mDoGph_gInf_c::getFader());
     mDoGph_gInf_c::setClearColor(mDoGph_gInf_c::getBackColor());
@@ -2347,7 +2340,7 @@ int mDoGph_Painter() {
 #endif
             dKy_setLight();
 #if TARGET_PC
-            if (dusk::frame_interp::is_enabled()) {
+            if (dusk::interp::is_enabled()) {
                 dKy_setLight_again();
             }
 #endif
@@ -2356,6 +2349,10 @@ int mDoGph_Painter() {
 
             GXSetClipMode(GX_CLIP_ENABLE);
 
+#if TARGET_PC
+            dusk::mods::gfx_run_stage(GFX_STAGE_SCENE_BEGIN, &camera_p->view, view_port);
+#endif
+
             #if DEBUG
             // "drawing up to Background (Translucent) (Rendering)"
             fapGm_HIO_c::stopCpuTimer("背景（半透明）描画まで（レンダリング）");
@@ -2384,6 +2381,10 @@ int mDoGph_Painter() {
 
             GX_DEBUG_GROUP(dComIfGd_drawShadow, camera_p->view.viewMtx);
 
+#if TARGET_PC
+            dusk::mods::gfx_run_stage(GFX_STAGE_SCENE_AFTER_TERRAIN, &camera_p->view, view_port);
+#endif
+
             #if DEBUG
             // "shadow drawing (Rendering)"
             fapGm_HIO_c::stopCpuTimer("影描画（レンダリング）");
@@ -2402,17 +2403,17 @@ int mDoGph_Painter() {
             }
 
 #if TARGET_PC
-            if (dusk::frame_interp::is_enabled()) {
-                // FRAME INTERP NOTE: Currently only recalculating points for Epona's reins. Need a more global solution.
-                if (daHorse_c* horse = dComIfGp_getHorseActor()) {
-                    horse->lerpControlPoints(dusk::frame_interp::get_interpolation_step());
-                }
-                g_dComIfG_gameInfo.drawlist.refresh3DlineMats(camera_p->view.lookat.eye);
+            if (dusk::interp::is_enabled()) {
+                g_dComIfG_gameInfo.drawlist.refresh3DlineMats();
             }
 #endif
 
             GX_DEBUG_GROUP(dComIfGd_drawOpaListPacket);
 
+#if TARGET_PC
+            dusk::mods::gfx_run_stage(GFX_STAGE_SCENE_AFTER_OPAQUE, &camera_p->view, view_port);
+#endif
+
             #if DEBUG
             // "drawing up to special-use drawing (Opaque) except J3D (Rendering)"
             fapGm_HIO_c::stopCpuTimer("Ｊ３Ｄ以外などの特殊用（不透明）描画まで（レンダリング）");
@@ -2761,12 +2762,9 @@ int mDoGph_Painter() {
     #endif
 
     GXSetClipMode(GX_CLIP_ENABLE);
-#if TARGET_PC
-    if (dusk::frame_interp::get_ui_tick_pending())
-#endif
-    {
-        dDlst_list_c::calcWipe();
-    }
+    IF_DUSK_BLOCK(dusk::interp::get_ui_tick_pending())
+    dDlst_list_c::calcWipe();
+    IF_DUSK_BLOCK_END
     j3dSys.reinitGX();
 
     ortho.setOrtho(mDoGph_gInf_c::getMinXF(), mDoGph_gInf_c::getMinYF(),
@@ -2778,6 +2776,10 @@ int mDoGph_Painter() {
     captureScreenSetPort();
     #endif
 
+#if TARGET_PC
+    dusk::mods::gfx_run_stage(GFX_STAGE_FRAME_BEFORE_HUD);
+#endif
+
     if (fapGmHIO_get2Ddraw()) {
         Mtx m4;
         cMtx_copy(j3dSys.getViewMtx(), m4);
@@ -2835,6 +2837,10 @@ int mDoGph_Painter() {
         dComIfGd_draw2DXlu();
     }
 
+#if TARGET_PC
+    dusk::mods::gfx_run_stage(GFX_STAGE_FRAME_AFTER_HUD);
+#endif
+
     #if DEBUG
     if (dJcame_c::get()) {
         dJcame_c::get()->show2D();
diff --git a/src/m_Do/m_Do_lib.cpp b/src/m_Do/m_Do_lib.cpp
index b46527b11c..389826d44e 100644
--- a/src/m_Do/m_Do_lib.cpp
+++ b/src/m_Do/m_Do_lib.cpp
@@ -38,11 +38,11 @@ u32 mDoLib_setResTimgObj(ResTIMG const* i_img, TGXTexObj* o_texObj, u32 tlut_nam
     return i_img->indexTexture;
 }
 
-J3DUClipper mDoLib_clipper::mClipper;
+DUSK_GAME_DATA J3DUClipper mDoLib_clipper::mClipper;
 
-f32 mDoLib_clipper::mSystemFar;
+DUSK_GAME_DATA f32 mDoLib_clipper::mSystemFar;
 
-f32 mDoLib_clipper::mFovyRate;
+DUSK_GAME_DATA f32 mDoLib_clipper::mFovyRate;
 
 void mDoLib_clipper::setup(f32 fovy, f32 aspect, f32 near_, f32 far_) {
     mClipper.setFovy(fovy);
diff --git a/src/m_Do/m_Do_machine.cpp b/src/m_Do/m_Do_machine.cpp
index ae22c5dbe2..3d0acca1a9 100644
--- a/src/m_Do/m_Do_machine.cpp
+++ b/src/m_Do/m_Do_machine.cpp
@@ -73,7 +73,7 @@ u8 mDoMch::FpscrEnableBits;
 u8 mDoMch::GXWarningLevel;
 u8 mDoMch::GXWarningExecuteFrame;
 #else
-u8 mDoMch::mDebugFill;
+DUSK_GAME_DATA u8 mDoMch::mDebugFill;
 #endif
 
 static int solidHeapErrors;
@@ -91,7 +91,7 @@ static int unknownHeapErrors;
 static u32 heapErrors;
 
 #if VERSION == VERSION_GCN_USA || VERSION == VERSION_GCN_JPN
-GXRenderModeObj g_ntscZeldaIntDf = {
+DUSK_GAME_DATA GXRenderModeObj g_ntscZeldaIntDf = {
     VI_TVMODE_NTSC_INT,
     608,
     448,
@@ -118,7 +118,7 @@ GXRenderModeObj g_ntscZeldaIntDf = {
     {8, 8, 10, 12, 10, 8, 8},
 };
 
-GXRenderModeObj g_ntscZeldaProg = {
+DUSK_GAME_DATA GXRenderModeObj g_ntscZeldaProg = {
     VI_TVMODE_NTSC_PROG,
     608,
     448,
@@ -277,7 +277,7 @@ GXRenderModeObj g_palZeldaProg60 = {
 };
 #endif
 
-GXRenderModeObj* mDoMch_render_c::mRenderModeObj = &g_ntscZeldaIntDf;
+DUSK_GAME_DATA GXRenderModeObj* mDoMch_render_c::mRenderModeObj = &g_ntscZeldaIntDf;
 
 static const char* myGetHeapTypeByString(JKRHeap* p_heap) {
     static char tmpString[5];
@@ -527,7 +527,7 @@ void myExceptionCallback(u16, OSContext*, u32, u32) {
     u32 btnHold;
     u32 btnTrig;
 
-    mDoMain::sHungUpTime = OSGetTime();
+    mDoMain::sHungUpTime = DUSK_IF_ELSE(OSGetSystemTime(), OSGetTime());
     OSReportEnable();
     cAPICPad_recalibrate();
     // "Vibration stopping & resetting to default\n"
diff --git a/src/m_Do/m_Do_main.cpp b/src/m_Do/m_Do_main.cpp
index ce029035b1..51eb5633e6 100644
--- a/src/m_Do/m_Do_main.cpp
+++ b/src/m_Do/m_Do_main.cpp
@@ -5,110 +5,108 @@
  */
 
 #include "m_Do/m_Do_main.h"
-#include <dolphin/vi.h>
-#include <cstring>
 #include "DynamicLink.h"
 #include "JSystem/JAudio2/JASAudioThread.h"
-#include "JSystem/JAudio2/JAUSectionHeap.h"
 #include "JSystem/JAudio2/JAUSoundTable.h"
 #include "JSystem/JFramework/JFWSystem.h"
-#include "JSystem/JHostIO/JORServer.h"
 #include "JSystem/JKernel/JKRAram.h"
 #include "JSystem/JKernel/JKRSolidHeap.h"
 #include "JSystem/JUtility/JUTConsole.h"
+#include "JSystem/JUtility/JUTReport.h"
 #include "JSystem/JUtility/JUTException.h"
 #include "JSystem/JUtility/JUTProcBar.h"
-#include "JSystem/JUtility/JUTReport.h"
-#include "SSystem/SComponent/c_counter.h"
-#include "SSystem/SComponent/c_API_graphic.h"
+#include "JSystem/JHostIO/JORServer.h"
 #include "Z2AudioLib/Z2WolfHowlMgr.h"
 #include "c/c_dylink.h"
 #include "d/d_com_inf_game.h"
-#include "d/d_debug_pad.h"
 #include "d/d_s_logo.h"
 #include "d/d_s_menu.h"
 #include "d/d_s_play.h"
-#include "dusk/time.h"
+#include "d/d_debug_pad.h"
 #include "f_ap/f_ap_game.h"
 #include "f_op/f_op_msg.h"
 #include "m_Do/m_Do_MemCard.h"
 #include "m_Do/m_Do_Reset.h"
 #include "m_Do/m_Do_controller_pad.h"
 #include "m_Do/m_Do_dvd_thread.h"
-#include "m_Do/m_Do_ext2.h"
 #include "m_Do/m_Do_graphic.h"
 #include "m_Do/m_Do_machine.h"
 #include "m_Do/m_Do_printf.h"
 #include "m_Do/m_Do_ext2.h"
-#include "SSystem/SComponent/c_counter.h"
 #include <cstring>
 
-#include <filesystem>
-#include <system_error>
-#include <thread>
-#include "SSystem/SComponent/c_API.h"
-#include "dusk/android_frame_rate.hpp"
 #include "dusk/app_info.hpp"
-#include "dusk/crash_handler.h"
-#include "dusk/crash_reporting.h"
+#include "dusk/audio/DuskAudioSystem.h"
+#include "dusk/audio/DuskDsp.hpp"
+#include "dusk/commands.hpp"
+#include "dusk/config.hpp"
 #include "dusk/data.hpp"
+#include "dusk/discord_presence.hpp"
 #include "dusk/dusk.h"
-#include "dusk/frame_interpolation.h"
 #include "dusk/game_clock.h"
+#include "dusk/game_combos.h"
 #include "dusk/gyro.h"
-#include "dusk/mouse.h"
+#include "dusk/hq_minimap.hpp"
 #include "dusk/imgui/ImGuiConsole.hpp"
 #include "dusk/imgui/ImGuiEngine.hpp"
+#include "dusk/interp/frame_interpolation.h"
 #include "dusk/iso_validate.hpp"
-#include "dusk/mod_loader.hpp"
 #include "dusk/logging.h"
 #include "dusk/main.h"
+#include "dusk/mod_loader.hpp"
+#include "dusk/mods/svc/window.hpp"
+#include "dusk/mouse.h"
+#include "dusk/os.h"
+#include "dusk/presentation.hpp"
+#include "dusk/settings.h"
+#include "dusk/speedrun.h"
+#include "dusk/texture_replacements.hpp"
+#include "dusk/time.h"
+#include "dusk/ui/command_console.hpp"
 #include "dusk/ui/menu_bar.hpp"
 #include "dusk/ui/overlay.hpp"
 #include "dusk/ui/prelaunch.hpp"
 #include "dusk/ui/preset.hpp"
+#if BOREALIS_HAS_SENTRY
+#include "dusk/ui/reporting.hpp"
+#endif
 #include "dusk/ui/touch_controls.hpp"
 #include "dusk/ui/ui.hpp"
-#include "version.h"
+#include "dusk/version.hpp"
+
+#include "d/actor/d_a_movie_player.h"
+
+#include "SSystem/SComponent/c_API_graphic.h"
 
 #include <aurora/aurora.h>
-#include <aurora/event.h>
-#include <aurora/main.h>
 #include <aurora/dvd.h>
+#include <aurora/event.h>
+#include <borealis/aurora_log.h>
+#include <borealis/cli.hpp>
+#include <borealis/crash.hpp>
+#include <borealis/io.hpp>
+#include <borealis/sentry.hpp>
+#include <borealis/task.hpp>
+#include <borealis/version.h>
+#include <cxxopts.hpp>
 #include <dolphin/dvd.h>
+#include <SDL3/SDL_init.h>
+#include <tracy/Tracy.hpp>
+
+#include <filesystem>
+#include <system_error>
+#include <thread>
 
-#include "SDL3/SDL_init.h"
-#include "SDL3/SDL_iostream.h"
-#include "SDL3/SDL_misc.h"
-#include "cxxopts.hpp"
-#include "d/actor/d_a_movie_player.h"
-#include "dusk/audio/DuskAudioSystem.h"
-#include "dusk/audio/DuskDsp.hpp"
-#include "dusk/config.hpp"
-#include "dusk/speedrun.h"
-#include "dusk/settings.h"
-#include "dusk/texture_replacements.hpp"
-#include "dusk/io.hpp"
-#include "dusk/version.hpp"
-#include "dusk/discord_presence.hpp"
-#include "tracy/Tracy.hpp"
-#include "f_pc/f_pc_draw.h"
-#include "tracy/Tracy.hpp"
-#include <RmlUi/Core.h>
 #ifdef __APPLE__
 #include <TargetConditionals.h>
 #endif
 
-#if DUSK_ENABLE_SENTRY_NATIVE
-#include "dusk/ui/reporting.hpp"
-#endif
-
 // --- GLOBALS ---
-s8 mDoMain::developmentMode = -1;
-OSTime mDoMain::sPowerOnTime;
-OSTime mDoMain::sHungUpTime;
-u32 mDoMain::memMargin = 0xFFFFFFFF;
-char mDoMain::COPYDATE_STRING[18] = "??/??/?? ??:??:??";
+DUSK_GAME_DATA s8 mDoMain::developmentMode = -1;
+DUSK_GAME_DATA OSTime mDoMain::sPowerOnTime;
+DUSK_GAME_DATA OSTime mDoMain::sHungUpTime;
+DUSK_GAME_DATA u32 mDoMain::memMargin = 0xFFFFFFFF;
+DUSK_GAME_DATA char mDoMain::COPYDATE_STRING[18] = "??/??/?? ??:??:??";
 #if TARGET_PC
 const int audioHeapSize = 0x14D800 * 2;
 #else
@@ -120,20 +118,6 @@ const int audioHeapSize = 0x14D800;
 // =========================================================================
 #define COPYDATE_PATH "/str/Final/Release/COPYDATE"
 
-#if TARGET_PC
-bool dusk::IsRunning = true;
-bool dusk::IsShuttingDown = false;
-bool dusk::IsGameLaunched = false;
-bool dusk::RestartRequested = false;
-std::filesystem::path dusk::ConfigPath;
-std::filesystem::path dusk::CachePath;
-#endif
-
-void dusk::RequestRestart() noexcept {
-    RestartRequested = SupportsProcessRestart;
-    IsRunning = false;
-}
-
 s32 LOAD_COPYDATE(void*) {
     char buffer[32];
     memset(buffer, 0, sizeof(buffer));
@@ -162,8 +146,6 @@ s32 LOAD_COPYDATE(void*) {
 }
 
 AuroraInfo auroraInfo;
-AuroraStats dusk::lastFrameAuroraStats;
-float dusk::frameUsagePct = 0.0f;
 
 bool launchUILoop() {
     while (dusk::IsRunning && !dusk::IsGameLaunched) {
@@ -171,6 +153,9 @@ bool launchUILoop() {
         while (event != nullptr && event->type != AURORA_NONE) {
             switch (event->type) {
             case AURORA_SDL_EVENT:
+                if (dusk::mods::svc::window_dispatch_event(event->sdl)) {
+                    break;
+                }
                 dusk::mouse::handle_event(event->sdl);
                 dusk::ui::handle_event(event->sdl);
                 dusk::g_imguiConsole.HandleSDLEvent(event->sdl);
@@ -239,7 +224,7 @@ void main01(void) {
 
     OSReport("Entering Main Loop (main01)...\n");
 
-    dusk::game_clock::ensure_initialized();
+    dusk::game_clock::initialize();
 
     do {
         // 1. Update Window Events
@@ -254,10 +239,13 @@ void main01(void) {
                 break;
             case AURORA_UNPAUSED:
                 dusk::audio::SetPaused(false);
-                dusk::game_clock::reset_frame_timer();
+                dusk::game_clock::reset();
                 dusk::mouse::on_focus_gained();
                 break;
             case AURORA_SDL_EVENT:
+                if (dusk::mods::svc::window_dispatch_event(event->sdl)) {
+                    break;
+                }
                 dusk::mouse::handle_event(event->sdl);
                 dusk::ui::handle_event(event->sdl);
                 dusk::g_imguiConsole.HandleSDLEvent(event->sdl);
@@ -293,53 +281,58 @@ void main01(void) {
 
         dusk::ui::update();
 
-        const auto pacing = dusk::game_clock::advance_main_loop();
-        if (pacing.is_interpolating) {
-            if (pacing.sim_ticks_to_run > 0) {
-                dusk::frame_interp::begin_frame(dusk::getSettings().game.enableFrameInterpolation, true, 0.0f);
-                dusk::frame_interp::set_ui_tick_pending(true);
-
-                for (int sim_tick = 0; sim_tick < pacing.sim_ticks_to_run; ++sim_tick) {
-                    dusk::frame_interp::begin_sim_tick();
+        const auto timing = dusk::game_clock::advance();
+        if (timing.separatePresentation) {
+            if (timing.numSimTicks > 0) {
+                dusk::interp::begin_frame(0.0f);
+                dusk::interp::set_ui_tick_pending(true);
+                for (int i = 0; i < timing.numSimTicks; ++i) {
+                    if (timing.interpolating) {
+                        dusk::interp::begin_sim_tick();
+                    }
+                    dusk::game_clock::begin_sim_tick();
                     mDoCPd_c::read();
                     dusk::mouse::read();
-                    dusk::gyro::read(pacing.sim_pace);
+                    dusk::gyro::read(dusk::game_clock::kSimPeriod);
+                    dusk::processGameCombos();
                     fapGm_Execute();
+                    dusk::processCameraCommands();
                     mDoAud_Execute();
                     dusk::game_clock::commit_sim_tick();
                 }
             }
 
-            dusk::frame_interp::begin_frame(dusk::getSettings().game.enableFrameInterpolation, false,
-                                            dusk::game_clock::sample_interpolation_step());
-            dusk::frame_interp::interpolate();
-            dusk::frame_interp::begin_presentation_camera();
-            // run draw functions for anything specially marked to handle interp
+            const float step = timing.interpolating ? dusk::game_clock::sample_interpolation_step() : 1.0f;
+            dusk::interp::begin_presentation(step);
             fpcM_DrawIterater((fpcM_DrawIteraterFunc)fpcM_Draw);
             cAPIGph_Painter();
-            dusk::frame_interp::end_presentation_camera();
-            dusk::frame_interp::set_ui_tick_pending(false);
+            dusk::interp::end_presentation();
+            dusk::interp::set_ui_tick_pending(false);
         } else {
-            dusk::frame_interp::begin_frame(dusk::FrameInterpMode::Off, true, 0.0f);
-            dusk::frame_interp::set_ui_tick_pending(true);
+            dusk::interp::begin_frame(0.0f);
+            dusk::interp::set_ui_tick_pending(true);
+            dusk::game_clock::begin_sim_tick();
 
             // Game Inputs
             mDoCPd_c::read();
             dusk::mouse::read();
-            dusk::gyro::read(pacing.presentation_dt_seconds);
+            dusk::gyro::read(timing.dt);
+            dusk::processGameCombos();
 
             // EXECUTE GAME LOGIC & RENDER
             // This calls mDoGph_Painter -> JFWDisplay -> GX Functions
             fapGm_Execute();
+            dusk::processCameraCommands();
 
             mDoAud_Execute();
+            dusk::game_clock::commit_sim_tick();
         }
 
         aurora_end_frame();
 
         FrameMark;
 
-#ifdef DUSK_DISCORD
+#if BOREALIS_HAS_DISCORD
         dusk::discord::run_callbacks();
         dusk::discord::update_presence();
 #endif
@@ -348,7 +341,10 @@ void main01(void) {
         static double last_fps_setting = 0.0;
         static Limiter::duration_t target_ns = 0;
 
-        if (dusk::getSettings().game.enableFrameInterpolation.getValue() == dusk::FrameInterpMode::Capped && !dusk::getTransientSettings().skipFrameRateLimit) {
+        if (dusk::getSettings().game.enableFrameInterpolation.getValue() ==
+                dusk::FrameInterpMode::Capped &&
+            !dusk::getTransientSettings().turboMode)
+        {
             ZoneScopedN("Frame limiter");
             double current_fps = dusk::getSettings().video.maxFrameRate.getValue();
             if (current_fps != last_fps_setting) {
@@ -357,7 +353,8 @@ void main01(void) {
             }
 
             Limiter::duration_t sleepTime = main_loop_limiter.Sleep(target_ns);
-            dusk::frameUsagePct = 100.0f * (1.0f - static_cast<float>(sleepTime) / static_cast<float>(target_ns));
+            dusk::frameUsagePct =
+                100.0f * (1.0f - static_cast<float>(sleepTime) / static_cast<float>(target_ns));
         } else {
             main_loop_limiter.Reset();
         }
@@ -487,318 +484,16 @@ static void LanguageInit() {
 }
 
 static void log_build_info() {
-    DuskLog.info("Build: {} (rev {}, built {}, type {})", DUSK_WC_DESCRIBE, DUSK_WC_REVISION, DUSK_WC_DATE, DUSK_BUILD_TYPE);
-    DuskLog.info("Platform: {}", DUSK_PLATFORM_NAME);
+    DuskLog.info("Build: {} (rev {}, built {}, type {})", BOREALIS_APP_DESCRIBE, BOREALIS_APP_REVISION, BOREALIS_APP_DATE, BOREALIS_BUILD_TYPE);
+    DuskLog.info("Platform: {}", BOREALIS_PLATFORM_NAME);
 }
 
-// =========================================================================
-// PC ENTRY POINT
-// =========================================================================
-int game_main(int argc, char* argv[]) {
-    // On iOS, when connected to an external monitor, SDLUIKitSceneDelegate scene:willConnectToSession:
-    // can call our main function again. Explicitly guard against this reinitialization.
-    if (mainCalled) {
-        return 0;
-    }
-    mainCalled = true;
-
-    dusk::registerSettings();
-
-    cxxopts::ParseResult parsed_arg_options;
-
-    try {
-        cxxopts::Options arg_options("Dusklight", "PC Port of a classic adventure game");
-
-        arg_options.add_options()
-            ("l,log-level", "Log level from " + std::to_string(AuroraLogLevel::LOG_DEBUG) + " to " + std::to_string(AuroraLogLevel::LOG_FATAL), cxxopts::value<uint8_t>()->default_value("0"))
-            ("h,help", "Print usage")
-            ("console", "Show the Windows console window for logs", cxxopts::value<bool>()->default_value("false")->implicit_value("true"))
-            ("dvd", "Path to DVD image file", cxxopts::value<std::string>())
-            ("mods", "Path to mods directory", cxxopts::value<std::string>())
-            ("backend", "Graphics API backend to use (auto, d3d12, d3d11, metal, vulkan, null)", cxxopts::value<std::string>())
-            ("cvar", "Override configuration variables without modifying config", cxxopts::value<std::vector<std::string>>());
-
-        arg_options.parse_positional({"dvd"});
-        arg_options.positional_help("<dvd-image>");
-        arg_options.allow_unrecognised_options();
-
-        parsed_arg_options = arg_options.parse(argc, argv);
-
-        if (parsed_arg_options.count("help"))
-        {
-            printf("%s", (arg_options.help() + "\n").c_str());
-            exit(0);
-        }
-    }
-    catch (const cxxopts::exceptions::exception& e) {
-        fprintf(stderr, "Argument Error: %s\n", e.what());
-        exit(1);
-    }
-
-    const auto startupLogLevel =
-        static_cast<AuroraLogLevel>(parsed_arg_options["log-level"].as<uint8_t>());
-    const auto dataPaths = dusk::data::initialize_data();
-    dusk::ConfigPath = dataPaths.userPath;
-    dusk::CachePath = dataPaths.cachePath;
-    dusk::InitializeFileLogging(dusk::CachePath, startupLogLevel);
-
-    log_build_info();
-
-    dusk::config::load_from_user_preferences();
-    ApplyCVarOverrides(parsed_arg_options["cvar"]);
-    dusk::android::update_surface_frame_rate();
-    dusk::crash_reporting::initialize();
-    dusk::crash_handler::install();
-    // TODO: How to handle this?
-    // PADSetDefaultMapping(&defaultPadMapping, PAD_TYPE_STANDARD);
-
-    {
-        const auto mappingsPath = dusk::ConfigPath / "gamecontrollerdb.txt";
-        std::error_code ec;
-        if (std::filesystem::exists(mappingsPath, ec)) {
-            const auto mappingsPathString = dusk::io::fs_path_to_string(mappingsPath);
-            if (SDL_AddGamepadMappingsFromFile(mappingsPathString.c_str()) < 0) {
-                DuskLog.warn("Failed to load gamecontrollerdb.txt from '{}': {}",
-                    mappingsPathString, SDL_GetError());
-            }
-        } else if (ec) {
-            DuskLog.warn("Failed to inspect gamecontrollerdb.txt in data folder '{}': {}",
-                dusk::io::fs_path_to_string(mappingsPath), ec.message());
-        }
-    }
-
-    // Set SDL metadata for audio mixers and macOS "About" menu
-    SDL_SetAppMetadata("Dusklight", DUSK_VERSION_STRING, "dev.twilitrealm.dusk");
-
-    {
-        const auto userPathString = dusk::ConfigPath.u8string();
-        const auto cachePathString = dusk::CachePath.u8string();
-        AuroraConfig config{};
-        config.appName = dusk::AppName;
-        config.userPath = reinterpret_cast<const char*>(userPathString.c_str());
-        config.cachePath = reinterpret_cast<const char*>(cachePathString.c_str());
-#ifdef DUSK_ASSET_DIR
-        config.resourcesPath = DUSK_ASSET_DIR;
-#endif
-        config.vsync = dusk::getSettings().video.enableVsync;
-        config.startFullscreen = dusk::getSettings().video.enableFullscreen;
-        config.windowPosX = -1;
-        config.windowPosY = -1;
-
-        const int lastWindowWidth = dusk::getSettings().video.lastWindowWidth.getValue();
-        const int lastWindowHeight = dusk::getSettings().video.lastWindowHeight.getValue();
-
-        if (dusk::getSettings().video.rememberWindowSize && lastWindowWidth > 0 && lastWindowHeight > 0) {
-            config.windowWidth = lastWindowWidth;
-            config.windowHeight = lastWindowHeight;
-        } else {
-            config.windowWidth = defaultWindowWidth * 2;
-            config.windowHeight = defaultWindowHeight * 2;
-        }
-
-        config.desiredBackend = ResolveDesiredBackend(parsed_arg_options);
-        config.logCallback = &aurora_log_callback;
-        config.logLevel = startupLogLevel;
-        config.mem1Size = 256 * 1024 * 1024;
-        config.mem2Size = 24 * 1024 * 1024;
-        config.allowJoystickBackgroundEvents = dusk::getSettings().game.allowBackgroundInput;
-        config.pauseOnFocusLost = dusk::getSettings().game.pauseOnFocusLost;
-        config.imGuiInitCallback = &aurora_imgui_init_callback;
-        config.allowTextureDumps = false;
-        auroraInfo = aurora_initialize(argc, argv, &config);
-    }
-
-    // Apply after aurora_initialize: speedrun mode mutates cvars whose change callbacks push
-    // values into aurora.
-    if (dusk::getSettings().game.speedrunMode) {
-        dusk::resetForSpeedrunMode();
-    }
-
-#ifdef DUSK_DISCORD
-    if (dusk::getSettings().game.enableDiscordPresence) {
-        dusk::discord::initialize();
-    }
-#endif
-
-    VISetWindowTitle(
-        fmt::format("Dusklight {} [{}]", DUSK_WC_DESCRIBE, dusk::backend_name(auroraInfo.backend))
-        .c_str());
-
-    if (dusk::getSettings().video.lockAspectRatio) {
-        AuroraSetViewportPolicy(AURORA_VIEWPORT_FIT);
-    } else {
-        AuroraSetViewportPolicy(AURORA_VIEWPORT_STRETCH);
-    }
-    VISetFrameBufferScale(dusk::getSettings().game.internalResolutionScale.getValue());
-    switch (dusk::getSettings().game.resampler.getValue()) {
-    case dusk::Resampler::Area:
-        aurora_set_resampler(SAMPLER_AREA);
-        break;
-    case dusk::Resampler::Bilinear:
-    default:
-        aurora_set_resampler(SAMPLER_BILINEAR);
-        break;
-    }
-
-    dusk::audio::SetMasterVolume(dusk::audio::MasterVolumeToLinear(dusk::getSettings().audio.masterVolume / 100.0f));
-    dusk::audio::SetEnableReverb(dusk::getSettings().audio.enableReverb);
-    dusk::audio::EnableHrtf = dusk::getSettings().audio.enableHrtf;
-
-    // Run ImGui UI loop if Aurora couldn't initialize a backend
-    if (auroraInfo.backend == BACKEND_NULL) {
-        launchUILoop();
-        dusk::crash_reporting::shutdown();
-        dusk::ShutdownFileLogging();
-        fflush(stdout);
-        fflush(stderr);
-#ifdef DUSK_DISCORD
-        dusk::discord::shutdown();
-#endif
-        dusk::ui::shutdown();
-        aurora_shutdown();
-        return 0;
-    }
-
-    dusk::texture_replacements::reload();
-    dusk::ui::initialize();
-    dusk::ui::push_document(std::make_unique<dusk::ui::Overlay>(), true, true);
-    dusk::ui::push_document(std::make_unique<dusk::ui::TouchControls>(), false, true);
-    dusk::ui::push_document(std::make_unique<dusk::ui::MenuBar>(), false);
-
-    // Invalidate a bad saved isoPath so that Dusklight can't get blocked from starting up.
-    // This is only a metadata check; full hash verification is handled by the prelaunch UI.
-    bool forcePreLaunchUI = false;
-    bool saveConfigBeforePrelaunch = false;
-
-    const std::string p = dusk::getSettings().backend.isoPath;
-    dusk::iso::DiscInfo discInfo{};
-    if (!p.empty() &&
-        dusk::iso::inspect(p.c_str(), discInfo) != dusk::iso::ValidationError::Success)
-    {
-        DuskLog.warn("Saved DVD image path failed validation, clearing configured path: {}", p);
-        dusk::getSettings().backend.isoPath.setValue("");
-        dusk::getSettings().backend.isoVerification.setValue(dusk::DiscVerificationState::Unknown);
-        forcePreLaunchUI = true;
-        saveConfigBeforePrelaunch = true;
-    }
-
-    std::string dvd_path;
-    bool dvd_opened = false;
-    if (parsed_arg_options.count("dvd")) {
-        dvd_path = parsed_arg_options["dvd"].as<std::string>();
-        if (dusk::iso::inspect(dvd_path.c_str(), discInfo) == dusk::iso::ValidationError::Success) {
-            DuskLog.info("Loading DVD image from command line: {}", dvd_path);
-            dvd_opened = aurora_dvd_open(dvd_path.c_str());
-            if (!dvd_opened) {
-                DuskLog.warn("Failed to open DVD image from command line: {}, opening prelaunch UI", dvd_path);
-                forcePreLaunchUI = true;
-            } else {
-                dusk::getSettings().backend.isoPath.setValue(dvd_path);
-                dusk::getSettings().backend.isoVerification.setValue(
-                    dusk::DiscVerificationState::Unknown);
-                dusk::config::save();
-                dusk::IsGameLaunched = true;
-            }
-        } else {
-            DuskLog.warn("DVD image from command line failed validation: {}, opening prelaunch UI", dvd_path);
-            forcePreLaunchUI = true;
-        }
-    }
-
-    dusk::iso::log_verification_state(
-        dusk::getSettings().backend.isoPath.getValue(),
-        dusk::getSettings().backend.isoVerification.getValue());
-
-    if (!dvd_opened) {
-        if (dusk::getSettings().backend.isoPath.getValue().empty()) {
-            forcePreLaunchUI = true;
-        }
-        if (forcePreLaunchUI && dusk::getSettings().backend.skipPreLaunchUI.getValue()) {
-            DuskLog.warn("Prelaunch UI was disabled with no usable DVD image, enabling prelaunch UI");
-            dusk::getSettings().backend.skipPreLaunchUI.setValue(false);
-            saveConfigBeforePrelaunch = true;
-        }
-        if (saveConfigBeforePrelaunch) {
-            dusk::config::save();
-        }
-
-        if (!dusk::getSettings().backend.skipPreLaunchUI) {
-            dusk::ui::push_document(std::make_unique<dusk::ui::Prelaunch>(), true);
-
-            // pre game launch ui main loop
-            if (!launchUILoop()) {
-                dusk::crash_reporting::shutdown();
-                dusk::ShutdownFileLogging();
-                fflush(stdout);
-                fflush(stderr);
-#ifdef DUSK_DISCORD
-                dusk::discord::shutdown();
-#endif
-                dusk::ui::shutdown();
-                aurora_shutdown();
-                return 0;
-            }
-        }
-
-        dvd_path = dusk::getSettings().backend.isoPath;
-
-        if (dvd_path.empty()) {
-            DuskLog.fatal("No DVD image specified, unable to boot!");
-        }
-        if (!dusk::IsGameLaunched &&
-            dusk::iso::inspect(dvd_path.c_str(), discInfo) != dusk::iso::ValidationError::Success)
-        {
-            DuskLog.fatal("DVD image failed validation: {}", dvd_path);
-        }
-        DuskLog.info("Loading DVD image: {}", dvd_path);
-        if (!aurora_dvd_open(dvd_path.c_str())) {
-            DuskLog.fatal("Failed to open DVD image: {}", dvd_path);
-        }
-
-        dusk::IsGameLaunched = true;
-    }
-
-#if DUSK_ENABLE_SENTRY_NATIVE
-    if (dusk::crash_reporting::get_consent() == dusk::crash_reporting::Consent::Unknown) {
-        dusk::ui::push_document(std::make_unique<dusk::ui::CrashReportWindow>());
-    }
-#endif
-
-    if (!dusk::getSettings().backend.wasPresetChosen) {
-        dusk::ui::push_document(std::make_unique<dusk::ui::PresetWindow>());
-    }
-
-    dusk::version::init();
-    LanguageInit();
-
-    OSInit();
-
-    mDoMain::sPowerOnTime = OSGetTime();
-
-    // Reset Data
-    static mDoRstData sResetData = {0};
-    mDoRst::setResetData(&sResetData);
-    mDoRst::offReset();
-    mDoRst::setLogoScnFlag(0);
-
-    // Global Context Init
-    dComIfG_ct();
-
-    // Development Mode
-    // mDoMain::developmentMode = 1;  // Force Dev Mode for Debugging
-    mDoDvdThd::SyncWidthSound = false;
-
+static void mods_init(const std::filesystem::path& mods_dir) {
     // Mod search directories, highest priority first: user dir (--mods replaces it), then
     // mods/ next to the app, then install-bundled mods inside the app bundle.
     {
         std::vector<dusk::mods::ModSearchDir> modDirs;
-        if (parsed_arg_options.contains("mods") &&
-            !parsed_arg_options["mods"].as<std::string>().empty())
-        {
-            modDirs.push_back({.path = parsed_arg_options["mods"].as<std::string>()});
-        } else {
-            modDirs.push_back({.path = dusk::ConfigPath / "mods"});
-        }
+        modDirs.push_back({.path = mods_dir});
 #if TARGET_ANDROID
         // APK-bundled mods are extracted to internal storage
         // by DuskActivity before SDL_main runs.
@@ -841,15 +536,434 @@ int game_main(int argc, char* argv[]) {
 
     DuskLog.info("Initializing mods...");
     dusk::mods::ModLoader::instance().init();
+}
+
+// =========================================================================
+// PC ENTRY POINT
+// =========================================================================
+int game_main(int argc, char* argv[]) {
+    // On iOS, when connected to an external monitor, SDLUIKitSceneDelegate scene:willConnectToSession:
+    // can call our main function again. Explicitly guard against this reinitialization.
+    if (mainCalled) {
+        return 0;
+    }
+    mainCalled = true;
+
+    cxxopts::ParseResult parsed_arg_options;
+    borealis::cli::StandardOptions standardOptions;
+
+    try {
+        cxxopts::Options arg_options("Dusklight", "PC Port of a classic adventure game");
+
+        borealis::cli::add_standard_options(arg_options);
+        arg_options.add_options()
+            ("h,help", "Print usage")
+            ("dvd", "Path to DVD image file", cxxopts::value<std::string>())
+            ("mods", "Path to mods directory", cxxopts::value<std::string>())
+            ("backend", "Graphics API backend to use (auto, d3d12, d3d11, metal, vulkan, null)", cxxopts::value<std::string>())
+            ("cvar", "Override configuration variables without modifying config", cxxopts::value<std::vector<std::string>>())
+            ("develop", "Enable the game's developer mode and OSReport for debugging", cxxopts::value<bool>()->default_value("false")->implicit_value("true"))
+            ("load-save", "Skip the opening and load a save from slot 1-3", cxxopts::value<uint8_t>()->default_value("0"))
+            ("stage", "Upon launching, load a stage, room, spawn point, and layer. When using --load-save, it uses the specified save on the loaded stage. Format (STAGE,ROOM,POINT,LAYER). Example: (STAGE) or (STAGE,0,0,-1)", cxxopts::value<std::string>());
+
+        arg_options.parse_positional({"dvd"});
+        arg_options.positional_help("<dvd-image>");
+        arg_options.allow_unrecognised_options();
+
+        parsed_arg_options = arg_options.parse(argc, argv);
+        standardOptions = borealis::cli::parse(parsed_arg_options);
+
+        if (parsed_arg_options.count("help"))
+        {
+            printf("%s", (arg_options.help() + "\n").c_str());
+            exit(0);
+        }
+
+        if (parsed_arg_options.count("stage")) {
+            std::stringstream ss(parsed_arg_options["stage"].as<std::string>());
+            std::string token;
+
+            std::getline(ss,token,',');
+            std::string stageName = token;
+            s8 room = 0;
+            s16 point = 0;
+            s8 layer = -1;
+            if (std::getline(ss,token,',')) {
+                room = std::stoi(token);
+                if (std::getline(ss,token,',')) {
+                    point = std::stoi(token);
+                    if (std::getline(ss,token,',')) {
+                        layer = std::stoi(token);
+                    }
+                }
+            }
+
+            dusk::StageRequested = {stageName,true, room,point,layer};
+        }
+    }
+    catch (const cxxopts::exceptions::exception& e) {
+        fprintf(stderr, "Argument Error: %s\n", e.what());
+        exit(1);
+    }
+    catch (const std::invalid_argument& e) {
+        // Handle parsing std::stoi when loading a stage
+        fprintf(stderr, "Fatal: Invalid Argument When Parsing Stage\n");
+        exit(1);
+    }
+    catch (const std::out_of_range& e) {
+        // Handle parsing std::stoi when loading a stage
+        fprintf(stderr, "Fatal: Argument Out of Range In Parsing Stage\n");
+        exit(1);
+    }
+
+    if (parsed_arg_options.contains("load-save")){
+        uint8_t slot = parsed_arg_options["load-save"].as<uint8_t>();
+        if (slot >= 1 && slot <= 3) {
+            dusk::SaveRequested = slot;
+        }
+    }
+
+    dusk::registerSettings();
+
+    const auto dataPaths = dusk::data::initialize_data(standardOptions.userDir);
+    dusk::ConfigPath = dataPaths.userPath;
+    dusk::CachePath = dataPaths.cachePath;
+    dusk::InitializeLogging(dusk::CachePath, standardOptions);
+    const auto startupLogLevel = borealis::log::level();
+
+    // Development Mode
+    if (parsed_arg_options.count("develop")) {
+        mDoMain::developmentMode = parsed_arg_options["develop"].as<bool>();  // Enable Dev Mode for Debugging
+        dusk::OSReportReallyForceEnable = parsed_arg_options["develop"].as<bool>();  // Print OSReport to console
+    }
+
+    log_build_info();
+
+    dusk::config::load_from_user_preferences();
+    ApplyCVarOverrides(parsed_arg_options["cvar"]);
+    borealis::sentry::Options sentryOptions{
+        .release = fmt::format("{}@{}", dusk::AppInfo.appName, BOREALIS_APP_DESCRIBE),
+        .databaseDirectory = dusk::CachePath / "sentry",
+    };
+    if (const char* logPath = borealis::log::file_path()) {
+        sentryOptions.attachments.emplace_back(logPath);
+    }
+    borealis::sentry::initialize(sentryOptions);
+    borealis::crash::install();
+    // TODO: How to handle this?
+    // PADSetDefaultMapping(&defaultPadMapping, PAD_TYPE_STANDARD);
+
+    {
+        const auto mappingsPath = dusk::ConfigPath / "gamecontrollerdb.txt";
+        std::error_code ec;
+        if (std::filesystem::exists(mappingsPath, ec)) {
+            const auto mappingsPathString = borealis::io::fs_path_to_string(mappingsPath);
+            if (SDL_AddGamepadMappingsFromFile(mappingsPathString.c_str()) < 0) {
+                DuskLog.warn("Failed to load gamecontrollerdb.txt from '{}': {}",
+                    mappingsPathString, SDL_GetError());
+            }
+        } else if (ec) {
+            DuskLog.warn("Failed to inspect gamecontrollerdb.txt in data folder '{}': {}",
+                borealis::io::fs_path_to_string(mappingsPath), ec.message());
+        }
+    }
+
+    // Set SDL metadata for audio mixers and macOS "About" menu
+    SDL_SetAppMetadata("Dusklight", BOREALIS_APP_VERSION, "dev.twilitrealm.dusk");
+
+    {
+        const auto userPathString = dusk::ConfigPath.u8string();
+        const auto cachePathString = dusk::CachePath.u8string();
+        AuroraConfig config{};
+        config.appName = dusk::AppName;
+        config.userPath = reinterpret_cast<const char*>(userPathString.c_str());
+        config.cachePath = reinterpret_cast<const char*>(cachePathString.c_str());
+#ifdef DUSK_ASSET_DIR
+        config.resourcesPath = DUSK_ASSET_DIR;
+#endif
+        config.vsync = dusk::getSettings().video.enableVsync;
+        config.startFullscreen = dusk::getSettings().video.enableFullscreen;
+        config.windowPosX = -1;
+        config.windowPosY = -1;
+
+        const int lastWindowWidth = dusk::getSettings().video.lastWindowWidth.getValue();
+        const int lastWindowHeight = dusk::getSettings().video.lastWindowHeight.getValue();
+
+        if (dusk::getSettings().video.rememberWindowSize && lastWindowWidth > 0 && lastWindowHeight > 0) {
+            config.windowWidth = lastWindowWidth;
+            config.windowHeight = lastWindowHeight;
+        } else {
+            config.windowWidth = defaultWindowWidth * 2;
+            config.windowHeight = defaultWindowHeight * 2;
+        }
+
+        config.desiredBackend = ResolveDesiredBackend(parsed_arg_options);
+        config.logCallback = borealis::log::aurora_callback();
+        config.logLevel = borealis::log::to_aurora_level(startupLogLevel);
+        config.mem1Size = 256 * 1024 * 1024;
+        config.mem2Size = 24 * 1024 * 1024;
+        config.allowJoystickBackgroundEvents = dusk::getSettings().game.allowBackgroundInput;
+        config.pauseOnFocusLost = dusk::getSettings().game.pauseOnFocusLost;
+        config.imGuiInitCallback = &aurora_imgui_init_callback;
+        config.allowTextureDumps = false;
+        auroraInfo = aurora_initialize(argc, argv, &config);
+    }
+
+    dusk::presentation::update_frame_rate_preference();
+
+#if BOREALIS_HAS_DISCORD
+    if (dusk::getSettings().game.enableDiscordPresence) {
+        dusk::discord::initialize();
+    }
+#endif
+
+    VISetWindowTitle(
+        fmt::format("Dusklight {} [{}]", BOREALIS_APP_DESCRIBE, dusk::backend_name(auroraInfo.backend))
+        .c_str());
+
+    if (dusk::getSettings().video.lockAspectRatio) {
+        AuroraSetViewportPolicy(AURORA_VIEWPORT_FIT);
+    } else {
+        AuroraSetViewportPolicy(AURORA_VIEWPORT_STRETCH);
+    }
+    dusk::applyInternalResolutionScale(dusk::getSettings().game.internalResolutionScale.getValue());
+    dusk::applyResampler(dusk::getSettings().game.resampler.getValue());
+
+    dusk::audio::SetMasterVolume(dusk::audio::MasterVolumeToLinear(dusk::getSettings().audio.masterVolume / 100.0f));
+    dusk::audio::SetEnableReverb(dusk::getSettings().audio.enableReverb);
+
+    // Run ImGui UI loop if Aurora couldn't initialize a backend
+    if (auroraInfo.backend == BACKEND_NULL) {
+        launchUILoop();
+        borealis::shutdown();
+        borealis::sentry::shutdown();
+        borealis::log::shutdown();
+        fflush(stdout);
+        fflush(stderr);
+#if BOREALIS_HAS_DISCORD
+        dusk::discord::shutdown();
+#endif
+        dusk::ui::shutdown();
+        aurora_shutdown();
+        return 0;
+    }
+
+    if (dusk::getSettings().game.enableHighQualityMinimapTextures.getValue()) {
+        dusk::hq_minimap::set_active(true);
+    }
+
+    dusk::texture_replacements::reload();
+    dusk::ui::initialize();
+    dusk::ui::apply_scale();
+    dusk::ui::push_document(std::make_unique<dusk::ui::Overlay>(), true, true);
+    dusk::ui::push_document(std::make_unique<dusk::ui::TouchControls>(), false, true);
+    dusk::ui::push_document(std::make_unique<dusk::ui::MenuBar>(), false);
+    dusk::ui::push_document(std::make_unique<dusk::ui::CommandConsole>(), false);
+
+    // Invalidate a bad saved isoPath so that Dusklight can't get blocked from starting up.
+    // This is only a metadata check; full hash verification is handled by the prelaunch UI.
+    bool forcePreLaunchUI = false;
+    bool saveConfigBeforePrelaunch = false;
+
+    borealis::io::PathAccess dvdPathAccess;
+    const auto resolveDvdLocation = [&dvdPathAccess](const std::string& location) {
+        dvdPathAccess = borealis::io::access_path(location);
+        return dvdPathAccess ? borealis::io::fs_path_to_string(dvdPathAccess.path()) : location;
+    };
+
+    const std::string savedLocation = dusk::getSettings().backend.isoPath;
+    dusk::iso::DiscInfo discInfo{};
+    if (!savedLocation.empty() &&
+        dusk::iso::inspect(savedLocation.c_str(), discInfo) != dusk::iso::ValidationError::Success)
+    {
+        DuskLog.warn("Saved DVD image location failed validation, clearing it: {}",
+            borealis::io::display_name(savedLocation));
+        dusk::getSettings().backend.isoPath.setValue("");
+        dusk::getSettings().backend.isoVerification.setValue(dusk::DiscVerificationState::Unknown);
+        forcePreLaunchUI = true;
+        saveConfigBeforePrelaunch = true;
+    }
+
+    bool skipPreLaunchUI = dusk::getSettings().backend.skipPreLaunchUI.getValue();
+
+    std::string dvdLocation = dusk::getSettings().backend.isoPath;
+    std::string dvdPath = resolveDvdLocation(dvdLocation);
+    bool dvd_opened = false;
+    if (parsed_arg_options.count("dvd")) {
+        dvdLocation = parsed_arg_options["dvd"].as<std::string>();
+        dvdPath = resolveDvdLocation(dvdLocation);
+        if (dusk::iso::inspect(dvdLocation.c_str(), discInfo) ==
+            dusk::iso::ValidationError::Success)
+        {
+            DuskLog.info("Loading DVD image from command line: {}", dvdPath);
+            dvd_opened = aurora_dvd_open(dvdPath.c_str());
+            if (!dvd_opened) {
+                DuskLog.warn("Failed to open DVD image from command line: {}, opening prelaunch UI",
+                    dvdPath);
+                forcePreLaunchUI = true;
+            } else {
+                dusk::getSettings().backend.isoPath.setValue(dvdLocation);
+                dusk::getSettings().backend.isoVerification.setValue(
+                    dusk::DiscVerificationState::Unknown);
+                dusk::config::save();
+                dusk::IsGameLaunched = true;
+                skipPreLaunchUI = true;
+            }
+        } else {
+            DuskLog.warn(
+                "DVD image from command line failed validation: {}, opening prelaunch UI", dvdPath);
+            forcePreLaunchUI = true;
+        }
+    }
+
+    // If we can't load right into the game, stop requesting to load a stage or save
+    if (forcePreLaunchUI || dvdPath.empty()) {
+        if (dusk::StageRequested.set) {
+            DuskLog.warn("Cannot load stage {} because no iso path is set, opening prelaunch UI",dusk::StageRequested.stage);
+            dusk::StageRequested = {};
+        }
+        if (dusk::SaveRequested) {
+            DuskLog.warn("Cannot load save {} because no iso path is set, opening prelaunch UI",dusk::SaveRequested);
+            dusk::SaveRequested = 0;
+        }
+    }else if (dusk::StageRequested.set || dusk::SaveRequested) {
+        skipPreLaunchUI = true;
+    }
+
+    dusk::iso::log_verification_state(
+        dusk::getSettings().backend.isoPath.getValue(),
+        dusk::getSettings().backend.isoVerification.getValue());
+
+    bool showPrelaunchAfterInit = true;
+    if (!dvd_opened && (dusk::getSettings().backend.isoPath.getValue().empty() || (forcePreLaunchUI && skipPreLaunchUI))) {
+        showPrelaunchAfterInit = false;
+    }
+
+    if (showPrelaunchAfterInit) {
+        // Force launchUILoop to not run, we know that the ISO will be loaded.
+        dusk::IsGameLaunched = true;
+    }
+
+    if (!dvd_opened) {
+        if (dusk::getSettings().backend.isoPath.getValue().empty()) {
+            forcePreLaunchUI = true;
+        }
+        if (forcePreLaunchUI && skipPreLaunchUI) {
+            DuskLog.warn("Prelaunch UI was disabled with no usable DVD image, enabling prelaunch UI");
+            dusk::getSettings().backend.skipPreLaunchUI.setValue(false);
+            saveConfigBeforePrelaunch = true;
+        }
+        if (saveConfigBeforePrelaunch) {
+            dusk::config::save();
+        }
+
+        if (!skipPreLaunchUI) {
+            if (!showPrelaunchAfterInit) {
+                dusk::ui::push_document(std::make_unique<dusk::ui::Prelaunch>(), true);
+            }
+
+            // pre game launch ui main loop
+            if (!launchUILoop()) {
+                borealis::shutdown();
+                borealis::sentry::shutdown();
+                borealis::log::shutdown();
+                fflush(stdout);
+                fflush(stderr);
+#if BOREALIS_HAS_DISCORD
+                dusk::discord::shutdown();
+#endif
+                dusk::ui::shutdown();
+                aurora_shutdown();
+                return 0;
+            }
+        }
+
+        dvdLocation = dusk::getSettings().backend.isoPath;
+        dvdPath = resolveDvdLocation(dvdLocation);
+        if (dvdPath.empty()) {
+            DuskLog.fatal("No DVD image specified, unable to boot!");
+        }
+        if (!dusk::IsGameLaunched && dusk::iso::inspect(dvdLocation.c_str(), discInfo) !=
+                                         dusk::iso::ValidationError::Success)
+        {
+            DuskLog.fatal("DVD image failed validation: {}", dvdPath);
+        }
+        DuskLog.info("Loading DVD image: {}", dvdPath);
+        if (!aurora_dvd_open(dvdPath.c_str())) {
+            DuskLog.fatal("Failed to open DVD image: {}", dvdPath);
+        }
+
+        dusk::IsGameLaunched = true;
+    }
+
+    dusk::version::init();
+    LanguageInit();
+
+    OSInit();
+
+    mDoMain::sPowerOnTime = DUSK_IF_ELSE(OSGetSystemTime(), OSGetTime());
+
+    // Reset Data
+    static mDoRstData sResetData = {0};
+    mDoRst::setResetData(&sResetData);
+    mDoRst::offReset();
+    mDoRst::setLogoScnFlag(0);
+
+    // Global Context Init
+    dComIfG_ct();
+
+    mDoDvdThd::SyncWidthSound = false;
+
+    // Apply after aurora_initialize: speedrun mode mutates cvars whose change callbacks push
+    // values into aurora.
+    if (dusk::getSettings().game.speedrunMode) {
+        dusk::speedrun::registerSpeedrunGameMode();
+    }
+
+    if (parsed_arg_options.contains("mods") &&
+            !parsed_arg_options["mods"].as<std::string>().empty())
+    {
+        mods_init(parsed_arg_options["mods"].as<std::string>());
+    } else {
+        mods_init(dusk::ConfigPath / "mods");
+    }
+
+    if (!skipPreLaunchUI && showPrelaunchAfterInit) {
+        dusk::ui::push_document(std::make_unique<dusk::ui::Prelaunch>(), true);
+    }
+
+    if (skipPreLaunchUI == true) {
+        if (dusk::gamemode::getGameModeManager().getRegisteredGameModes().size() > 1 && dusk::getSettings().backend.skipPreLaunchUI.getValue()) {
+            // Force pre-launch if we have registered gamemodes that we need to choose from
+            dusk::ui::push_document(std::make_unique<dusk::ui::Prelaunch>(), true);
+        } else {
+            // If we get back to prelaunch later, tell it that we've already started the game
+            dusk::ui::prelaunch_state().firstLaunch = false;
+        }
+    }
+
+#if BOREALIS_HAS_SENTRY
+    if (borealis::sentry::get_consent() == borealis::sentry::Consent::Unknown) {
+        dusk::ui::push_document(std::make_unique<dusk::ui::CrashReportWindow>());
+    }
+#endif
+
+    if (!dusk::getSettings().backend.wasPresetChosen) {
+        dusk::ui::push_document(std::make_unique<dusk::ui::PresetWindow>());
+    }
 
     OSReport("Starting main01 (Game Loop)...\n");
 
     main01();
+    borealis::shutdown();
 
-    dusk::MoviePlayerShutdown();
+    // We need to cleanly shut down the threads to avoid crashes on shutdown.
+    if (daMP_c::m_myObj) {
+        daMP_c::m_myObj->daMP_c_Finish();
+    }
 
-    dusk::crash_reporting::shutdown();
-    dusk::ShutdownFileLogging();
+    borealis::sentry::shutdown();
+    borealis::log::shutdown();
     fflush(stdout);
     fflush(stderr);
 
@@ -858,9 +972,10 @@ int game_main(int argc, char* argv[]) {
     // Notifies all CVs and causes threads to exit
     OSResetSystem(OS_RESET_SHUTDOWN, 0, 0);
 
-#ifdef DUSK_DISCORD
+#if BOREALIS_HAS_DISCORD
     dusk::discord::shutdown();
 #endif
+    dusk::audio::Shutdown();
     dusk::ui::shutdown();
     dusk::texture_replacements::shutdown();
     dusk::config::shutdown();
diff --git a/src/m_Do/m_Do_mtx.cpp b/src/m_Do/m_Do_mtx.cpp
index e0df166e8e..8b57abd3e4 100644
--- a/src/m_Do/m_Do_mtx.cpp
+++ b/src/m_Do/m_Do_mtx.cpp
@@ -12,19 +12,19 @@
 #include "global.h"
 #include "os_report.h"
 
-Mtx mDoMtx_stack_c::now;
+DUSK_GAME_DATA Mtx mDoMtx_stack_c::now;
 
-Mtx mDoMtx_stack_c::buffer[16];
+DUSK_GAME_DATA Mtx mDoMtx_stack_c::buffer[16];
 
-Mtx* mDoMtx_stack_c::next = mDoMtx_stack_c::buffer;
+DUSK_GAME_DATA Mtx* mDoMtx_stack_c::next = mDoMtx_stack_c::buffer;
 
-Mtx* mDoMtx_stack_c::end = mDoMtx_stack_c::buffer + 16;
+DUSK_GAME_DATA Mtx* mDoMtx_stack_c::end = mDoMtx_stack_c::buffer + 16;
 
 static mDoMtx_stack_c mDoMtx_stack;
 
 static mDoMtx_quatStack_c mDoMtx_quatStack;
 
-Mtx g_mDoMtx_identity = {
+DUSK_GAME_DATA Mtx g_mDoMtx_identity = {
     {1.0f, 0.0f, 0.0f, 0.0f},
     {0.0f, 1.0f, 0.0f, 0.0f},
     {0.0f, 0.0f, 1.0f, 0.0f},
diff --git a/src/m_Do/m_Do_printf.cpp b/src/m_Do/m_Do_printf.cpp
index 3cacece77d..9e6e719fff 100644
--- a/src/m_Do/m_Do_printf.cpp
+++ b/src/m_Do/m_Do_printf.cpp
@@ -9,6 +9,7 @@
 #include "m_Do/m_Do_ext.h"
 #if TARGET_PC
 #include <cstdarg>
+#include "dusk/os.h"
 #endif
 
 u8 __OSReport_disable;
@@ -125,7 +126,7 @@ void OSReportInit() {
     }
 }
 
-static u8 mDoPrintf_FiberStack[2048] ATTRIBUTE_ALIGN(32);
+ATTRIBUTE_ALIGN(32) static u8 mDoPrintf_FiberStack[2048];
 
 void mDoPrintf_vprintf_Interrupt(char const* fmt, va_list args) {
     BOOL interruptStatus = OSDisableInterrupts();
diff --git a/tools/mod_template/mod.json b/tools/mod_template/mod.json
deleted file mode 100644
index 46507a87ee..0000000000
--- a/tools/mod_template/mod.json
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-    "id": "com.example.mod",
-    "name": "Template Mod",
-    "version": "1.0.0",
-    "author": "You",
-    "description": "An example Dusklight mod"
-}
diff --git a/version.h.in b/version.h.in
deleted file mode 100644
index 6d94ce406a..0000000000
--- a/version.h.in
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef VERSION_H
-#define VERSION_H
-
-#define DUSK_WC_DESCRIBE "@DUSK_WC_DESCRIBE@"
-#define DUSK_VERSION_STRING "@DUSK_VERSION_STRING@"
-
-#define DUSK_WC_BRANCH "@DUSK_WC_BRANCH@"
-#define DUSK_WC_REVISION "@DUSK_WC_REVISION@"
-#define DUSK_WC_DATE "@DUSK_WC_DATE@"
-#define DUSK_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
-
-#if defined(__x86_64__) || defined(_M_AMD64)
-#define DUSK_ARCH "x86_64"
-#elif defined(__i386__) || defined(_M_IX86)
-#define DUSK_ARCH "x86"
-#elif defined(__aarch64__) || defined(_M_ARM64)
-#define DUSK_ARCH "arm64"
-#endif
-
-#define DUSK_PLATFORM_NAME "@PLATFORM_NAME@"
-#define DUSK_DLPACKAGE "dusklight-@DUSK_WC_DESCRIBE@-" DUSK_PLATFORM_NAME "-" DUSK_ARCH
-
-#define DUSK_SENTRY_DSN "@DUSK_SENTRY_DSN@"
-#define DUSK_SENTRY_ENVIRONMENT "@DUSK_SENTRY_ENVIRONMENT@"
-
-#endif