maybe fix ook crash

docs: Improve building.md file (#1530 )
* docs: Improve building.md file - Fix broken XCode link - Add MacOS running instructions - Alphabetize linux packages * fix: collapse packages sections for readability * fix: collapse packages sections for readability * fix: add --dvd flag to specify iso path * fix: Remove incorrect info about game.iso
2026-07-04 11:19:58 -04:00 · 2026-05-20 14:33:48 -07:00 · 2026-05-17 07:51:38 -06:00 · 2026-05-17 07:51:15 -06:00 · 2026-05-17 07:45:08 -06:00 · 2026-05-17 07:44:29 -06:00
480 changed files with 37368 additions and 5088 deletions
@@ -2,7 +2,7 @@
 Language: Cpp
 Standard: C++03
 AccessModifierOffset: -4
-AlignAfterOpenBracket: Align
+AlignAfterOpenBracket: DontAlign
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
 AlignOperands:   true
@@ -8,7 +8,7 @@ on:
  pull_request:

 env:
-  # SCCACHE_GHA_ENABLED: "true"
+  SCCACHE_GHA_ENABLED: "true"
  RUSTC_WRAPPER: "sccache"
  SENTRY_DSN: ${{ secrets.SENTRY_DSN }}

@@ -22,7 +22,7 @@ jobs:
      matrix:
        include:
          - name: GCC x86_64
-            runner: [self-hosted, Linux]
+            runner: ubuntu-latest
            preset: gcc
            artifact_arch: x86_64
          # - name: GCC aarch64
@@ -41,7 +41,6 @@ jobs:
          submodules: recursive

      - name: Install dependencies
-        if: 'false' # disabled for self-hosted
        run: |
          sudo apt-get update
          sudo apt-get -y install ninja-build clang lld openssl libcurl4-openssl-dev \
@@ -51,8 +50,7 @@ jobs:
            libxss-dev libfuse2 libusb-1.0-0-dev libdecor-0-dev libpipewire-0.3-dev libunwind-dev

      - name: Setup sccache
-        if: 'false' # disabled for self-hosted
-        uses: mozilla-actions/sccache-action@v0.0.9
+        uses: mozilla-actions/sccache-action@v0.0.10

      - name: Print sccache stats
        run: sccache --show-stats
@@ -69,31 +67,34 @@ jobs:
      - name: Upload artifacts
        uses: actions/upload-artifact@v7
        with:
-          name: dusk-${{env.DUSK_VERSION}}-linux-${{matrix.preset}}-${{matrix.artifact_arch}}
+          name: dusklight-${{env.DUSK_VERSION}}-linux-${{matrix.preset}}-${{matrix.artifact_arch}}
          path: |
-            build/install/Dusk-*.AppImage
+            build/install/Dusklight-*.AppImage
            build/install/debug.tar.*

  build-apple:
    name: Build Apple (${{matrix.name}})
-    if: 'false' # TODO enable when CI is free
    runs-on: macos-latest
    strategy:
      fail-fast: false
      matrix:
        include:
-          - name: AppleClang macOS universal
+          - name: AppleClang macOS arm64
            platform: macos
-            preset: x-macos-ci
-            artifact_name: macos-appleclang-universal
+            preset: x-macos-ci-arm64
+            artifact_name: macos-appleclang-arm64
+          - name: AppleClang macOS x86_64
+            platform: macos
+            preset: x-macos-ci-x86_64
+            artifact_name: macos-appleclang-x86_64
          - name: AppleClang iOS arm64
            platform: ios
            preset: x-ios-ci
            artifact_name: ios-appleclang-arm64
-          - name: AppleClang tvOS arm64
-            platform: tvos
-            preset: x-tvos-ci
-            artifact_name: tvos-appleclang-arm64
+          # - name: AppleClang tvOS arm64
+          #   platform: tvos
+          #   preset: x-tvos-ci
+          #   artifact_name: tvos-appleclang-arm64

    steps:
      - uses: actions/checkout@v6
@@ -101,22 +102,14 @@ jobs:
          fetch-depth: 0
          submodules: recursive

-      - name: Update Homebrew
-        if: matrix.platform == 'tvos'
-        run: |
-          brew update
-          brew upgrade --formula
-
      - name: Install dependencies
        run: brew install cmake ninja

-      - name: Install markupsafe
-        if: matrix.platform == 'tvos'
-        run: pip3 install --break-system-packages markupsafe
-
      - name: Install Rust iOS target
        if: matrix.platform == 'ios'
-        run: rustup target add aarch64-apple-ios
+        run: |
+          rustup toolchain install stable
+          rustup target add aarch64-apple-ios

      - name: Install Rust tvOS target
        if: matrix.platform == 'tvos'
@@ -124,8 +117,14 @@ jobs:
          rustup toolchain install nightly
          rustup target add --toolchain nightly aarch64-apple-tvos

+      - name: Install Rust x86_64 macOS target
+        if: endsWith(matrix.preset, 'x86_64')
+        run: |
+          rustup toolchain install stable
+          rustup target add x86_64-apple-darwin
+
      - name: Setup sccache
-        uses: mozilla-actions/sccache-action@v0.0.9
+        uses: mozilla-actions/sccache-action@v0.0.10

      - name: Configure CMake
        run: cmake --preset ${{matrix.preset}}
@@ -136,11 +135,78 @@ jobs:
      - name: Upload artifacts
        uses: actions/upload-artifact@v7
        with:
-          name: dusk-${{env.DUSK_VERSION}}-${{matrix.artifact_name}}
+          name: dusklight-${{env.DUSK_VERSION}}-${{matrix.artifact_name}}
          path: |
-            build/install/Dusk.app
+            build/install/Dusklight.app
            build/install/debug.tar.*

+  build-android:
+    name: Build Android (${{matrix.name}})
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Clang arm64-v8a
+            preset: x-android-ci-arm64
+            abi: arm64-v8a
+            artifact_arch: arm64
+            rust_target: aarch64-linux-android
+
+    env:
+      ANDROID_NDK_VERSION: "29.0.14206865"
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+          submodules: recursive
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get -y install ninja-build
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 17
+
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v4
+
+      - name: Install Android SDK packages
+        run: sdkmanager "platforms;android-36" "build-tools;36.1.0" "ndk;${ANDROID_NDK_VERSION}"
+
+      - name: Install Rust Android target
+        run: |
+          rustup toolchain install stable
+          rustup target add ${{matrix.rust_target}}
+
+      - name: Setup sccache
+        uses: mozilla-actions/sccache-action@v0.0.10
+
+      - name: Configure CMake
+        run: cmake --preset ${{matrix.preset}}
+
+      - 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 APK
+        working-directory: platforms/android
+        run: ./gradlew :app:assembleRelease --rerun-tasks
+
+      - 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
+
  build-windows:
    name: Build Windows (${{matrix.name}})
    runs-on: ${{matrix.runner}}
@@ -150,7 +216,7 @@ jobs:
      matrix:
        include:
          - name: MSVC x86_64
-            runner: [self-hosted, Windows]
+            runner: windows-latest
            preset: msvc
            msvc_arch: amd64
            vcpkg_arch: x64
@@ -187,7 +253,6 @@ jobs:
        uses: mozilla-actions/sccache-action@v0.0.9

      - name: Install dependencies
-        if: 'false' # disabled for self-hosted
        run: |
          choco install ninja
          vcpkg install freetype:${{matrix.vcpkg_arch}}-windows-static zstd:${{matrix.vcpkg_arch}}-windows-static
@@ -201,7 +266,7 @@ jobs:
      - name: Upload artifacts
        uses: actions/upload-artifact@v7
        with:
-          name: dusk-${{env.DUSK_VERSION}}-win32-msvc-${{matrix.artifact_arch}}
+          name: dusklight-${{env.DUSK_VERSION}}-win32-msvc-${{matrix.artifact_arch}}
          path: |
            build/install/*.exe
            build/install/*.dll
@@ -1,6 +1,7 @@
 # IDE folders
 .idea/
 .vs/
+.zed/

 # Caches
 __pycache__
@@ -41,6 +42,10 @@ compile_commands.json
 # MacOS
 .DS_Store

+# direnv / nix
+.direnv/
+.envrc
+
 # ISOs
 *.iso

@@ -2,11 +2,11 @@
    "version": "0.2.0",
    "configurations": [
        {
-            "name": "(gdb) Launch Dusk MSVC",
+            "name": "(gdb) Launch Dusklight MSVC",
            "type": "cppvsdbg",
            "request": "launch",
            "program": "${command:cmake.launchTargetPath}",
-            "args": ["-l", "1", "--dvd", "${workspaceRoot}/orig/GZ2E01/GZ2E01.iso"],
+            "args": ["-l", "1", "--dvd", "${workspaceRoot}/orig/GZ2E01/GZ2E01.iso", "--console"],
            "MIMode": "gdb",
            "miDebuggerPath": "gdb",
            "symbolSearchPath": "${command:cmake.launchTargetPath}",
@@ -1,5 +1,5 @@
 {
-  "cmake.buildDirectory": "${workspaceFolder}/build/dusk/${buildType}/${variant:tp_version}",
+  "cmake.buildDirectory": "${workspaceFolder}/build/dusklight/${buildType}/${variant:tp_version}",
  "cmake.generator": "Ninja",
  "cmake.configureSettings": {
    "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
@@ -5,8 +5,19 @@ if (NOT CMAKE_BUILD_TYPE)
            "Build type options: Debug Release RelWithDebInfo MinSizeRel" FORCE)
 endif ()

-# obtain revision info from git
-find_package(Git)
+set(DUSK_VERSION_OVERRIDE "" CACHE STRING "Override version string (skips git detection and format validation)")
+
+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_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 ${CMAKE_SOURCE_DIR} COMMAND ${GIT_EXECUTABLE} rev-parse --git-path HEAD
@@ -48,26 +59,33 @@ 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]+)(-([0-9]+).*)?$")
+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}")
-    if (CMAKE_MATCH_5)
-        set(DUSK_VERSION_STRING "${DUSK_SHORT_VERSION_STRING}.${CMAKE_MATCH_5}")
-    else ()
-        set(DUSK_VERSION_STRING "${DUSK_SHORT_VERSION_STRING}.0")
+    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}")
 else ()
    set(DUSK_WC_DESCRIBE "UNKNOWN-VERSION")
    set(DUSK_VERSION_STRING "0.0.0.0")
    set(DUSK_SHORT_VERSION_STRING "0.0.0")
 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")
 endif()
-message(STATUS "Dusk version set to ${DUSK_WC_DESCRIBE}")
+message(STATUS "Dusklight version set to ${DUSK_WC_DESCRIBE}")
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
-project(dusk LANGUAGES C CXX VERSION ${DUSK_VERSION_STRING})
+project(dusklight LANGUAGES C CXX VERSION ${DUSK_VERSION_STRING})
+if (APPLE)
+    enable_language(OBJC OBJCXX)
+endif ()
 if (APPLE AND NOT TVOS AND CMAKE_SYSTEM_NAME STREQUAL tvOS)
    # ios.toolchain.cmake hack for SDL
    set(TVOS ON)
@@ -87,37 +105,46 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)

+# Folder-based instead of target-based organization
+# in Visual Studio and Xcode generators
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+set_property(GLOBAL PROPERTY PREDEFINED_TARGETS_FOLDER "_cmake")
+
 if (CMAKE_SYSTEM_NAME STREQUAL Linux)
  set(DAWN_USE_WAYLAND ON CACHE BOOL "Enable support for Wayland surface" FORCE)
 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_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(libs/freeverb)

 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)
-
-if(ANDROID)
-    set(DUSK_MOVIE_SUPPORT OFF)
-    set(NOD_COMPRESS_BZIP2 OFF CACHE BOOL "" FORCE)
-    set(NOD_COMPRESS_LZMA OFF CACHE BOOL "" FORCE)
-    set(NOD_COMPRESS_ZLIB OFF CACHE BOOL "" FORCE)
-    set(NOD_COMPRESS_ZSTD OFF CACHE BOOL "" FORCE)
-endif ()
-
+option(DUSK_ENABLE_UPDATE_CHECKER "Enable update checking support" ON)
 option(DUSK_ENABLE_SENTRY_NATIVE "Enable sentry-native crash reporting support" OFF)
 set(DUSK_SENTRY_DSN "" CACHE STRING "Sentry DSN")
 set(DUSK_SENTRY_ENVIRONMENT "development" CACHE STRING "Sentry environment")

+# Edit & Continue
+if (MSVC)
+    if ("${CMAKE_MSVC_DEBUG_INFORMATION_FORMAT}" STREQUAL "" AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+        set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "EditAndContinue")
+    endif ()
+    if (CMAKE_MSVC_DEBUG_INFORMATION_FORMAT STREQUAL "EditAndContinue")
+        add_link_options("/INCREMENTAL")
+    endif ()
+endif ()
+
 if (DUSK_MOVIE_SUPPORT)
    find_package(libjpeg-turbo 3.0 CONFIG QUIET)
    if (libjpeg-turbo_FOUND)
-        message(STATUS "dusk: Using system libjpeg-turbo")
+        message(STATUS "dusklight: Using system libjpeg-turbo")
    else ()
-        message(STATUS "dusk: Fetching libjpeg-turbo")
+        message(STATUS "dusklight: Fetching libjpeg-turbo")
        include(ExternalProject)
        set(_jpeg_install_dir ${CMAKE_BINARY_DIR}/libjpeg-turbo-install)
        if (WIN32)
@@ -125,19 +152,40 @@ if (DUSK_MOVIE_SUPPORT)
        else ()
            set(_jpeg_lib ${_jpeg_install_dir}/lib/libturbojpeg.a)
        endif ()
+        set(_jpeg_cmake_args
+            -DCMAKE_INSTALL_PREFIX=${_jpeg_install_dir}
+            -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
+            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
-                -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
-                -DCMAKE_INSTALL_PREFIX=${_jpeg_install_dir}
-                -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-                -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-                -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
-                -DCMAKE_MSVC_RUNTIME_LIBRARY=${CMAKE_MSVC_RUNTIME_LIBRARY}
-                -DENABLE_SHARED=OFF
-                -DWITH_TURBOJPEG=ON
-                -DWITH_JAVA=OFF
+            CMAKE_ARGS ${_jpeg_cmake_args}
            BUILD_BYPRODUCTS ${_jpeg_lib}
        )
        file(MAKE_DIRECTORY ${_jpeg_install_dir}/include)
@@ -188,13 +236,13 @@ endif ()
 include(FetchContent)

 # Declare all dependencies first so CMake can download them in parallel
-message(STATUS "dusk: Fetching cxxopts")
+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 TRUE
 )
-message(STATUS "dusk: Fetching nlohmann/json")
+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
@@ -203,7 +251,7 @@ FetchContent_Declare(json
 FetchContent_MakeAvailable(cxxopts json)

 if (DUSK_ENABLE_SENTRY_NATIVE)
-    message(STATUS "dusk: Fetching 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)
@@ -228,6 +276,12 @@ if (DUSK_ENABLE_SENTRY_NATIVE)
    endif ()
 endif ()

+# Use signed char on ARM to match the original game (and x86)
+string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" _arch)
+if(_arch MATCHES "^(arm|aarch64)" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "GNU")
+    add_compile_options(-fsigned-char)
+endif()
+
 if (CMAKE_SYSTEM_NAME STREQUAL Windows)
    set(PLATFORM_NAME win32)
 elseif (CMAKE_SYSTEM_NAME STREQUAL Darwin)
@@ -248,36 +302,32 @@ include(files.cmake)

 # TODO: version handling for res includes

-set(DUSK_BUNDLE_NAME Dusk)
-set(DUSK_BUNDLE_IDENTIFIER dev.decomp.dusk)
+set(DUSK_BUNDLE_NAME Dusklight)
+set(DUSK_BUNDLE_IDENTIFIER dev.twilitrealm.dusk)
 set(DUSK_COMPANY_NAME "Twilit Realm")
-set(DUSK_FILE_DESCRIPTION "Dusk")
-set(DUSK_PRODUCT_NAME "Dusk")
+set(DUSK_FILE_DESCRIPTION "Dusklight")
+set(DUSK_PRODUCT_NAME "Dusklight")
 set(DUSK_COPYRIGHT "Copyright (C) Twilit Realm contributors")
-set(DUSK_GAME_NAME "GZ2E")
-set(DUSK_GAME_VERSION "01")
-set(DUSK_TP_VERSION ${DUSK_GAME_NAME}${DUSK_GAME_VERSION})

-message(STATUS "dusk: Game Version: ${DUSK_TP_VERSION}")
+source_group("dolzel" FILES ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${REL_FILES})
+source_group("dusklight" FILES ${DUSK_FILES} ${DUSK_HTTP_BACKEND_FILES})

-source_group("dolzel" FILES ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${JSYSTEM_FILES} ${JSYSTEM_DEBUG_FILES} ${REL_FILES})
-source_group("dusk" FILES ${DUSK_FILES})
-
-set(GAME_COMPILE_DEFS TARGET_PC WIDESCREEN_SUPPORT=1 AVOID_UB=1 VERSION=0
-    DUSK_TP_VERSION="${DUSK_TP_VERSION}" DUSK_GAME_NAME="${DUSK_GAME_NAME}" DUSK_GAME_VERSION="${DUSK_GAME_VERSION}")
+set(GAME_COMPILE_DEFS TARGET_PC WIDESCREEN_SUPPORT=1 AVOID_UB=1 VERSION=0 MTX_USE_PS=1)

 set(GAME_INCLUDE_DIRS
    include
    src
-    assets/${DUSK_TP_VERSION}
+    assets/GZ2E01 # TODO: make this dynamic if needed?
    libs/JSystem/include
    libs
    extern/aurora/include/dolphin
    extern
    ${CMAKE_BINARY_DIR})

+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)
+    aurora::card freeverb cxxopts::cxxopts absl::flat_hash_map nlohmann_json::nlohmann_json TracyClient fmt::fmt
+    Threads::Threads)

 list(APPEND GAME_LIBS libzstd_static)

@@ -286,6 +336,45 @@ if (DUSK_ENABLE_SENTRY_NATIVE)
    list(APPEND GAME_COMPILE_DEFS DUSK_ENABLE_SENTRY_NATIVE=1 SENTRY_BUILD_STATIC=1)
 endif ()

+if (WIN32)
+    list(APPEND GAME_LIBS Ws2_32)
+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)
@@ -295,14 +384,13 @@ if (DUSK_MOVIE_SUPPORT)
    list(APPEND GAME_COMPILE_DEFS MOVIE_SUPPORT=1)
 endif ()

-# Edit & Continue
-if (MSVC)
-    if (CMAKE_MSVC_DEBUG_INFORMATION_FORMAT STREQUAL "" AND CMAKE_BUILD_TYPE STREQUAL Debug)
-        set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "EditAndContinue")
-    endif ()
-    if (CMAKE_MSVC_DEBUG_INFORMATION_FORMAT STREQUAL "EditAndContinue")
-        add_link_options("/INCREMENTAL")
-    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(ANDROID)
@@ -311,70 +399,96 @@ endif ()

 # game_debug is for game code files that we know work when compiled with DEBUG=1
 # Of course, if building a release build, this distinction is irrelevant
-add_library(game_debug OBJECT ${JSYSTEM_DEBUG_FILES} ${SSYSTEM_FILES}
+set(GAME_DEBUG_FILES
+        ${SSYSTEM_FILES}
        src/dusk/audio/DuskAudioSystem.cpp
        src/dusk/audio/JASCriticalSection.cpp
        src/dusk/audio/DuskDsp.cpp
        src/dusk/audio/Adpcm.cpp
        src/dusk/audio/DspStub.cpp
-        src/dusk/imgui/ImGuiAudio.cpp)
+        src/dusk/imgui/ImGuiAudio.cpp
+)
+set_source_files_properties(
+        ${GAME_DEBUG_FILES}
+        PROPERTIES
+        COMPILE_DEFINITIONS "$<$<CONFIG:Debug>:DEBUG=1>;$<$<CONFIG:Debug>:PARTIAL_DEBUG=1>"
+)

 # game_base is for all other game code files
-add_library(game_base OBJECT ${DOLZEL_FILES} ${Z2AUDIOLIB_FILES} ${JSYSTEM_FILES} ${REL_FILES} ${DUSK_FILES} ${DOLPHIN_FILES})
+set(GAME_BASE_FILES
+        ${DOLZEL_FILES}
+        ${Z2AUDIOLIB_FILES}
+        ${REL_FILES}
+        ${DUSK_FILES}
+        ${DOLPHIN_FILES}
+)
+set_source_files_properties(
+        ${GAME_BASE_FILES}
+        PROPERTIES
+        COMPILE_DEFINITIONS "NDEBUG=1;NDEBUG_DEFINED=1;DEBUG_DEFINED=0;$<$<CONFIG:Debug>:PARTIAL_DEBUG=1>"
+)

-target_compile_definitions(game_debug PRIVATE ${GAME_COMPILE_DEFS} $<$<CONFIG:Debug>:DEBUG=1> $<$<CONFIG:Debug>:PARTIAL_DEBUG=1>)
-target_compile_definitions(game_base PRIVATE ${GAME_COMPILE_DEFS} NDEBUG=1 NDEBUG_DEFINED=1 DEBUG_DEFINED=0 $<$<CONFIG:Debug>:PARTIAL_DEBUG=1>)
+foreach(jsystem_lib IN LISTS JSYSTEM_LIBRARIES)
+    target_compile_definitions(${jsystem_lib} PRIVATE
+            ${GAME_COMPILE_DEFS}
+            $<$<CONFIG:Debug>:DEBUG=1>
+            $<$<CONFIG:Debug>:PARTIAL_DEBUG=1>
+    )
+    target_include_directories(${jsystem_lib} PRIVATE ${GAME_INCLUDE_DIRS})
+    target_link_libraries(${jsystem_lib} PRIVATE ${GAME_LIBS})
+    set_target_properties(${jsystem_lib} PROPERTIES FOLDER "JSystem")
+endforeach()

-# only apply PCH to game_base since not all headers are necessarily validated with DEBUG=1
-target_precompile_headers(game_base PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
-
-target_include_directories(game_debug PRIVATE ${GAME_INCLUDE_DIRS})
-target_include_directories(game_base PRIVATE ${GAME_INCLUDE_DIRS})
-
-# This implicitly pulls in the library include directories even though no
-# linking actually takes place for object libraries
-target_link_libraries(game_debug PRIVATE ${GAME_LIBS})
-target_link_libraries(game_base PRIVATE ${GAME_LIBS})
-
-# Combined game library
-add_library(game STATIC
-    $<TARGET_OBJECTS:game_base>
-    $<TARGET_OBJECTS:game_debug>)
-target_link_libraries(game PUBLIC ${GAME_LIBS})
-
-if(ANDROID)
-    add_library(dusk SHARED src/dusk/main.cpp)
-    set_target_properties(dusk PROPERTIES OUTPUT_NAME main)
-else ()
-    add_executable(dusk src/dusk/main.cpp)
+set(JSYSTEM_LINK_LIBRARIES ${JSYSTEM_LIBRARIES})
+if (CMAKE_CXX_LINK_GROUP_USING_RESCAN_SUPPORTED OR CMAKE_LINK_GROUP_USING_RESCAN_SUPPORTED)
+    # GNU ld resolves static archives in a single left-to-right pass. The split
+    # JSystem libraries reference each other, so they need a RESCAN group there.
+    set(JSYSTEM_LINK_LIBRARIES "$<LINK_GROUP:RESCAN,${JSYSTEM_LIBRARIES}>")
 endif ()

-target_compile_definitions(dusk PRIVATE TARGET_PC AVOID_UB=1 VERSION=0)
-target_include_directories(dusk PRIVATE include)
-target_link_libraries(dusk PRIVATE game aurora::main)
+set(DUSK_FILES src/dusk/main.cpp ${GAME_BASE_FILES} ${GAME_DEBUG_FILES})
+if(ANDROID)
+    add_library(dusklight SHARED ${DUSK_FILES})
+    set_target_properties(dusklight PROPERTIES OUTPUT_NAME main)
+else ()
+    add_executable(dusklight ${DUSK_FILES})
+endif ()
+
+target_compile_definitions(dusklight PRIVATE ${GAME_COMPILE_DEFS})
+target_include_directories(dusklight PRIVATE ${GAME_INCLUDE_DIRS})
+target_link_libraries(dusklight PRIVATE aurora::main ${GAME_LIBS} ${JSYSTEM_LINK_LIBRARIES})
+target_precompile_headers(dusklight PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
 if (TARGET crashpad_handler)
-    add_dependencies(dusk crashpad_handler)
+    add_dependencies(dusklight crashpad_handler)
+    add_custom_command(TARGET dusklight POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "$<TARGET_FILE:crashpad_handler>"
+            "$<TARGET_FILE_DIR:dusklight>"
+        COMMENT "Copying 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(dusk PRIVATE "-Wl,-u,SDL_main")
+    target_link_options(dusklight PRIVATE "-Wl,-u,SDL_main")
 endif ()

-add_custom_command(TARGET dusk POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E copy_directory
-        "${CMAKE_SOURCE_DIR}/res"
-        "$<TARGET_FILE_DIR:dusk>/res"
-    COMMENT "Copying resources"
-)
+if (NOT APPLE)
+    add_custom_command(TARGET dusklight POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_directory
+            "${CMAKE_SOURCE_DIR}/res"
+            "$<TARGET_FILE_DIR:dusklight>/res"
+        COMMENT "Copying resources"
+    )
+endif ()

 if (WIN32)
    set(DUSK_WINDOWS_RESOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/platforms/windows)
    set(DUSK_WINDOWS_ICON_PNG ${CMAKE_CURRENT_SOURCE_DIR}/res/icon.png)
-    set(DUSK_WINDOWS_ICON_ICO ${CMAKE_CURRENT_BINARY_DIR}/dusk.ico)
-    set(DUSK_WINDOWS_RC ${CMAKE_CURRENT_BINARY_DIR}/dusk.rc)
-    set(DUSK_WINDOWS_MANIFEST ${CMAKE_CURRENT_BINARY_DIR}/dusk.manifest)
+    set(DUSK_WINDOWS_ICON_ICO ${CMAKE_CURRENT_BINARY_DIR}/dusklight.ico)
+    set(DUSK_WINDOWS_RC ${CMAKE_CURRENT_BINARY_DIR}/dusklight.rc)
+    set(DUSK_WINDOWS_MANIFEST ${CMAKE_CURRENT_BINARY_DIR}/dusklight.manifest)

    add_custom_command(
            OUTPUT ${DUSK_WINDOWS_ICON_ICO}
@@ -387,62 +501,74 @@ if (WIN32)
            COMMENT "Generating Windows icon"
    )

-    configure_file(${DUSK_WINDOWS_RESOURCE_DIR}/dusk.manifest.in ${DUSK_WINDOWS_MANIFEST} @ONLY)
-    configure_file(${DUSK_WINDOWS_RESOURCE_DIR}/dusk.rc.in ${DUSK_WINDOWS_RC} @ONLY)
+    configure_file(${DUSK_WINDOWS_RESOURCE_DIR}/dusklight.manifest.in ${DUSK_WINDOWS_MANIFEST} @ONLY)
+    configure_file(${DUSK_WINDOWS_RESOURCE_DIR}/dusklight.rc.in ${DUSK_WINDOWS_RC} @ONLY)

-    target_sources(dusk PRIVATE ${DUSK_WINDOWS_ICON_ICO} ${DUSK_WINDOWS_RC})
-    set_target_properties(dusk PROPERTIES WIN32_EXECUTABLE TRUE)
+    target_sources(dusklight PRIVATE ${DUSK_WINDOWS_ICON_ICO} ${DUSK_WINDOWS_RC})
+    set_target_properties(dusklight PROPERTIES WIN32_EXECUTABLE TRUE)

    if (MSVC)
-        target_link_options(dusk PRIVATE /MANIFEST:NO)
+        target_link_options(dusklight PRIVATE /MANIFEST:NO)
    endif ()
 endif ()

 if (APPLE)
    if (IOS)
        set(DUSK_RESOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/platforms/ios)
-        set(DUSK_INFO_PLIST ${DUSK_RESOURCE_DIR}/Info.plist.in)
-        file(GLOB_RECURSE DUSK_RESOURCE_FILES "${DUSK_RESOURCE_DIR}/Base.lproj/*")
-    endif ()
-    if (IOS OR TVOS)
-        target_sources(dusk PRIVATE ${DUSK_RESOURCE_FILES})
-        foreach (FILE ${DUSK_RESOURCE_FILES})
-            file(RELATIVE_PATH NEW_FILE "${DUSK_RESOURCE_DIR}" ${FILE})
-            get_filename_component(NEW_FILE_PATH ${NEW_FILE} DIRECTORY)
-            set_property(SOURCE ${FILE} PROPERTY MACOSX_PACKAGE_LOCATION "Resources/${NEW_FILE_PATH}")
-        endforeach ()
-        set_target_properties(
-            dusk PROPERTIES
-            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}
-            OUTPUT_NAME dusk
-            XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "YES"
-            XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "YES"
-        )
-        if (CMAKE_GENERATOR STREQUAL "Xcode")
-            set_target_properties(dusk PROPERTIES MACOSX_BUNDLE_INFO_PLIST ${DUSK_INFO_PLIST})
-        elseif (DEFINED DUSK_INFO_PLIST)
-            set(MACOSX_BUNDLE_EXECUTABLE_NAME dusk)
-            set(MACOSX_BUNDLE_GUI_IDENTIFIER ${DUSK_BUNDLE_IDENTIFIER})
-            set(MACOSX_BUNDLE_BUNDLE_NAME ${DUSK_BUNDLE_NAME})
-            set(MACOSX_BUNDLE_BUNDLE_VERSION ${DUSK_VERSION_STRING})
-            set(MACOSX_BUNDLE_SHORT_VERSION_STRING ${DUSK_SHORT_VERSION_STRING})
-            set(DUSK_GENERATED_INFO_PLIST ${CMAKE_CURRENT_BINARY_DIR}/dusk.Info.plist)
-            configure_file(${DUSK_INFO_PLIST} ${DUSK_GENERATED_INFO_PLIST})
-            add_custom_command(
-                TARGET dusk POST_BUILD
-                COMMAND ${CMAKE_COMMAND} -E copy_if_different ${DUSK_GENERATED_INFO_PLIST} $<TARGET_FILE_DIR:dusk>/Info.plist
-                VERBATIM
-            )
-        endif ()
+    elseif (TVOS)
+        set(DUSK_RESOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/platforms/tvos)
+    else ()
+        set(DUSK_RESOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/platforms/macos)
    endif ()
+    set(DUSK_INFO_PLIST ${DUSK_RESOURCE_DIR}/Info.plist.in)
+    file(GLOB_RECURSE DUSK_RESOURCE_FILES
+        "${DUSK_RESOURCE_DIR}/Assets.car"
+        "${DUSK_RESOURCE_DIR}/Base.lproj/*"
+        "${DUSK_RESOURCE_DIR}/Dusklight.icns")
+    file(GLOB_RECURSE DUSK_APP_RESOURCE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/res/*")
+    target_sources(dusklight PRIVATE ${DUSK_RESOURCE_FILES})
+    target_sources(dusklight PRIVATE ${DUSK_APP_RESOURCE_FILES})
+    foreach (FILE ${DUSK_RESOURCE_FILES})
+        file(RELATIVE_PATH NEW_FILE "${DUSK_RESOURCE_DIR}" ${FILE})
+        get_filename_component(NEW_FILE_PATH ${NEW_FILE} DIRECTORY)
+        set_property(SOURCE ${FILE} PROPERTY MACOSX_PACKAGE_LOCATION "Resources/${NEW_FILE_PATH}")
+    endforeach ()
+    foreach (FILE ${DUSK_APP_RESOURCE_FILES})
+        file(RELATIVE_PATH NEW_FILE "${CMAKE_CURRENT_SOURCE_DIR}" ${FILE})
+        get_filename_component(NEW_FILE_PATH ${NEW_FILE} DIRECTORY)
+        set_property(SOURCE ${FILE} PROPERTY MACOSX_PACKAGE_LOCATION "Resources/${NEW_FILE_PATH}")
+    endforeach ()
+    set_target_properties(
+        dusklight PROPERTIES
+        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_INFO_PLIST ${DUSK_INFO_PLIST}
+        OUTPUT_NAME Dusklight
+        XCODE_ATTRIBUTE_CODE_SIGNING_ALLOWED "YES"
+        XCODE_ATTRIBUTE_CODE_SIGNING_REQUIRED "YES"
+    )
+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(dusk)
+aurora_copy_runtime_dlls(dusklight)

 if (DUSK_SELECTED_OPT)
    if (CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
@@ -480,14 +606,16 @@ function(get_target_prefix target result_var)
        endif ()
    endif ()
 endfunction()
-list(APPEND BINARY_TARGETS dusk)
+list(APPEND BINARY_TARGETS dusklight)
 set(EXTRA_TARGETS "")
 if (TARGET crashpad_handler)
    list(APPEND EXTRA_TARGETS crashpad_handler)
 endif ()
 install(TARGETS ${BINARY_TARGETS} ${EXTRA_TARGETS} DESTINATION ${CMAKE_INSTALL_PREFIX})
-aurora_install_runtime_dlls(dusk ${CMAKE_INSTALL_PREFIX})
-install(DIRECTORY ${CMAKE_SOURCE_DIR}/res DESTINATION ${CMAKE_INSTALL_PREFIX})
+aurora_install_runtime_dlls(dusklight ${CMAKE_INSTALL_PREFIX})
+if (NOT APPLE)
+    install(DIRECTORY ${CMAKE_SOURCE_DIR}/res DESTINATION ${CMAKE_INSTALL_PREFIX})
+endif ()
 if (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL RelWithDebInfo)
    set(DEBUG_FILES_LIST "")
    foreach (target IN LISTS BINARY_TARGETS EXTRA_TARGETS)
@@ -509,18 +637,22 @@ if (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL RelWithDebInfo)
        endif ()
        list(APPEND DEBUG_FILES_LIST "${output_name}")
    endforeach ()
-    if (WIN32)
-        list(TRANSFORM DEBUG_FILES_LIST APPEND ".pdb")
-        list(JOIN DEBUG_FILES_LIST " " DEBUG_FILES)
-        install(CODE "execute_process(WORKING_DIRECTORY \"${CMAKE_INSTALL_PREFIX}\" COMMAND 7z a -t7z \"${CMAKE_INSTALL_PREFIX}/debug.7z\" ${DEBUG_FILES})")
-    elseif (APPLE)
-        list(TRANSFORM DEBUG_FILES_LIST APPEND ".dSYM")
-        list(JOIN DEBUG_FILES_LIST " " DEBUG_FILES)
-        install(CODE "execute_process(WORKING_DIRECTORY \"${CMAKE_INSTALL_PREFIX}\" COMMAND tar acfv \"${CMAKE_INSTALL_PREFIX}/debug.tar.xz\" ${DEBUG_FILES})")
-    elseif (UNIX)
-        list(TRANSFORM DEBUG_FILES_LIST APPEND ".dbg")
-        list(JOIN DEBUG_FILES_LIST " " DEBUG_FILES)
-        install(CODE "execute_process(WORKING_DIRECTORY \"${CMAKE_INSTALL_PREFIX}\" COMMAND tar -I \"xz -9 -T0\" -cvf \"${CMAKE_INSTALL_PREFIX}/debug.tar.xz\" ${DEBUG_FILES})")
+    # This is a terrible hack to only run this on CI
+    # until I turn this into a script or something
+    if(DEFINED ENV{GITHUB_ENV})
+        if (WIN32)
+            list(TRANSFORM DEBUG_FILES_LIST APPEND ".pdb")
+            list(JOIN DEBUG_FILES_LIST " " DEBUG_FILES)
+            install(CODE "execute_process(WORKING_DIRECTORY \"${CMAKE_INSTALL_PREFIX}\" COMMAND 7z a -t7z \"${CMAKE_INSTALL_PREFIX}/debug.7z\" ${DEBUG_FILES})")
+        elseif (APPLE)
+            list(TRANSFORM DEBUG_FILES_LIST APPEND ".dSYM")
+            list(JOIN DEBUG_FILES_LIST " " DEBUG_FILES)
+            install(CODE "execute_process(WORKING_DIRECTORY \"${CMAKE_INSTALL_PREFIX}\" COMMAND tar acfv \"${CMAKE_INSTALL_PREFIX}/debug.tar.xz\" ${DEBUG_FILES})")
+        elseif (UNIX)
+            list(TRANSFORM DEBUG_FILES_LIST APPEND ".dbg")
+            list(JOIN DEBUG_FILES_LIST " " DEBUG_FILES)
+            install(CODE "execute_process(WORKING_DIRECTORY \"${CMAKE_INSTALL_PREFIX}\" COMMAND tar -I \"xz -9 -T0\" -cvf \"${CMAKE_INSTALL_PREFIX}/debug.tar.xz\" ${DEBUG_FILES})")
+        endif ()
    endif ()
 endif ()
 foreach (target IN LISTS BINARY_TARGETS)
@@ -148,8 +148,7 @@
      "cacheVariables": {
        "CMAKE_C_COMPILER": "cl",
        "CMAKE_CXX_COMPILER": "cl",
-        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
-        "AURORA_DAWN_PROVIDER": "vendor"
+        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install"
      },
      "vendor": {
        "microsoft.com/VisualStudioSettings/CMake/1.0": {
@@ -250,22 +249,11 @@
          "type": "BOOL",
          "value": false
        },
-        "CMAKE_DISABLE_FIND_PACKAGE_BZip2": {
+        "CMAKE_DISABLE_FIND_PACKAGE_PkgConfig": {
          "type": "BOOL",
          "value": true
        },
-        "CMAKE_DISABLE_FIND_PACKAGE_LibLZMA": {
-          "type": "BOOL",
-          "value": true
-        },
-        "CMAKE_DISABLE_FIND_PACKAGE_zstd": {
-          "type": "BOOL",
-          "value": true
-        },
-        "CMAKE_DISABLE_FIND_PACKAGE_Freetype": {
-          "type": "BOOL",
-          "value": true
-        }
+        "CMAKE_IGNORE_PREFIX_PATH": "/opt/homebrew"
      },
      "vendor": {
        "microsoft.com/VisualStudioSettings/CMake/1.0": {
@@ -330,7 +318,11 @@
      "cacheVariables": {
        "CMAKE_INSTALL_PREFIX": "${sourceDir}/build/install",
        "CMAKE_TOOLCHAIN_FILE": "$env{ANDROID_HOME}/ndk/$env{ANDROID_NDK_VERSION}/build/cmake/android.toolchain.cmake",
-        "ANDROID_PLATFORM": "android-28"
+        "ANDROID_PLATFORM": "android-28",
+        "BUILD_SHARED_LIBS": {
+          "type": "BOOL",
+          "value": false
+        }
      }
    },
    {
@@ -353,13 +345,41 @@
        "ANDROID_ABI": "x86_64"
      }
    },
+    {
+      "name": "x-android-ci",
+      "hidden": true,
+      "inherits": [
+        "android-base",
+        "ci"
+      ],
+      "cacheVariables": {
+        "DUSK_ENABLE_SENTRY_NATIVE": {
+          "type": "BOOL",
+          "value": false
+        }
+      }
+    },
+    {
+      "name": "x-android-ci-arm64",
+      "binaryDir": "${sourceDir}/build/android-arm64",
+      "inherits": [
+        "x-android-ci"
+      ],
+      "cacheVariables": {
+        "ANDROID_ABI": "arm64-v8a",
+        "Rust_CARGO_TARGET": "aarch64-linux-android"
+      }
+    },
    {
      "name": "x-linux-ci",
      "hidden": true,
      "inherits": [
        "relwithdebinfo",
        "ci"
-      ]
+      ],
+      "cacheVariables": {
+        "AURORA_SDL3_PROVIDER": "vendor"
+      }
    },
    {
      "name": "x-linux-ci-gcc",
@@ -380,7 +400,40 @@
      "inherits": [
        "macos-default-relwithdebinfo",
        "ci"
-      ]
+      ],
+      "cacheVariables": {
+        "AURORA_NOD_PROVIDER": "vendor",
+        "CMAKE_DISABLE_FIND_PACKAGE_PkgConfig": {
+          "type": "BOOL",
+          "value": true
+        },
+        "CMAKE_OSX_DEPLOYMENT_TARGET": "11.0",
+        "CMAKE_IGNORE_PREFIX_PATH": "/opt/homebrew",
+        "BUILD_SHARED_LIBS": {
+          "type": "BOOL",
+          "value": false
+        }
+      }
+    },
+    {
+      "name": "x-macos-ci-arm64",
+      "inherits": [
+        "x-macos-ci"
+      ],
+      "cacheVariables": {
+        "CMAKE_OSX_ARCHITECTURES": "arm64"
+      }
+    },
+    {
+      "name": "x-macos-ci-x86_64",
+      "inherits": [
+        "x-macos-ci"
+      ],
+      "cacheVariables": {
+        "AURORA_DAWN_PROVIDER": "vendor",
+        "CMAKE_OSX_ARCHITECTURES": "x86_64",
+        "Rust_CARGO_TARGET": "x86_64-apple-darwin"
+      }
    },
    {
      "name": "x-ios-ci",
@@ -483,7 +536,7 @@
      "description": "iOS release build with debug info",
      "displayName": "iOS RelWithDebInfo",
      "targets": [
-        "dusk"
+        "dusklight"
      ]
    },
    {
@@ -492,7 +545,7 @@
      "description": "tvOS release build with debug info",
      "displayName": "tvOS RelWithDebInfo",
      "targets": [
-        "dusk"
+        "dusklight"
      ]
    },
    {
@@ -501,7 +554,7 @@
      "description": "Android arm64-v8a release build with debug info",
      "displayName": "Android arm64-v8a RelWithDebInfo",
      "targets": [
-        "dusk"
+        "dusklight"
      ]
    },
    {
@@ -510,7 +563,16 @@
      "description": "Android x86_64 release build with debug info",
      "displayName": "Android x86_64 RelWithDebInfo",
      "targets": [
-        "dusk"
+        "dusklight"
+      ]
+    },
+    {
+      "name": "x-android-ci-arm64",
+      "configurePreset": "x-android-ci-arm64",
+      "description": "(Internal) Android CI arm64-v8a",
+      "displayName": "(Internal) Android CI arm64-v8a",
+      "targets": [
+        "dusklight"
      ]
    },
    {
@@ -556,10 +618,19 @@
      ]
    },
    {
-      "name": "x-macos-ci",
-      "configurePreset": "x-macos-ci",
-      "description": "(Internal) macOS CI",
-      "displayName": "(Internal) macOS CI",
+      "name": "x-macos-ci-arm64",
+      "configurePreset": "x-macos-ci-arm64",
+      "description": "(Internal) macOS CI arm64",
+      "displayName": "(Internal) macOS CI arm64",
+      "targets": [
+        "install"
+      ]
+    },
+    {
+      "name": "x-macos-ci-x86_64",
+      "configurePreset": "x-macos-ci-x86_64",
+      "description": "(Internal) macOS CI x86_64",
+      "displayName": "(Internal) macOS CI x86_64",
      "targets": [
        "install"
      ]
@@ -567,8 +638,8 @@
    {
      "name": "x-ios-ci",
      "configurePreset": "x-ios-ci",
-      "description": "(Internal) iOS CI",
-      "displayName": "(Internal) iOS CI",
+      "description": "(Internal) iOS CI arm64",
+      "displayName": "(Internal) iOS CI arm64",
      "targets": [
        "install"
      ]
@@ -576,8 +647,8 @@
    {
      "name": "x-tvos-ci",
      "configurePreset": "x-tvos-ci",
-      "description": "(Internal) tvOS CI",
-      "displayName": "(Internal) tvOS CI",
+      "description": "(Internal) tvOS CI arm64",
+      "displayName": "(Internal) tvOS CI arm64",
      "targets": [
        "install"
      ]
@@ -1,103 +1,69 @@
-## Dusk
+<div align="center">
+  <img src="res/logo.png" alt="Logo" width="640">

-### Building
-#### Prerequisites
-* [CMake 3.25+](https://cmake.org)
-    * Windows: Install `CMake Tools` in Visual Studio
-    * macOS: `brew install cmake`
-* [Python 3+](https://python.org)
-    * Windows: [Microsoft Store](https://go.microsoft.com/fwlink?linkID=2082640)
-        * Verify it's added to `%PATH%` by typing `python` in `cmd`.
-    * macOS: `brew install python@3`
-* **[Windows]** [Visual Studio 2026 Community](https://www.visualstudio.com/en-us/products/visual-studio-community-vs.aspx)
-    * Select `C++ Development` and verify the following packages are included:
-        * `Windows 11 SDK`
-        * `CMake Tools`
-        * `C++ Clang Compiler`
-        * `C++ Clang-cl`
-* **[macOS]** [Xcode 16.4+](https://developer.apple.com/xcode/download/)
-* **[Linux]** Actively tested on Ubuntu 24.04, Arch Linux & derivatives.
-    * Ubuntu 24.04+ packages
-      ```
-      build-essential curl git ninja-build clang lld zlib1g-dev libcurl4-openssl-dev \
-      libglu1-mesa-dev libdbus-1-dev libvulkan-dev libxi-dev libxrandr-dev libasound2-dev libpulse-dev \
-      libudev-dev libpng-dev libncurses5-dev cmake libx11-xcb-dev python3 python-is-python3 \
-      libclang-dev libfreetype-dev libxinerama-dev libxcursor-dev python3-markupsafe libgtk-3-dev \
-      libxss-dev libxtst-dev
-      ```
-     * Arch Linux packages
-       ```
-       base-devel cmake ninja llvm vulkan-headers python python-markupsafe clang lld alsa-lib libpulse libxrandr freetype2
-       ```
-     * Fedora packages
-       ```
-       cmake vulkan-headers ninja-build clang-devel llvm-devel libpng-devel
-       ```
-         * It's also important that you install the developer tools and libraries
-           ```
-           sudo dnf groupinstall "Development Tools" "Development Libraries"
-           ```
-#### Setup
-Clone and initialize the Dusk repository
-```sh
-git clone --recursive https://github.com/TwilitRealm/dusk.git
-cd dusk
-git pull
-git submodule update --init --recursive
-```
+  <p align="center">
+    <a href="https://twilitrealm.dev">Official Website</a>
+    •
+    <a href="https://discord.gg/6NpMhefCK9">Discord</a>
+  </p>
+</div>

-#### Building
+# Overview

-**CLion (Windows / macOS / Linux)**
+Dusklight is a reverse-engineered reimplementation of Twilight Princess.

-Open the project directory in CLion. Enable the appropriate presets for your platform:
+It aims to be as accurate as possible to the original while also providing new options, enhancements, and tools to customize your experience.

-![CLion](assets/clion.png)
+# Setup

-**Visual Studio (Windows)**
+> [!IMPORTANT]
+> Dusklight does *not* provide any copyrighted assets. You must provide your own copy of the original game.

-Open the project directory in Visual Studio. The CMake configuration will be loaded automatically.
+> [!IMPORTANT]
+> At a minimum, Dusklight requires a GPU with support for either D3D12, Vulkan, or Metal. Your experience with specific hardware, operating systems, and drivers may vary. In particular, older Intel iGPUs have a high likelihood of incompatibility. We are also aware of a number of issues on devices with Adreno GPUs and are working to resolve them.

-**ninja (macOS)**
+### 1. Verify your dump

-```sh
-cmake --preset macos-default-relwithdebinfo
-cmake --build --preset macos-default-relwithdebinfo
-```
+First, make sure your dump of the game is clean and supported by Dusklight. You can do this by checking the SHA-1 hash of your dump against this list of supported versions:

-Alternate presets available:
- `macos-default-debug`: Clang, Debug
+| Version      | SHA-1 hash                                 |
+|--------------| ------------------------------------------ |
+| GameCube USA | `75edd3ddff41f125d1b4ce1a40378f1b565519e7` |
+| GameCube EUR | `2601822a488eeb86fb89db16ca8f29c2c953e1ca` |

-**ninja (Linux)**
+*Support for other versions of the game is planned in the future.

-```sh
-cmake --preset linux-default-relwithdebinfo
-cmake --build --preset linux-default-relwithdebinfo
-```
+### 2. Download [Dusklight](https://github.com/TwilitRealm/dusklight/releases)

-Alternate presets available:
- `linux-default-debug`: GCC, Debug
- `linux-clang-relwithdebinfo`: Clang, RelWithDebInfo
- `linux-clang-debug`: Clang, Debug
+### 3. Setup the game
+**Windows / macOS / Linux**
+- Extract the .zip file
+- Launch Dusklight
+- Press **Select Disc Image** and provide the path to your supported game dump
+- Press **Play**!

-**ninja (Windows)**
+**iOS**
+- Follow the [iOS setup guide](docs/ios-install-altstore.md)

-```sh
-cmake --preset windows-msvc-relwithdebinfo
-cmake --build --preset windows-msvc-relwithdebinfo
-```
+**Android**
+- Install the Dusklight APK
+- Launch Dusklight
+- Press **Select Disc Image** and provide the path to your supported game dump
+- Press **Play**!

-Alternate presets available:
- `windows-msvc-debug`: MSVC, Debug
- `windows-clang-relwithdebinfo`: Clang-cl, RelWithDebInfo
- `windows-clang-debug`: Clang-cl, Debug
+# Building

-#### Running
-Pass the disc image as a positional argument. Supported formats: ISO (GCM), RVZ, WIA, WBFS, CISO, GCZ
-```sh
-build/{preset}/dusk /path/to/game.rvz
-```
-If no path is specified, Dusk defaults to `game.iso` in the current working directory.
+If you'd like to build Dusklight from source, please read the [build instructions](docs/building.md).

-#### 30 FPS on Debug
-When compiled fully in a Debug the game runs too slowly to hit playable 30 FPS. To avoid this, you can set a CMake cache variable to optimize specific critical files without hampering debuggability in the rest of the program: `-DDUSK_SELECTED_OPT=ON`. When building for MSVC (Windows) you must also modify `CMAKE_CXX_FLAGS_DEBUG` and `CMAKE_C_FLAGS_DEBUG` to remove `/RTC1` from the flags, like so: `-DCMAKE_CXX_FLAGS_DEBUG="/MDd /Zi /Ob0 /Od" -DCMAKE_C_FLAGS_DEBUG="/MDd /Zi /Ob0 /Od"`
+Pull requests are welcomed! Note that we do not accept contributions that are primarily AI-generated and will close your PR if we suspect as much. Please also see the [code conventions](docs/code-conventions.md).
+
+# Credits
+
+Special thanks to the [TP decompilation](https://github.com/zeldaret/tp) team, the GC/Wii decompilation community, the [Aurora](https://github.com/encounter/aurora) developers, the [TP speedrunning community](https://zsrtp.link), and all [contributors](https://github.com/TwilitRealm/dusklight/graphs/contributors).
+
+<br/>
+<div align="center">
+    <a href="https://github.com/encounter/aurora">
+        <img src="assets/aurora-powered.png" alt="Powered by Aurora" width="800">
+    </a>
+</div>
@@ -0,0 +1,66 @@
+<svg width="600" height="600" viewBox="0 0 300 300" xmlns="http://www.w3.org/2000/svg">
+  <circle cx="150" cy="150" r="105" fill="none" stroke="white" stroke-width="4"/>
+  <circle cx="150" cy="150" r="95" fill="none" stroke="white" stroke-width="4"/>
+  <circle cx="150" cy="150" r="60" fill="none" stroke="white" stroke-width="4"/>
+  <circle cx="150" cy="150" r="75" fill="none" stroke="white" stroke-width="4"/>
+
+  <defs>
+    <line id="ray" x1="150" y1="55" x2="150" y2="45"/>
+    <clipPath id="zigzag-clip">
+      <circle cx="150" cy="150" r="75"/>
+    </clipPath>
+  </defs>
+
+  <g stroke="white" stroke-width="3">
+    <use href="#ray"/>
+    <use href="#ray" transform="rotate(18 150 150)"/>
+    <use href="#ray" transform="rotate(36 150 150)"/>
+    <use href="#ray" transform="rotate(54 150 150)"/>
+    <use href="#ray" transform="rotate(72 150 150)"/>
+    <use href="#ray" transform="rotate(90 150 150)"/>
+    <use href="#ray" transform="rotate(108 150 150)"/>
+    <use href="#ray" transform="rotate(126 150 150)"/>
+    <use href="#ray" transform="rotate(144 150 150)"/>
+    <use href="#ray" transform="rotate(162 150 150)"/>
+    <use href="#ray" transform="rotate(180 150 150)"/>
+    <use href="#ray" transform="rotate(198 150 150)"/>
+    <use href="#ray" transform="rotate(216 150 150)"/>
+    <use href="#ray" transform="rotate(234 150 150)"/>
+    <use href="#ray" transform="rotate(252 150 150)"/>
+    <use href="#ray" transform="rotate(270 150 150)"/>
+    <use href="#ray" transform="rotate(288 150 150)"/>
+    <use href="#ray" transform="rotate(306 150 150)"/>
+    <use href="#ray" transform="rotate(324 150 150)"/>
+    <use href="#ray" transform="rotate(342 150 150)"/>
+  </g>
+
+  <polygon fill="none" stroke="white" stroke-width="4" opacity="1" clip-path="url(#zigzag-clip)"
+    points="
+      126.82,78.67
+      150,90
+      173.18,78.67
+      185.27,101.46
+      210.68,105.92
+      207.06,131.46
+      225,150
+      207.06,168.54
+      210.68,194.08
+      185.27,198.54
+      173.18,221.33
+      150,210
+      126.82,221.33
+      114.73,198.54
+      89.32,194.08
+      92.94,168.54
+      75,150
+      92.94,131.46
+      89.32,105.92
+      114.73,101.46
+    "/>
+
+  <g fill="none" stroke="white" stroke-width="4">
+    <polygon points="150,105 130,140 170,140"/>
+    <polygon points="130,140 110,175 150,175"/>
+    <polygon points="170,140 150,175 190,175"/>
+  </g>
+</svg>
@@ -1,18 +1,26 @@
 #!/bin/bash -ex
-shopt -s extglob
+
+if [[ -n "${GITHUB_WORKSPACE:-}" ]]; then
+  cd "$GITHUB_WORKSPACE"
+fi
+
+build_dir="$PWD/build"
+linuxdeploy="$build_dir/linuxdeploy-$(uname -m).AppImage"

 # Get linuxdeploy
-cd "$RUNNER_WORKSPACE"
-curl -fOL https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-$(uname -m).AppImage
-chmod +x linuxdeploy-$(uname -m).AppImage
+mkdir -p "$build_dir"
+curl -fL "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-$(uname -m).AppImage" -o "$linuxdeploy"
+chmod +x "$linuxdeploy"

 # Build AppImage
-cd "$GITHUB_WORKSPACE"
 mkdir -p build/appdir/usr/{bin,share/{applications,icons/hicolor}}
-cp -r build/install/!(*.*) build/appdir/usr/bin
+for install_path in build/install/*; do
+  [[ "$(basename "$install_path")" == *.* ]] && continue
+  cp -r "$install_path" build/appdir/usr/bin
+done
 cp -r platforms/freedesktop/{16x16,32x32,48x48,64x64,128x128,256x256,512x512,1024x1024} build/appdir/usr/share/icons/hicolor
-cp platforms/freedesktop/dusk.desktop build/appdir/usr/share/applications
+cp platforms/freedesktop/dusklight.desktop build/appdir/usr/share/applications

 cd build/install
-VERSION="$DUSK_VERSION" NO_STRIP=1 "$RUNNER_WORKSPACE"/linuxdeploy-$(uname -m).AppImage \
-  -l /usr/lib/x86_64-linux-gnu/libusb-1.0.so --appdir "$GITHUB_WORKSPACE"/build/appdir --output appimage
+VERSION="$DUSK_VERSION" NO_STRIP=1 "$linuxdeploy" \
+  -l /usr/lib/x86_64-linux-gnu/libusb-1.0.so --appdir "$build_dir/appdir" --output appimage
@@ -13,13 +13,3 @@ buildType:
      short: RelWithDebInfo
      long: Optimized, with debug symbols
      buildType: RelWithDebInfo
-
-tp_version:
-  default: GZ2E01
-  description: TP Version
-  choices:
-    GZ2E01:
-      short: GZ2E01
-      long: GZ2E01
-      settings:
-        DUSK_TP_VERSION: GZ2E01
@@ -0,0 +1,228 @@
+# Building Dusklight
+
+## Dependencies
+
+The following dependencies are required:
+
+* [CMake 3.25+](https://cmake.org)
+* [Python 3+](https://python.org)
+
+### Windows
+
+* Install [CMake 3.25+](https://cmake.org) by searching `CMake Tools` in Visual Studio
+* Install Python 3 from the [Microsoft Store](https://go.microsoft.com/fwlink?linkID=2082640) and verify it's added to `%PATH%` by typing `python` in `cmd`.
+
+Recommended IDEs:
+
+* [Visual Studio 2026 Community](https://www.visualstudio.com/en-us/products/visual-studio-community-vs.aspx). During installation:
+  * Select `C++ Development` and verify the following packages are included:
+    * `Windows 11 SDK`
+    * `CMake Tools`
+    * `C++ Clang Compiler`
+    * `C++ Clang-cl`
+
+### macOS
+
+* Make sure [Homebrew](https://brew.sh) is installed
+* Install [CMake 3.25+](https://cmake.org)
+
+```sh
+brew install cmake
+```
+
+* Install Python 3
+
+```sh
+brew install python@3
+```
+
+Recommended IDEs:
+
+* [Xcode 16.4 or later](https://developer.apple.com/xcode/)
+* [Visual Studio Code](https://code.visualstudio.com/download/)
+* [CLion](https://www.jetbrains.com/clion/)
+
+### Linux
+
+Actively tested on Ubuntu 24.04, Arch Linux & derivatives.
+
+**Ubuntu 24.04+ packages**
+
+<details>
+<summary>Click to expand</summary>
+
+* Run the following command to install the required dependencies:
+
+```sh
+sudo apt update && sudo apt install -y \
+    build-essential \
+    clang \
+    cmake \
+    curl \
+    git \
+    libasound2-dev \
+    libclang-dev \
+    libcurl4-openssl-dev \
+    libdbus-1-dev \
+    libfreetype-dev \
+    libglu1-mesa-dev \
+    libgtk-3-dev \
+    libncurses5-dev \
+    libpng-dev \
+    libpulse-dev \
+    libudev-dev \
+    libvulkan-dev \
+    libx11-xcb-dev \
+    libxcursor-dev \
+    libxi-dev \
+    libxinerama-dev \
+    libxrandr-dev \
+    libxss-dev \
+    libxtst-dev \
+    lld \
+    ninja-build \
+    python-is-python3 \
+    python3 \
+    python3-markupsafe \
+    zlib1g-dev
+```
+
+</details>
+<br>
+
+**Arch Linux packages**
+
+<details>
+<summary>Click to expand</summary>
+
+* Run the following command to install the required dependencies:
+
+```sh
+sudo pacman -S --needed \
+    alsa-lib \
+    base-devel \
+    clang \
+    cmake \
+    freetype2 \
+    libpulse \
+    libxrandr \
+    lld \
+    llvm \
+    ninja \
+    python \
+    python-markupsafe \
+    vulkan-headers
+```
+
+</details>
+<br>
+
+**Fedora packages**
+
+<details>
+<summary>Click to expand</summary>
+
+* Run the following command to install the required dependencies:
+
+```sh
+sudo dnf install -y \
+    clang-devel \
+    cmake \
+    libpng-devel \
+    llvm-devel \
+    ninja-build \
+    vulkan-headers
+```
+
+* It's also important that you install the developer tools and libraries
+
+```sh
+sudo dnf groupinstall \
+    "Development Libraries" "Development Tools"
+```
+
+</details>
+<br>
+
+Recommended IDEs:
+
+* [CLion](https://www.jetbrains.com/clion/)
+* [Visual Studio Code](https://code.visualstudio.com/download/)
+
+## Building
+
+* Clone and initialize the Dusklight repository:
+
+```sh
+git clone --recursive https://github.com/TwilitRealm/dusklight.git
+git pull
+cd dusklight
+git submodule update --init --recursive
+```
+
+**CLion (Windows / macOS / Linux)**
+
+Open the project directory in CLion. Enable the appropriate presets for your platform:
+
+![CLion](../assets/clion.png)
+
+**Visual Studio (Windows)**
+
+Open the project directory in Visual Studio. The CMake configuration will be loaded automatically.
+
+**ninja (macOS)**
+
+```sh
+cmake --preset macos-default-relwithdebinfo
+cmake --build --preset macos-default-relwithdebinfo
+```
+
+Alternate presets available:
+
+* `macos-default-debug`: Clang, Debug
+
+**ninja (Linux)**
+
+```sh
+cmake --preset linux-default-relwithdebinfo
+cmake --build --preset linux-default-relwithdebinfo
+```
+
+Alternate presets available:
+
+* `linux-default-debug`: GCC, Debug
+* `linux-clang-relwithdebinfo`: Clang, RelWithDebInfo
+* `linux-clang-debug`: Clang, Debug
+
+**ninja (Windows)**
+
+```sh
+cmake --preset windows-msvc-relwithdebinfo
+cmake --build --preset windows-msvc-relwithdebinfo
+```
+
+Alternate presets available:
+
+* `windows-msvc-debug`: MSVC, Debug
+* `windows-clang-relwithdebinfo`: Clang-cl, RelWithDebInfo
+* `windows-clang-debug`: Clang-cl, Debug
+
+## Running
+
+**Windows / Linux**
+
+* Pass the disc image as a positional argument using the `--dvd` flag. Supported formats are: ISO (GCM), RVZ, WIA, WBFS, CISO, GCZ
+
+```sh
+build/{preset}/dusklight --dvd /path/to/game.iso
+```
+
+**macOS**
+
+macOS builds an `.app` bundle which contains the executable and all necessary resources.
+
+* Pass the disc image as a positional argument using the `--dvd` flag. Supported formats are: ISO (GCM), RVZ, WIA, WBFS, CISO, GCZ
+
+```sh
+build/{preset}/Dusklight.app/Contents/MacOS/Dusklight --dvd /path/to/game.iso
+```
@@ -0,0 +1,13 @@
+# Code conventions for Dusk
+
+## Upstream when appropriate
+
+Bug fixes, documentation improvements, code cleanup, etc that also apply to the [original decompilation project](https://github.com/zeldaret/tp) should preferably be PR'd there.
+
+## Properly indicate Dusk-modified code
+
+When modifying original game code (i.e. in decomp) for Dusk's purposes, please clearly delineate such code as being Dusk-specific. Generally, this can be done by using `#if TARGET_PC` and keeping the original code in place. Use `#if AVOID_UB` for Undefined Behavior fixes to the original codebase.
+
+## Miscellaneous things
+
+* The original codebase makes heavy use of global `operator new` and similar overloads to allocate into a strict tree of heaps. This would cause many linkage headaches for us, so effectively all uses of `new` or `delete` in the original game code have been replaced with `JKR_NEW`, `JKR_DELETE`, or similar macros. See `JKRHeap.h` for the full list.  
@@ -0,0 +1,48 @@
+# Installing Dusklight on iOS via iloader
+
+## Prerequisites
+
+- 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/dusk/releases))
+- Game disc - `GZ2E01` (Gamecube USA) or `GZ2PE01` (Gamecube PAL)
+
+## 1. Install AltServer
+
+- Executable bundles can be installed from [iloader's main page](https://iloader.app/) or [their GitHub](https://github.com/nab138/iloader) for Windows, Linux, and macOS.
+- Windows WILL require iTunes to be installed
+- Linux WILL require usbmuxd to be installed, this is installed by default in most distros though
+
+## 2. Enable Developer Mode (iOS 16+)
+
+- On your iPhone, go to **Settings > Privacy & Security > Developer Mode**
+- Toggle it on and restart when prompted
+
+## 3. Install Dusklight on Your iPhone
+
+1. Sign into your Apple ID (this is required for registering app IDs, it is sent securely and not stored by iloader)
+    * You may be prompted to put in a code from your iOS device, do so
+2. Plug in your iOS device via USB into your PC. If you're missing a dependency, an error pop-up will tell you to install it
+    * You will need to hit `Refresh` after plugging it in at this stage so that it can be detected, it does not automatically refresh
+3. Leave settings unchanged (the Anisette server should stay Sidestore (.io))
+    3.(a) Installing SideStore directly is not required, but provides you a way to install Dusklight on your phone without being plugged into a computer later
+4. Press `Import IPA` and choose your downloaded `Dusk-v.X.X.X-ios-arm64.ipa`, it will begin installing on your device
+
+**NOTE:** *At various stages, you may be prompted to trust your device, do so*
+
+## 3. Getting Dusk trusted
+When installing sideloaded iOS applications, at first you will need to manually trust the app due to Apple's security policies
+* Go to **Settings > General > VPN & Device Management**
+* Tap the Apple ID you signed into iloader with under "Developer App" and tap **Trust**
+* Tap **Allow** on the pop-up
+
+## 4. Copy Files to Your iPhone
+
+Transfer the IPA and game disc to your iPhone so they're accessible in the Files app. A few ways to do this:
+
+- **AirDrop** - Right-click the files on your Mac and choose Share > AirDrop
+- **iCloud Drive** - Place files in iCloud Drive on your Mac and they'll sync to Files on your iPhone
+- **USB transfer** - Connect your iPhone and drag files via Finder's sidebar
+- **Cloud storage** - Upload to Google Drive, Dropbox, etc. and download on your iPhone
+
+You may now use Dusklight on iOS, iPadOS!
@@ -1,7 +1,7 @@

 set(DOLZEL_FILES
        src/m_Do/m_Do_main.cpp
-        src/m_Do/m_Do_printf.cpp
+        #src/m_Do/m_Do_printf.cpp
        src/m_Do/m_Do_audio.cpp
        src/m_Do/m_Do_controller_pad.cpp
        #src/m_Do/m_Re_controller_pad.cpp
@@ -15,7 +15,6 @@ set(DOLZEL_FILES
        src/m_Do/m_Do_DVDError.cpp
        src/m_Do/m_Do_MemCard.cpp
        src/m_Do/m_Do_MemCardRWmng.cpp
-        src/m_Do/m_Do_machine_exception.cpp
        src/m_Do/m_Do_hostIO.cpp
        src/c/c_damagereaction.cpp
        src/c/c_dylink.cpp
@@ -315,7 +314,7 @@ set(SSYSTEM_FILES
        src/SSystem/SStandard/s_basic.cpp
 )

-set(JSYSTEM_DEBUG_FILES
+add_library(JSystem_JParticle STATIC
        libs/JSystem/src/JParticle/JPAResourceManager.cpp
        libs/JSystem/src/JParticle/JPAResource.cpp
        libs/JSystem/src/JParticle/JPABaseShape.cpp
@@ -331,10 +330,19 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JParticle/JPAEmitter.cpp
        libs/JSystem/src/JParticle/JPAParticle.cpp
        libs/JSystem/src/JParticle/JPAMath.cpp
+)
+
+add_library(JSystem_JFramework STATIC
        libs/JSystem/src/JFramework/JFWSystem.cpp
        libs/JSystem/src/JFramework/JFWDisplay.cpp
+)
+
+add_library(JSystem_J3DU STATIC
        libs/JSystem/src/J3DU/J3DUClipper.cpp
        libs/JSystem/src/J3DU/J3DUDL.cpp
+)
+
+add_library(JSystem_JKernel STATIC
        libs/JSystem/src/JKernel/JKRHeap.cpp
        libs/JSystem/src/JKernel/JKRExpHeap.cpp
        libs/JSystem/src/JKernel/JKRSolidHeap.cpp
@@ -360,14 +368,23 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JKernel/JKRDvdRipper.cpp
        libs/JSystem/src/JKernel/JKRDvdAramRipper.cpp
        libs/JSystem/src/JKernel/JKRDecomp.cpp
+)
+
+add_library(JSystem_JMath STATIC
        libs/JSystem/src/JMath/JMath.cpp
        libs/JSystem/src/JMath/random.cpp
        libs/JSystem/src/JMath/JMATrigonometric.cpp
+)
+
+add_library(JSystem_JSupport STATIC
        libs/JSystem/src/JSupport/JSUList.cpp
        libs/JSystem/src/JSupport/JSUInputStream.cpp
        libs/JSystem/src/JSupport/JSUOutputStream.cpp
        libs/JSystem/src/JSupport/JSUMemoryStream.cpp
        libs/JSystem/src/JSupport/JSUFileStream.cpp
+)
+
+add_library(JSystem_JUtility STATIC
        libs/JSystem/src/JUtility/JUTCacheFont.cpp
        libs/JSystem/src/JUtility/JUTResource.cpp
        libs/JSystem/src/JUtility/JUTTexture.cpp
@@ -388,6 +405,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JUtility/JUTConsole.cpp
        libs/JSystem/src/JUtility/JUTDirectFile.cpp
        libs/JSystem/src/JUtility/JUTFontData_Ascfont_fix12.cpp
+)
+
+add_library(JSystem_JStage STATIC
        libs/JSystem/src/JStage/JSGActor.cpp
        libs/JSystem/src/JStage/JSGAmbientLight.cpp
        libs/JSystem/src/JStage/JSGCamera.cpp
@@ -395,6 +415,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JStage/JSGLight.cpp
        libs/JSystem/src/JStage/JSGObject.cpp
        libs/JSystem/src/JStage/JSGSystem.cpp
+)
+
+add_library(JSystem_J2DGraph STATIC
        libs/JSystem/src/J2DGraph/J2DGrafContext.cpp
        libs/JSystem/src/J2DGraph/J2DOrthoGraph.cpp
        libs/JSystem/src/J2DGraph/J2DTevs.cpp
@@ -413,6 +436,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J2DGraph/J2DAnmLoader.cpp
        libs/JSystem/src/J2DGraph/J2DAnimation.cpp
        libs/JSystem/src/J2DGraph/J2DManage.cpp
+)
+
+add_library(JSystem_J3DGraphBase STATIC
        libs/JSystem/src/J3DGraphBase/J3DGD.cpp
        libs/JSystem/src/J3DGraphBase/J3DSys.cpp
        libs/JSystem/src/J3DGraphBase/J3DVertex.cpp
@@ -427,6 +453,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J3DGraphBase/J3DTevs.cpp
        libs/JSystem/src/J3DGraphBase/J3DDrawBuffer.cpp
        libs/JSystem/src/J3DGraphBase/J3DStruct.cpp
+)
+
+add_library(JSystem_J3DGraphAnimator STATIC
        libs/JSystem/src/J3DGraphAnimator/J3DShapeTable.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DJointTree.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DModelData.cpp
@@ -438,6 +467,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J3DGraphAnimator/J3DCluster.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DJoint.cpp
        libs/JSystem/src/J3DGraphAnimator/J3DMaterialAttach.cpp
+)
+
+add_library(JSystem_J3DGraphLoader STATIC
        libs/JSystem/src/J3DGraphLoader/J3DMaterialFactory.cpp
        libs/JSystem/src/J3DGraphLoader/J3DMaterialFactory_v21.cpp
        libs/JSystem/src/J3DGraphLoader/J3DClusterLoader.cpp
@@ -446,6 +478,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/J3DGraphLoader/J3DJointFactory.cpp
        libs/JSystem/src/J3DGraphLoader/J3DShapeFactory.cpp
        libs/JSystem/src/J3DGraphLoader/J3DAnmLoader.cpp
+)
+
+add_library(JSystem_JStudio STATIC
        libs/JSystem/src/JStudio/JStudio/ctb.cpp
        libs/JSystem/src/JStudio/JStudio/ctb-data.cpp
        libs/JSystem/src/JStudio/JStudio/functionvalue.cpp
@@ -460,6 +495,9 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JStudio/JStudio/stb.cpp
        libs/JSystem/src/JStudio/JStudio/stb-data-parse.cpp
        libs/JSystem/src/JStudio/JStudio/stb-data.cpp
+)
+
+add_library(JSystem_JStudio_JStage STATIC
        libs/JSystem/src/JStudio/JStudio_JStage/control.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object-actor.cpp
@@ -467,10 +505,19 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JStudio/JStudio_JStage/object-camera.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object-fog.cpp
        libs/JSystem/src/JStudio/JStudio_JStage/object-light.cpp
+)
+
+add_library(JSystem_JStudio_JAudio2 STATIC
        libs/JSystem/src/JStudio/JStudio_JAudio2/control.cpp
        libs/JSystem/src/JStudio/JStudio_JAudio2/object-sound.cpp
+)
+
+add_library(JSystem_JStudio_JParticle STATIC
        libs/JSystem/src/JStudio/JStudio_JParticle/control.cpp
        libs/JSystem/src/JStudio/JStudio_JParticle/object-particle.cpp
+)
+
+add_library(JSystem_JAudio2 STATIC
        libs/JSystem/src/JAudio2/JASCalc.cpp
        libs/JSystem/src/JAudio2/JASTaskThread.cpp
        libs/JSystem/src/JAudio2/JASDvdThread.cpp
@@ -535,22 +582,34 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JAudio2/JAUSoundAnimator.cpp
        libs/JSystem/src/JAudio2/JAUSoundTable.cpp
        libs/JSystem/src/JAudio2/JAUStreamFileTable.cpp
+)
+
+add_library(JSystem_JMessage STATIC
        libs/JSystem/src/JMessage/control.cpp
        libs/JSystem/src/JMessage/data.cpp
        libs/JSystem/src/JMessage/processor.cpp
        libs/JSystem/src/JMessage/resource.cpp
        libs/JSystem/src/JMessage/locale.cpp
+)
+
+add_library(JSystem_JGadget STATIC
        libs/JSystem/src/JGadget/binary.cpp
        libs/JSystem/src/JGadget/define.cpp
        libs/JSystem/src/JGadget/linklist.cpp
        libs/JSystem/src/JGadget/search.cpp
        libs/JSystem/src/JGadget/std-vector.cpp
+)
+
+add_library(JSystem_JAHostIO STATIC
        libs/JSystem/src/JAHostIO/JAHFrameNode.cpp
        libs/JSystem/src/JAHostIO/JAHioMessage.cpp
        libs/JSystem/src/JAHostIO/JAHioMgr.cpp
        libs/JSystem/src/JAHostIO/JAHioNode.cpp
        libs/JSystem/src/JAHostIO/JAHioUtil.cpp
        libs/JSystem/src/JAHostIO/JAHVirtualNode.cpp
+)
+
+add_library(JSystem_JHostIO STATIC
        libs/JSystem/src/JHostIO/JORFile.cpp
        libs/JSystem/src/JHostIO/JORHostInfo.cpp
        libs/JSystem/src/JHostIO/JORMessageBox.cpp
@@ -560,7 +619,28 @@ set(JSYSTEM_DEBUG_FILES
        libs/JSystem/src/JHostIO/JHIMccBuf.cpp
 )

-set(JSYSTEM_FILES
+set(JSYSTEM_LIBRARIES
+        JSystem_JParticle
+        JSystem_JFramework
+        JSystem_J3DU
+        JSystem_JKernel
+        JSystem_JMath
+        JSystem_JSupport
+        JSystem_JUtility
+        JSystem_JStage
+        JSystem_J2DGraph
+        JSystem_J3DGraphBase
+        JSystem_J3DGraphAnimator
+        JSystem_J3DGraphLoader
+        JSystem_JStudio
+        JSystem_JStudio_JStage
+        JSystem_JStudio_JAudio2
+        JSystem_JStudio_JParticle
+        JSystem_JAudio2
+        JSystem_JMessage
+        JSystem_JGadget
+        JSystem_JAHostIO
+        JSystem_JHostIO
 )

 set(REL_FILES
@@ -1331,54 +1411,125 @@ set(DOLPHIN_FILES
 )

 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
        src/d/actor/d_a_alink_dusk.cpp
        src/dusk/asserts.cpp
        src/dusk/config.cpp
        src/dusk/crash_reporting.cpp
+        src/dusk/data.cpp
+        src/dusk/data.hpp
        src/dusk/endian.cpp
        src/dusk/extras.c
-        src/dusk/extras.cpp
+        src/dusk/file_select.cpp
+        src/dusk/file_select.hpp
        src/dusk/frame_interpolation.cpp
+        src/dusk/game_clock.cpp
        src/dusk/globals.cpp
-        src/dusk/gyro_aim.cpp
+        src/dusk/gyro.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/stubs.cpp
+        src/dusk/update_check.cpp
+        src/dusk/update_check.hpp
        #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/imgui/ImGuiMenuGame.cpp
-        src/dusk/imgui/ImGuiMenuGame.hpp
+        src/dusk/imgui/ImGuiBloomWindow.cpp
+        src/dusk/imgui/ImGuiBloomWindow.hpp
        src/dusk/imgui/ImGuiMenuTools.cpp
        src/dusk/imgui/ImGuiMenuTools.hpp
-        src/dusk/imgui/ImGuiMenuEnhancements.cpp
-        src/dusk/imgui/ImGuiMenuEnhancements.hpp
-        src/dusk/imgui/ImGuiPreLaunchWindow.cpp
-        src/dusk/imgui/ImGuiPreLaunchWindow.hpp
-        src/dusk/imgui/ImGuiFirstRunPreset.hpp
-        src/dusk/imgui/ImGuiFirstRunPreset.cpp
+        src/dusk/imgui/ImGuiActorSpawner.cpp
        src/dusk/imgui/ImGuiProcessOverlay.cpp
        src/dusk/imgui/ImGuiCameraOverlay.cpp
        src/dusk/imgui/ImGuiHeapOverlay.cpp
-        src/dusk/imgui/ImGuiDebugPad.cpp
        src/dusk/imgui/ImGuiControllerOverlay.cpp
        src/dusk/imgui/ImGuiStubLog.cpp
-        src/dusk/imgui/ImGuiMapLoader.cpp
        src/dusk/imgui/ImGuiSaveEditor.cpp
        src/dusk/imgui/ImGuiStateShare.hpp
        src/dusk/imgui/ImGuiStateShare.cpp
+        src/dusk/ui/achievements.cpp
+        src/dusk/ui/achievements.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/component.cpp
+        src/dusk/ui/component.hpp
+        src/dusk/ui/controller_config.cpp
+        src/dusk/ui/controller_config.hpp
+        src/dusk/ui/document.cpp
+        src/dusk/ui/document.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/modal.cpp
+        src/dusk/ui/modal.hpp
+        src/dusk/ui/nav_types.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/prelaunch.cpp
+        src/dusk/ui/prelaunch.hpp
+        src/dusk/ui/preset.cpp
+        src/dusk/ui/preset.hpp
+        src/dusk/ui/reporting.cpp
+        src/dusk/ui/reporting.hpp
+        src/dusk/ui/select_button.cpp
+        src/dusk/ui/select_button.hpp
+        src/dusk/ui/settings.cpp
+        src/dusk/ui/settings.hpp
+        src/dusk/ui/string_button.cpp
+        src/dusk/ui/string_button.hpp
+        src/dusk/ui/tab_bar.cpp
+        src/dusk/ui/tab_bar.hpp
+        src/dusk/ui/ui.cpp
+        src/dusk/ui/ui.hpp
+        src/dusk/ui/warp.cpp
+        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/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
 )
@@ -4,30 +4,216 @@
  };
  outputs = { self, nixpkgs }:
    let
-      pkgs = import nixpkgs { system = "x86_64-linux"; };
-      dusk = pkgs.stdenv.mkDerivation {
-        name = "dusk";
-        src = ./.;
-        nativeBuildInputs = [
-          pkgs.cmake
-          pkgs.pkg-config
-          pkgs.wayland
-        ];
-        buildInputs = [
-          pkgs.libGL
-          pkgs.libX11
-          pkgs.libXcursor
-          pkgs.libxi
-          pkgs.libxcb
-          pkgs.libxrandr
-          pkgs.libxscrnsaver
-          pkgs.libxtst
-          pkgs.libjpeg8
-          pkgs.libxkbcommon
-          pkgs.libglvnd
-        ];
+      supportedSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+      pkgsFor = system: import nixpkgs { inherit system; };
+
+      # Dependencies that are not packaged in nixpkgs (used by the Linux package build):
+      buildSources = pkgs: {
+        dawn-src = pkgs.fetchzip {
+          url = "https://github.com/encounter/dawn-build/releases/download/v20260423.175430/dawn-linux-x86_64.tar.gz";
+          hash = "sha256-HXfKTLHtMPwupnFnaflCARtXVPuS/0PoCePXidjE5xs=";
+          stripRoot = false;
+        };
+        nod-src = pkgs.fetchzip {
+          url = "https://github.com/encounter/nod/releases/download/v2.0.0-alpha.8/libnod-linux-x86_64.tar.gz";
+          hash = "sha256-mUqvLsbsqaZ+HAjMmHYPYO+MgtanGRTw7Gzn5uXR5rE=";
+          stripRoot = false;
+        };
+        # The version of imgui on nixpkgs does not map cleanly.
+        imgui-src = pkgs.fetchFromGitHub {
+          owner = "ocornut";
+          repo = "imgui";
+          rev = "v1.91.9b-docking";
+          hash = "sha256-mQOJ6jCN+7VopgZ61yzaCnt4R1QLrW7+47xxMhFRHLQ=";
+        };
+        sqlite-src = pkgs.fetchzip {
+          url = "https://sqlite.org/2026/sqlite-amalgamation-3510300.zip";
+          hash = "sha256-pNMR8zxaaqfAzQ0AQBOXMct4usdjey1Q0Gnitg06UhM=";
+        };
+        rmlui-src = pkgs.fetchzip {
+          url = "https://github.com/mikke89/RmlUi/archive/f9b8c9e2935d5df2c7dff2c190d3968e99b0c3dc.tar.gz";
+          hash = "sha256-g4O/JZUrrcseOz8o2QJRt+2CeuiLnVeuDJc906xvuIg=";
+        };
      };
+
+      # Dusklight Actual (Linux x86_64 only — relies on prebuilt dawn/nod binaries)
+      mkDusklight = pkgs:
+        let srcs = buildSources pkgs;
+          versionSuffix = if self ? shortRev && self.shortRev != null
+            then "nix-${self.shortRev}"
+            else "nix-dirty";
+        in
+        pkgs.stdenv.mkDerivation {
+          name = "dusklight";
+          src = ./.;
+          postUnpack = ''
+            sed -i '/add_subdirectory(tests)/d' $sourceRoot/extern/aurora/CMakeLists.txt
+          '';
+          # Remove last line to re-enable tests
+          cmakeFlags = [
+            "-DDUSK_VERSION_OVERRIDE=${versionSuffix}"
+            "-DFETCHCONTENT_FULLY_DISCONNECTED=ON"
+            "-DFETCHCONTENT_SOURCE_DIR_CXXOPTS=${pkgs.cxxopts.src}"
+            "-DFETCHCONTENT_SOURCE_DIR_JSON=${pkgs.nlohmann_json.src}"
+            "-DFETCHCONTENT_SOURCE_DIR_DAWN_PREBUILT=${srcs.dawn-src}"
+            "-DFETCHCONTENT_SOURCE_DIR_XXHASH=${pkgs.xxHash.src}"
+            "-DFETCHCONTENT_SOURCE_DIR_FMT=${pkgs.fmt.src}"
+            "-DFETCHCONTENT_SOURCE_DIR_TRACY=${pkgs.tracy.src}"
+            "-DAURORA_SDL3_PROVIDER=system"
+            "-DFETCHCONTENT_SOURCE_DIR_NOD_PREBUILT=${srcs.nod-src}"
+            "-DAURORA_NOD_PROVIDER=package"
+            "-DFETCHCONTENT_SOURCE_DIR_FREETYPE=${pkgs.freetype.src}"
+            "-DFETCHCONTENT_SOURCE_DIR_ZSTD=${pkgs.zstd.src}"
+            "-DFETCHCONTENT_SOURCE_DIR_SQLITE3=${srcs.sqlite-src}"
+            "-DFETCHCONTENT_SOURCE_DIR_IMGUI=${srcs.imgui-src}"
+            "-DFETCHCONTENT_SOURCE_DIR_RMLUI=${srcs.rmlui-src}"
+            "-DCMAKE_CROSSCOMPILING=ON" # Tests are not working as I didn't want to work through getting google's test suite working as well. This is the only guard I could find to disable it.
+          ];
+          installPhase = ''
+            mkdir -p $out/bin
+            cp dusklight $out/bin/dusklight
+            cp -r ./res $out/bin/res
+
+            mkdir -p $out/share/applications
+            cp $src/platforms/freedesktop/dusklight.desktop $out/share/applications/dusklight.desktop
+
+            for size in 16 32 48 64 128 256 512 1024; do
+              install -Dm644 $src/platforms/freedesktop/''${size}x''${size}/apps/dusklight.png \
+                $out/share/icons/hicolor/''${size}x''${size}/apps/dusklight.png
+            done
+          '';
+          nativeBuildInputs = [
+            pkgs.cmake
+            pkgs.pkg-config
+            pkgs.wayland
+          ];
+          buildInputs = [
+            pkgs.libGL
+            pkgs.libX11
+            pkgs.libXcursor
+            pkgs.libxi
+            pkgs.libxcb
+            pkgs.libxrandr
+            pkgs.libxscrnsaver
+            pkgs.libxtst
+            pkgs.libjpeg8
+            pkgs.libxkbcommon
+            pkgs.libglvnd
+            pkgs.cxxopts
+            pkgs.abseil-cpp
+            pkgs.sdl3
+            pkgs.fmt
+            pkgs.tracy
+            pkgs.freetype
+            pkgs.zstd
+          ];
+        };
+
+      # Tooling common to every supported host (Linux and macOS).
+      commonDevTools = pkgs: [
+        pkgs.cmake
+        pkgs.ninja
+        pkgs.pkg-config
+        pkgs.git
+        pkgs.python3
+        pkgs.python3Packages.markupsafe
+        pkgs.rustc
+        pkgs.cargo
+        pkgs.sccache
+      ];
+
+      # Linux-only system libraries — mirrors the apt deps from .github/workflows/build.yml
+      # so the cmake presets resolve the same set of headers as CI.
+      linuxDevDeps = pkgs: [
+        # Compilers / linkers
+        pkgs.clang
+        pkgs.lld
+        # C/C++ utilities
+        pkgs.curl
+        pkgs.openssl
+        pkgs.zlib
+        pkgs.libpng
+        pkgs.libjpeg_turbo
+        pkgs.freetype
+        pkgs.zstd
+        pkgs.fmt
+        pkgs.tracy
+        pkgs.cxxopts
+        pkgs.abseil-cpp
+        pkgs.sdl3
+        pkgs.ncurses
+        pkgs.libunwind
+        pkgs.libusb1
+        pkgs.fuse
+        # Wayland / display server
+        pkgs.wayland
+        pkgs.wayland-protocols
+        pkgs.libxkbcommon
+        pkgs.libdecor
+        # OpenGL / Vulkan
+        pkgs.libGL
+        pkgs.libGLU
+        pkgs.libglvnd
+        pkgs.vulkan-headers
+        pkgs.vulkan-loader
+        # X11
+        pkgs.libX11
+        pkgs.libxcb
+        pkgs.libXcursor
+        pkgs.libxi
+        pkgs.libxrandr
+        pkgs.libxscrnsaver
+        pkgs.libxtst
+        pkgs.libxinerama
+        # Audio
+        pkgs.alsa-lib
+        pkgs.libpulseaudio
+        pkgs.pipewire
+        # System integration
+        pkgs.dbus
+        pkgs.udev
+        pkgs.gtk3
+      ];
+
+      # On macOS we deliberately avoid pulling Nix's cc-wrapper so CMake picks up
+      # Apple Clang and the Xcode SDK directly, matching the macOS CI workflow.
+      mkDarwinShell = pkgs:
+        pkgs.mkShellNoCC {
+          packages = commonDevTools pkgs;
+          shellHook = ''
+            echo "Dusklight dev shell (macOS)"
+            echo "Requires Xcode Command Line Tools for Apple Clang and the macOS SDK."
+            echo "Configure: cmake --preset macos-default-relwithdebinfo"
+            echo "Build:     cmake --build --preset macos-default-relwithdebinfo"
+          '';
+        };
+
+      mkLinuxShell = pkgs:
+        pkgs.mkShell {
+          packages = (commonDevTools pkgs) ++ (linuxDevDeps pkgs);
+          shellHook = ''
+            echo "Dusklight dev shell (Linux)"
+            echo "Configure: cmake --preset linux-default-relwithdebinfo"
+            echo "           cmake --preset linux-clang-relwithdebinfo"
+            echo "Build:     cmake --build --preset <preset>"
+          '';
+        };
+
+      mkDevShell = pkgs:
+        if pkgs.stdenv.isDarwin
+        then mkDarwinShell pkgs
+        else mkLinuxShell pkgs;
    in {
-      packages.x86_64-linux.default = dusk;
+      packages.x86_64-linux.default = mkDusklight (pkgsFor "x86_64-linux");
+
+      devShells = forAllSystems (system: {
+        default = mkDevShell (pkgsFor system);
+      });
    };
 }
@@ -4551,7 +4551,19 @@ public:
 #if TARGET_PC
    void handleWolfHowl();
    void handleQuickTransform();
-    bool checkGyroAimItemContext();
+    bool checkGyroAimContext();
+
+    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;
 #endif
 };  // Size: 0x385C

@@ -188,6 +188,15 @@ public:
    /* 0x273C */ f32 mKankyoBlend;
    /* 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
 };

 STATIC_ASSERT(sizeof(b_gnd_class) == 0x2790);
@@ -80,6 +80,12 @@ 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);
@@ -73,6 +73,12 @@ 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);
@@ -44,6 +44,12 @@ 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);
@@ -81,6 +81,15 @@ 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);
@@ -220,6 +220,15 @@ public:
    /* 0x17E2 */ s16 wait_roll_angle;  ///< @brief Roll angle during wait state.
    /* 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
 };

 STATIC_ASSERT(sizeof(e_wb_class) == 0x17EC);
@@ -74,6 +74,12 @@ 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);
@@ -63,6 +63,15 @@ 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);
@@ -77,6 +77,12 @@ 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);
@@ -25,6 +25,10 @@ public:
    /* 0x164 */ cXyz mMinVal;
    /* 0x170 */ cXyz mMaxVal;
    /* 0x17C */ cXyz mViewScale;
+#if TARGET_PC
+    bool mbReset = false;
+    bool mbHadEntry = false;
+#endif
 };

 /**
@@ -94,6 +94,12 @@ static void __THPAudioInitialize(THPAudioDecodeInfo* info, u8* ptr);
 #define THP_TEXTURE_SET_COUNT  3
 #endif

+#if TARGET_PC
+namespace dusk {
+    void MoviePlayerShutdown();
+}
+#endif
+
 struct daMP_THPPlayer {
    /* 0x000 */ DVDFileInfo fileInfo;
 	/* 0x03C */ THPHeader header;
@@ -31,6 +31,10 @@ 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;
@@ -42,6 +46,14 @@ 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);
@@ -25,6 +25,10 @@ public:
    int Draw();
    int Delete();

+#if TARGET_PC
+    void onInterpCallback();
+#endif
+
    enum Param_e {
        LOCK_e = (1 << 6), NO_BASE_DISP = (1 << 7)
    };
@@ -50,6 +54,13 @@ 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);
@@ -58,6 +58,9 @@ public:
    void setNextPoint();
    int Draw();
    int Delete();
+#if TARGET_PC
+    friend void daL8Lift_interp_callback(bool isSimFrame, void* pUserWork);
+#endif

    u8 getPthID() { return fopAcM_GetParamBit(this, 0, 8); }
    u8 getMoveSpeed() { return fopAcM_GetParamBit(this, 8, 4); }
@@ -68,10 +68,8 @@ public:
    /* 0x904 */ cXyz field_0x904[2];
    /* 0x91C */ int field_0x91c;
    /* 0x920 */ cXyz field_0x920[63];
-    /* 0xC14 */ f32 field_0xc14[4];
-    /* 0xC24 */ u8 field_0xc24[0xd10 - 0xc24];
-    /* 0xD10 */ s8 field_0xd10[4];
-    /* 0xD14 */ u8 field_0xd14[0xd50 - 0xd14];
+    /* 0xC14 */ f32 field_0xc14[63];
+    /* 0xD10 */ s8 field_0xd10[64];
    /* 0xD50 */ mDoExt_3DlineMat1_c field_0xd50;
    /* 0xD8C */ int field_0xd8c;
 };
@@ -143,6 +143,12 @@ public:
    /* 0x20 */ JORFile mFile;
 #endif

+#if TARGET_PC
+    /* 0x24 */ u8 mManualMode;
+    /* 0x25 */ f32 freeXAngle;
+    /* 0x29 */ f32 freeYAngle;
+#endif
+
    u32 Id(s32 i_style) { return mCamStyleData[i_style].field_0x0; }
    int Algorythmn(s32 i_style) { return mCamStyleData[i_style].field_0x4; }
    int Algorythmn() { return mCurrentStyle->field_0x4; }
@@ -118,6 +118,18 @@ class camera_class;
 class dCamera_c;
 typedef bool (dCamera_c::*engine_fn)(s32);

+#if TARGET_PC
+struct DebugFlyCam {
+    bool initialized;
+    f32 pitch;
+    f32 yaw;
+    cXyz savedCenter;
+    cXyz savedEye;
+    f32 savedFovy;
+    cSAngle savedBank;
+};
+#endif
+
 class dCamera_c {
 public:
    class dCamInfo_c {
@@ -273,6 +285,8 @@ public:
        /* 0xA4 */ f32 field_0xa4;
        /* 0xA8 */ int field_0xa8;
        /* 0xAC */ f32 field_0xac;
+        f32 xAngle;
+        f32 yAngle;
    };

    struct LockOnData {
@@ -1024,6 +1038,11 @@ public:
    bool colosseumCamera(s32);
    bool test1Camera(s32);
    bool test2Camera(s32);
+    #if TARGET_PC
+    bool freeCamera();
+    bool executeDebugFlyCam();
+    void deactivateDebugFlyCam();
+    #endif
    bool towerCamera(s32);
    bool hookshotCamera(s32);
    bool railCamera(s32);
@@ -1371,6 +1390,10 @@ public:
    /* 0x970 */ dCamSetup_c mCamSetup;
    /* 0xAEC */ dCamParam_c mCamParam;
    /* 0xB0C */ u8 field_0xb0c;
+
+#if TARGET_PC
+    DebugFlyCam mDebugFlyCam;
+#endif
 };  // Size: 0xB10

 dCamera_c* dCam_getBody();
@@ -1845,6 +1845,12 @@ 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 char* dComIfGs_getPlayerName() {
    return g_dComIfG_gameInfo.info.getPlayer().getPlayerInfo().getPlayerName();
 }
@@ -4834,8 +4840,7 @@ inline void dComIfGd_drawXluListDark() {
 inline void dComIfGd_drawXluListInvisible() {
    ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::getSettings().game.enableWaterRefraction &&
-        !dusk::getSettings().game.enableFrameInterpolation) {
+    if (!dusk::getSettings().game.disableWaterRefraction) {
 #endif
        g_dComIfG_gameInfo.drawlist.drawXluListInvisible();
 #ifdef TARGET_PC
@@ -4846,8 +4851,7 @@ inline void dComIfGd_drawXluListInvisible() {
 inline void dComIfGd_drawOpaListInvisible() {
    ZoneScoped;
 #ifdef TARGET_PC
-    if (dusk::getSettings().game.enableWaterRefraction &&
-        !dusk::getSettings().game.enableFrameInterpolation) {
+    if (!dusk::getSettings().game.disableWaterRefraction) {
 #endif
        g_dComIfG_gameInfo.drawlist.drawOpaListInvisible();
 #ifdef TARGET_PC
@@ -209,6 +209,10 @@ public:
    /* 0x04 */ TGXTexObj* mpTexObj;
    /* 0x08 */ Mtx mVolumeMtx;
    /* 0x38 */ Mtx mMtx;
+#if TARGET_PC
+    const void* mVolumeMtxKey;
+    const void* mMtxKey;
+#endif
 };  // Size: 0x68

 struct cBgD_Vtx_t;
@@ -196,7 +196,11 @@ public:
    /* 0x108 */ int mSkipTimer;
    /* 0x10C */ int mSkipParameter;
    /* 0x110 */ BOOL mIsSkipFade;
+#if TARGET_PC
+    /* 0x114 */ char mSkipEventName[21];
+#else
    /* 0x114 */ char mSkipEventName[20];
+#endif
    /* 0x128 */ u8 mCompulsory;
    /* 0x129 */ bool mRoomInfoSet;
    /* 0x12C */ int mRoomNo;
@@ -10,6 +10,7 @@
 #include "JSystem/J3DGraphLoader/J3DAnmLoader.h"

 class dFile_info_c;
+class J2DPicture;

 class dDlst_FileSel_c : public dDlst_base_c {
 public:
@@ -113,6 +114,14 @@ public:
    /* 0x04 */ J2DScreen* Scr3m;
 };

+class dDlst_FileSelFade_c : public dDlst_base_c {
+public:
+    void draw();
+    virtual ~dDlst_FileSelFade_c() {}
+
+    /* 0x04 */ J2DPicture* mpPict;
+};
+
 class dFs_HIO_c : public JORReflexible {
 public:
    dFs_HIO_c();
@@ -676,6 +685,9 @@ public:
    #if PLATFORM_GCN
    /* 0x2378 */ J2DPicture* mpFadePict;
    #endif
+#ifdef TARGET_PC
+    dDlst_FileSelFade_c mFadeDlst;
+#endif

    #if PLATFORM_WII || PLATFORM_SHIELD
    /* 0x2376 */ u8 field_0x2376[SAVEFILE_SIZE];
@@ -684,6 +696,10 @@ public:
    #endif
 };

+#ifdef TARGET_PC
+STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C + sizeof(dDlst_FileSelFade_c));
+#else
 STATIC_ASSERT(sizeof(dFile_select_c) == 0x237C);
+#endif

 #endif /* D_FILE_D_FILE_SELECT_H */
@@ -223,6 +223,9 @@ private:
    /* 0x8F */ u8 field_0x8f;
    /* 0x90 */ u8 field_0x90;
    /* 0x91 */ u8 field_0x91;
+#if TARGET_PC
+    bool previousMirror;
+#endif
 };  // Size: 0x94

 class dMap_HIO_list_c : public dMpath_HIO_n::hioList_c {
@@ -91,6 +91,10 @@ public:
    void calcCursor();
    void drawCursor();

+    #if TARGET_PC
+    void dMapBgWide();
+    #endif
+
    void setDPDFloorSelCurPos(s8 i_pos) { field_0xdd6 = i_pos; }

    f32 getMapWidth() { return mMapWidth; }
@@ -103,6 +107,10 @@ public:
        field_0xd98 = param_1;
    }

+#if TARGET_PC
+    void resetScrollArrowMask() { field_0xdda = 0; }
+#endif
+
    /* 0xC98 */ JKRExpHeap* mpHeap;
    /* 0xC9C */ JKRExpHeap* mpTalkHeap;
    /* 0xCA0 */ STControl* mpStick;
@@ -75,7 +75,9 @@ public:
        /* 0x8 */ BE(u16) mAreaName;
        /* 0xA */ u8 mCount;
 #ifdef _MSVC_LANG
-        u8* __get_mRoomNos() const { return (u8*)(this + 1); }
+        // Room numbers start at offset 0xB (right after mCount), NOT at sizeof(data)=12.
+        // (u8*)(this+1) would give offset 12 because MSVC sizeof=12; use &mCount+1 instead.
+        u8* __get_mRoomNos() const { return (u8*)&mCount + 1; }
        __declspec(property(get = __get_mRoomNos)) u8* mRoomNos;
 #else
        /* 0xB */ u8 mRoomNos[0];
@@ -81,6 +81,10 @@ public:
    void calcDrawPriority();
    void setArrowPosAxis(f32, f32);

+    #if TARGET_PC
+    void fMapBackWide();
+    #endif
+
    virtual void draw();
    virtual ~dMenu_Fmap2DBack_c();

@@ -165,6 +169,12 @@ public:

    void mapBlink() {}

+    #if PLATFORM_WII || TARGET_PC
+    f32 getMirrorPosX(f32 param_0, f32 param_1) {
+        return (field_0x11dc * 2.0f - (param_0 + param_1)) - param_1;
+    }
+    #endif
+
    // Unknown name
    struct RegionTexData {
        /* 0x00 */ float mMinX;
@@ -330,6 +340,10 @@ public:
    void setHIO(bool);
    bool isWarpAccept();

+    #if TARGET_PC
+    void fMapTopWide();
+    #endif
+
    virtual void draw();
    virtual ~dMenu_Fmap2DTop_c();

@@ -66,6 +66,16 @@ public:
        _c90 = param_2;
    }

+#if PLATFORM_WII || TARGET_PC
+    f32 getMirrorCenterPosX(f32 param_0, f32 param_1) {
+        if (_c90) {
+            return (mCenterPosX * 2.0f - (param_0 + param_1)) - param_1;
+        }
+
+        return param_0;
+    }
+#endif
+
    struct Stage_c {
        // Incomplete class

@@ -204,6 +204,18 @@ private:
    /* 0x6D1 */ u8 field_0x6d1;
    /* 0x6D2 */ u8 field_0x6d2;
    /* 0x6D3 */ u8 field_0x6d3;
+#if TARGET_PC
+    f32 mSelectItemSlideElapsed[4];
+    f32 mCursorInterpPrevX;
+    f32 mCursorInterpPrevY;
+    f32 mCursorInterpCurrX;
+    f32 mCursorInterpCurrY;
+    s16 mCursorInterpPrevAngle;
+    s16 mCursorInterpCurrAngle;
+    bool mCursorInterpPrevAngular;
+    bool mCursorInterpCurrAngular;
+    bool mCursorInterpInit;
+#endif
 };

 #endif /* D_MENU_D_MENU_RING_H */
@@ -343,6 +343,11 @@ public:
    /* 0x624 */ f32 mMidonaPosX;
    /* 0x628 */ f32 mMidonaPosY;
    /* 0x62C */ f32 mMidonaScale;
+
+#ifdef TARGET_PC
+    bool mWasListen[2];
+    bool mWasRepeat[2];
+#endif
 };

 #endif /* D_METER_D_METER_BUTTON_H */
@@ -67,6 +67,9 @@ public:
    bool isStaffMessage();
    bool isSaveMessage();
    bool isTalkMessage();
+#if TARGET_PC
+    bool isShopItemMessage();
+#endif
    const char* getSmellName();
    const char* getPortalName();
    const char* getBombName();
@@ -89,7 +89,7 @@ public:
    void MojiSelectAnm3();
    int mojiChange(u8);
    void selectMojiSet();
-    #if REGION_JPN
+    #if TARGET_PC || REGION_JPN
    int checkDakuon(int, u8);
    int setDakuon(int, u8);
    #endif
@@ -79,7 +79,7 @@ public:
    bool isProgressiveMode();
    void setRenderMode();

-    #if VERSION == VERSION_GCN_PAL || PLATFORM_WII || PLATFORM_SHIELD
+    #if TARGET_PC || VERSION == VERSION_GCN_PAL || PLATFORM_WII || PLATFORM_SHIELD
    u8 getPalLanguage();
    #endif

@@ -149,7 +149,7 @@ public:
    /* 0x200 */ dDlst_2D_c* mNvLogo;
    /* 0x204 */ dDlst_2D_c* mMocImg;
 #endif
-#if VERSION == VERSION_GCN_PAL
+#if TARGET_PC || VERSION == VERSION_GCN_PAL
    /* 0x1FC */ mDoDvdThd_mountArchive_c* mpPalLogoResCommand;
 #endif
    /* 0x1FC */ request_of_phase_process_class* m_preLoad_dylPhase;
@@ -486,6 +486,9 @@ public:
            mDeathCount++;
        }
    }
+#if TARGET_PC
+    u16 getDeathCount() const { return mDeathCount; }
+#endif
    char* getPlayerName() const { return const_cast<char*>(mPlayerName); }
    void setPlayerName(const char* i_name) {
 #if AVOID_UB
@@ -47,6 +47,13 @@ public:
        mPositionY = y;
    }

+#ifdef TARGET_PC
+    f32 getPositionX() const { return mPositionX; }
+    f32 getPositionY() const { return mPositionY; }
+
+    void refreshAspectScale();
+#endif
+
    void onUpdateFlag() { mUpdateFlag = true; }

    void resetUpdateFlag() { mUpdateFlag = false; }
@@ -79,6 +86,9 @@ private:
    /* 0x58 */ f32 mPositionX;
    /* 0x5C */ f32 mPositionY;
    /* 0x60 */ f32 mParam1;
+#ifdef TARGET_PC
+    f32 mBaseParam1;
+#endif
    /* 0x64 */ f32 mParam2;
    /* 0x68 */ f32 mParam3;
    /* 0x6C */ f32 mParam4;
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <queue>
+#include <string>
+#include <string_view>
+#include <unordered_set>
+#include <vector>
+#include "nlohmann/json.hpp"
+
+namespace dusk {
+
+enum class AchievementCategory : uint8_t {
+    Challenge,
+    Collection,
+    Minigame,
+    Misc,
+    Glitched
+};
+
+struct Achievement {
+    const char* key;
+    const char* name;
+    const char* description;
+    AchievementCategory category;
+    bool isCounter;
+    int32_t goal;
+    int32_t progress;
+    bool unlocked;
+};
+
+// Responsible for updating a.progress.
+// Use extra for any per-achievement state that must survive across frames or sessions, extra is saved
+using AchievementCheckFn = std::function<void(Achievement& a, nlohmann::json& extra)>;
+
+class AchievementSystem {
+public:
+    static AchievementSystem& get();
+
+    void load();
+    void save();
+    void tick();
+    void clearAll();
+    void clearOne(const char* key);
+
+    // Signals are visible to all achievement checks within the same tick, then cleared.
+    void signal(const char* key);
+    bool hasSignal(const char* key) const;
+
+    std::vector<Achievement> getAchievements() const;
+
+private:
+    struct Entry {
+        Achievement achievement;
+        AchievementCheckFn check;
+        nlohmann::json extra;
+    };
+
+    AchievementSystem();
+    static std::vector<Entry> makeEntries();
+    void processEntry(Entry& e);
+
+    std::vector<Entry> m_entries;
+    std::unordered_set<std::string_view> m_signals;
+    bool m_loaded = false;
+    bool m_dirty = false;
+};
+
+} // namespace dusk
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "dusk/config_var.hpp"
+
+namespace dusk {
+
+enum class ActionBinds {
+    FIRST_PERSON_CAMERA,
+    CALL_MIDNA,
+    OPEN_DUSKLIGHT_MENU,
+    TURBO_SPEED_BUTTON,
+    COUNT,
+};
+
+struct ActionBindData {
+    std::array<config::ActionBindConfigVar, 4>* configVars{};
+    std::string actionName{};
+};
+
+struct ActionBindPressData {
+    bool pressedCurFrame{false};
+    bool pressedPrevFrame{false};
+};
+
+using ActionBindsMap = std::unordered_map<ActionBinds, ActionBindData>;
+
+ActionBindsMap& getActionBinds();
+
+bool isActionBound(ActionBinds action, u32 port);
+
+void updateActionBindings();
+
+bool getActionBindTrig(ActionBinds action, u32 port);
+
+bool getActionBindHold(ActionBinds action, u32 port);
+
+bool getActionBindHoldAnyPort(ActionBinds action);
+
+int getActionBindButton(ActionBinds action, u32 port);
+
+}
@@ -7,7 +7,12 @@ namespace dusk {
     *
     * This gets used for file paths and such, and cannot be changed!
     */
-    constexpr auto AppName = "Dusk";
+    constexpr auto AppName = "Dusklight";
+
+    /**
+     * Previous AppName to migrate data from.
+     */
+    constexpr auto LegacyAppName = "Dusk";

    /**
     * \brief The internal organization name for the game.
@@ -1,8 +1,19 @@
 #pragma once

+#include <cmath>
 #include <dolphin/types.h>

 namespace dusk::audio {
+
+    // Converts a 0-1 volume to a linear amplitude multiplier.
+    // The curve is -4 dB per 10% step: 100% = 0 dB, 90% = -4 dB, ..., 0% = -inf dB
+    inline f32 MasterVolumeToLinear(f32 v) {
+        if (v <= 0.0f) {
+            return 0.0f;
+        }
+        return std::pow(10.0f, (v - 1.0f) * 2.0f);
+    }
+
    /**
     * Initialize the audio system and start playing audio.
     */
@@ -12,6 +23,8 @@ namespace dusk::audio {

    void SetMasterVolume(f32 value);

+    void SetPaused(bool paused);
+
    u32 GetResetCount(int channelIdx);

    f32 VolumeFromU16(u16 value);
@@ -0,0 +1,19 @@
+#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();
+void enterAutoSave();
+void autoSaving();
+void waitingForWrite();
+void endAutoSave();
+void toggleAutoSave(bool enabled);
+
+#endif
@@ -1,6 +1,7 @@
 #ifndef DUSK_CONFIG_HPP
 #define DUSK_CONFIG_HPP

+#include <functional>
 #include <stdexcept>
 #include "nlohmann/json.hpp"
 #include "config_var.hpp"
@@ -111,6 +112,18 @@ void Save();
 */
 ConfigVarBase* GetConfigVar(std::string_view name);

+/**
+ * \brief Resets all custom action bindings for a specific port to nothing
+ *
+ * @param port The port to be cleared of action bindings
+ */
+void ClearAllActionBindings(int port);
+
+/**
+ * \brief Call a function on every registered CVar.
+ */
+void EnumerateRegistered(std::function<void(ConfigVarBase&)> callback);
+
 template <ConfigValue T>
 const ConfigImplBase* GetConfigImpl() {
    static ConfigImpl<T> config;
@@ -48,6 +48,13 @@ enum class ConfigVarLayer : u8 {
     * Will not get saved to config.
     */
    Override,
+
+    /**
+     * The CVar is temporarily overridden by speedrun mode.
+     * Will not get saved to config. Cleared when speedrun mode is disabled.
+     * Lower priority than Override, so launch args still win.
+     */
+    Speedrun,
 };

 class ConfigImplBase;
@@ -113,6 +120,12 @@ public:
     * This is necessary to make it legal to access.
     */
    void markRegistered();
+
+    /**
+     * Clear a speedrun-mode override if one is active on this CVar.
+     * Safe to call on any CVar, no-op if not at the Speedrun layer.
+     */
+    virtual void clearSpeedrunOverride() {}
 };

 template <typename T>
@@ -162,6 +175,7 @@ class ConfigVar : public ConfigVarBase {
    T defaultValue;
    T value;
    T overrideValue;
+    ConfigVarLayer priorLayer = ConfigVarLayer::Default;

 public:
    /**
@@ -189,6 +203,7 @@ public:
        case ConfigVarLayer::Value:
            return value;
        case ConfigVarLayer::Override:
+        case ConfigVarLayer::Speedrun:
            return overrideValue;
        default:
            abort();
@@ -239,8 +254,54 @@ public:
        overrideValue = std::move(newValue);
        layer = ConfigVarLayer::Override;
    }
+
+    /**
+     * \brief Give a CVar a speedrun-mode override value.
+     *
+     * Lower priority than a launch-arg override. Cleared when speedrun mode is disabled.
+     * The overridden value will not get saved to config.
+     *
+     * @param newValue The new value the CVar will get.
+     */
+    void setSpeedrunValue(T newValue) {
+        checkRegistered();
+        if (layer != ConfigVarLayer::Override) {
+            priorLayer = layer;
+            overrideValue = std::move(newValue);
+            layer = ConfigVarLayer::Speedrun;
+        }
+    }
+
+    void clearOverride() {
+        checkRegistered();
+        if (layer == ConfigVarLayer::Override) {
+            overrideValue = {};
+            layer = ConfigVarLayer::Value;
+        }
+    }
+
+    void clearSpeedrunOverride() override {
+        checkRegistered();
+        if (layer == ConfigVarLayer::Speedrun) {
+            overrideValue = {};
+            layer = priorLayer;
+        }
+    }
+
+    /**
+     * \brief Get the user-persisted value, ignoring any temporary overrides.
+     *
+     * Used by Save() to write the correct value even when a speedrun override is active.
+     */
+    [[nodiscard]] constexpr const T& getValueForSave() const noexcept {
+        checkRegistered();
+        const ConfigVarLayer effectiveLayer = (layer == ConfigVarLayer::Speedrun) ? priorLayer : layer;
+        return effectiveLayer == ConfigVarLayer::Default ? defaultValue : value;
+    }
 };

+using ActionBindConfigVar = ConfigVar<int>;
+
 }

 #endif  // DUSK_CONFIG_VAR_HPP
@@ -1,8 +1,17 @@
 #pragma once

-namespace dusk {
+namespace dusk::crash_reporting {

-void InitializeCrashReporting();
-void ShutdownCrashReporting();
+enum class Consent {
+    Unavailable,
+    Unknown,
+    Given,
+    Revoked,
+};

-}  // namespace dusk
+void initialize();
+void shutdown();
+Consent get_consent();
+void set_consent(bool enabled);
+
+}  // namespace dusk::crash_reporting
@@ -0,0 +1,14 @@
+#pragma once
+
+#ifdef DUSK_DISCORD
+
+namespace dusk::discord {
+
+void initialize();
+void run_callbacks();
+void update_presence();
+void shutdown();
+
+}  // namespace dusk::discord
+
+#endif  // DUSK_DISCORD
@@ -6,7 +6,6 @@
 #include "aurora/gfx.h"

 extern AuroraInfo auroraInfo;
-extern const char* configPath;

 namespace dusk {
    extern AuroraStats lastFrameAuroraStats;
@@ -1,22 +1,31 @@
 #pragma once

 #include "dolphin/types.h"
+#include "version.hpp"

 namespace dusk {

+struct OffsetVersion {
+    version::GameVersion mGameVersion;
+    u32 mOffset;
+
+    constexpr OffsetVersion(const version::GameVersion gameVersion, const u32 offset)
+        : mGameVersion(gameVersion), mOffset(offset) {}
+};
+
 /**
 * Load bytes from the main DOL by GameCube virtual address
 */
-bool LoadDolAsset(void* dst, u32 virtualAddress, s32 size);
+bool LoadDolAsset(void* dst, std::initializer_list<OffsetVersion> virtualAddress, s32 size);

 /**
 * Load bytes from a REL file in the ISO filesystem, dst must be 32-byte aligned
 */
-bool LoadRelAsset(void* dst, const char* dvdPath, s32 offset, s32 size);
+bool LoadRelAsset(void* dst, const char* dvdPath, std::initializer_list<OffsetVersion> offset, s32 size);

 /**
 * Load bytes from a REL inside RELS.arc
 */
-bool LoadArchivedRelAsset(void* dst, u32 memType, const char* relFileName, s32 offset, s32 size);
+bool LoadArchivedRelAsset(void* dst, u32 memType, const char* relFileName, std::initializer_list<OffsetVersion> offset, s32 size);

 }  // namespace dusk
@@ -1,13 +1,12 @@
-#ifndef DUSK_FRAME_INTERP_H
-#define DUSK_FRAME_INTERP_H
+#pragma once

 #include <dolphin/mtx.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>

-struct cXyz;
 class camera_process_class;
+class view_class;

 #ifdef __cplusplus
 namespace dusk {
@@ -15,36 +14,40 @@ namespace frame_interp {

 void ensure_initialized();

-void begin_record_camera();
 void begin_record();
 void end_record();
-void interpolate(float step);
+void begin_sim_tick();
+uint64_t sim_tick_seq();
+void begin_frame(bool enabled, bool is_sim_frame, float step);
+void interpolate();
 float get_interpolation_step();

-void notify_presentation_frame();
 void request_presentation_sync();
 bool presentation_sync_active();

-void notify_sim_tick_complete();
-uint32_t begin_presentation_ui_pass();
-uint32_t get_presentation_ui_advance_ticks();
-void end_presentation_ui_pass();
+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 open_child(const void* key, int32_t id);
-void close_child();
 void record_camera(::camera_process_class* cam, int camera_id);
-void record_final_mtx_raw(const Mtx* dest, const Mtx src);
-void record_final_mtx_raw_tagged(const Mtx* dest, const Mtx src, uint64_t stable_tag);
+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* source, Mtx out);
+bool lookup_replacement(const void* key, Mtx out);
 bool lookup_concat_replacement(const void* lhs, const void* rhs, Mtx out);

-void camera_eye_from_view_mtx(MtxP view_mtx, cXyz* o_eye);
-bool build_star_view(Mtx o_view, Mtx o_cam_billboard_base, cXyz* o_anchor_eye, float* o_fovy);
+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();

-uint64_t alloc_simple_shadow_pair_base();
 }  // namespace frame_interp
 }  // namespace dusk
 #endif
-
-#endif
@@ -0,0 +1,26 @@
+#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
@@ -0,0 +1,8 @@
+#pragma once
+
+#ifndef GAMEPAD_COLOR_H
+#define GAMEPAD_COLOR_H
+
+void handleGamepadColor();
+
+#endif
@@ -0,0 +1,18 @@
+#ifndef DUSK_GYRO_H
+#define DUSK_GYRO_H
+
+namespace dusk::gyro {
+void read(float dt);
+void getAimDeltas(float& out_yaw, float& out_pitch);
+bool queryGyroAimContext();
+
+void rollgoalTick(bool play_active, s16 camera_yaw);
+void rollgoalTableOffset(s16& out_ax, s16& out_az);
+
+extern bool s_sensor_keep_alive;
+bool get_sensor_keep_alive();
+void set_sensor_keep_alive(bool value);
+bool rollgoal_gyro_enabled();
+}  // namespace dusk::gyro
+
+#endif
@@ -1,10 +0,0 @@
-#ifndef DUSK_GYRO_AIM_H
-#define DUSK_GYRO_AIM_H
-
-namespace dusk::gyro_aim {
-void read(float dt, bool context_active);
-void consumeAimDeltas(float& out_yaw_rad, float& out_pitch_rad);
-bool queryGyroAimItemContext();
-}  // namespace dusk::gyro_aim
-
-#endif
@@ -14,7 +14,6 @@ constexpr const char* SHOW_DEBUG_OVERLAY = "F3";
 constexpr const char* SHOW_HEAP_VIEWER = "F4";
 constexpr const char* SHOW_PLAYER_INFO = "F5";
 constexpr const char* SHOW_SAVE_EDITOR = "F6";
-constexpr const char* SHOW_MAP_LOADER = "F7";
 constexpr const char* SHOW_STATE_SHARE = "F8";
 constexpr const char* SHOW_DEBUG_CAMERA = "F9";
 constexpr const char* SHOW_AUDIO_DEBUG = "F10";
@@ -1,6 +1,7 @@
 #ifndef DUSK_IO_HPP
 #define DUSK_IO_HPP

+#include <filesystem>
 #include <vector>

 // I can't believe it's 2026 and neither SDL (no error codes) nor
@@ -15,7 +16,7 @@ namespace dusk::io {
 * Methods on this class throw appropriate C++ exceptions when an error occurs.
 */
 class FileStream {
-    void* file;
+    FILE* file;

 public:
    FileStream() noexcept;
@@ -23,7 +24,7 @@ public:
    /**
     * \brief Take ownership of a FILE* handle.
     */
-    explicit FileStream(void* file);
+    explicit FileStream(FILE* file);
    FileStream(const FileStream& other) = delete;
    FileStream(FileStream&& other) noexcept;

@@ -34,6 +35,11 @@ public:
     */
    static FileStream OpenRead(const char* utf8Path);

+    /**
+     * \brief Open a file for reading at the given path.
+     */
+    static FileStream OpenRead(const std::filesystem::path& path);
+
    /**
     * \brief Create a file for writing.
     *
@@ -41,16 +47,33 @@ public:
     */
    static FileStream Create(const char* utf8Path);

+    /**
+     * \brief Create a file for writing.
+     *
+     * If there is an existing file, its contents are demolished.
+     */
+    static FileStream Create(const std::filesystem::path& path);
+
    /**
     * \brief Read the byte contents of a file directly into a vector.
     */
    static std::vector<u8> ReadAllBytes(const char* utf8Path);

+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static std::vector<u8> ReadAllBytes(const std::filesystem::path& path);
+
    /**
     * \brief Read the byte contents of a file directly into a vector.
     */
    static void WriteAllText(const char* utf8Path, std::string_view text);

+    /**
+     * \brief Read the byte contents of a file directly into a vector.
+     */
+    static void WriteAllText(const std::filesystem::path& path, std::string_view text);
+
    /**
     * \brief Read the remaining contents of the file directly into a vector.
     */
@@ -59,17 +82,24 @@ public:
    /**
     * Get direct access to the underlying FILE* handle.
     */
-    [[nodiscard]] void* GetFileHandle() const noexcept {
-        return file;
-    }
+    [[nodiscard]] void* GetFileHandle() const noexcept { return file; }

    /**
     * Write data to the file.
     */
    void Write(const char* data, size_t dataLen);
+
+    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
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstdint>
+
+namespace dusk::speedrun {
+void onGameFrame();
+uint64_t getFrameCount();
+void start();
+void reset();
+void connectLiveSplit(const char* host = "127.0.0.1", int port = 16834);
+void disconnectLiveSplit();
+bool consumeConnectedEvent();
+bool consumeDisconnectedEvent();
+void updateLiveSplit();
+void shutdown();
+}
@@ -4,10 +4,12 @@
 #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 char* configDir, AuroraLogLevel logLevel);
+    void InitializeFileLogging(const std::filesystem::path& configDir, AuroraLogLevel logLevel);
    void ShutdownFileLogging();
    const char* GetLogFilePath();
    void SendToStubLog(AuroraLogLevel level, const char* module, const char* message);
@@ -1,10 +1,26 @@
 #ifndef DUSK_MAIN_H
 #define DUSK_MAIN_H

+#include <filesystem>
+
 namespace dusk {
-    extern bool IsRunning;
-    extern bool IsShuttingDown;
-    extern bool IsGameLaunched;
-}
+
+extern bool IsRunning;
+extern bool IsShuttingDown;
+extern bool IsGameLaunched;
+extern bool RestartRequested;
+extern std::filesystem::path ConfigPath;
+extern std::filesystem::path CachePath;
+
+#if defined(__ANDROID__) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS) ||                           \
+    (defined(TARGET_OS_TV) && TARGET_OS_TV)
+inline constexpr bool SupportsProcessRestart = false;
+#else
+inline constexpr bool SupportsProcessRestart = true;
+#endif
+
+void RequestRestart() noexcept;
+
+}  // namespace dusk

 #endif  // DUSK_MAIN_H
@@ -1,5 +1,7 @@
 #pragma once

+#include <array>
+
 struct RoomEntry {
    u8 roomNo;
    std::vector<s16> roomPoints = {};
@@ -2,9 +2,6 @@
 #define _SRC_DUSK_MATH_H_

 #include <cmath>
-#include <array>
-#include <limits>
-#include <bit>

 #ifndef M_PI
 #define M_PI 3.14159265358979323846f
@@ -19,139 +16,6 @@ inline float i_cosf(float x) { return cos(x); }
 inline float i_tanf(float x) { return tan(x); }
 inline float i_acosf(float x) { return acos(x); }

-
-// frsqrte matching courtesy of Geotale, with reference to https://achurch.org/cpu-tests/ppc750cl.s
-
-struct BaseAndDec32 {
-    uint32_t base;
-    int32_t dec;
-};
-
-struct BaseAndDec64 {
-    uint64_t base;
-    int64_t dec;
-};
-
-union c32 {
-    constexpr c32(const float p) {
-        f = p;
-    }
-
-    constexpr c32(const uint32_t p) {
-        u = p;
-    }
-
-    uint32_t u;
-    float f;
-};
-
-union c64 {
-    constexpr c64(const double p) {
-        f = p;
-    }
-
-    constexpr c64(const uint64_t p) {
-        u = p;
-    }
-
-    uint64_t u;
-    double f;
-};
-
-static constexpr uint64_t EXPONENT_SHIFT_F64 = 52;
-static constexpr uint64_t MANTISSA_MASK_F64 = 0x000fffffffffffffULL;
-static constexpr uint64_t EXPONENT_MASK_F64 = 0x7ff0000000000000ULL;
-static constexpr uint64_t SIGN_MASK_F64 = 0x8000000000000000ULL;
-
-static constexpr std::array<BaseAndDec64, 32> RSQRTE_TABLE = {{
-        {0x69fa000000000ULL, -0x15a0000000LL},
-        {0x5f2e000000000ULL, -0x13cc000000LL},
-        {0x554a000000000ULL, -0x1234000000LL},
-        {0x4c30000000000ULL, -0x10d4000000LL},
-        {0x43c8000000000ULL, -0x0f9c000000LL},
-        {0x3bfc000000000ULL, -0x0e88000000LL},
-        {0x34b8000000000ULL, -0x0d94000000LL},
-        {0x2df0000000000ULL, -0x0cb8000000LL},
-        {0x2794000000000ULL, -0x0bf0000000LL},
-        {0x219c000000000ULL, -0x0b40000000LL},
-        {0x1bfc000000000ULL, -0x0aa0000000LL},
-        {0x16ae000000000ULL, -0x0a0c000000LL},
-        {0x11a8000000000ULL, -0x0984000000LL},
-        {0x0ce6000000000ULL, -0x090c000000LL},
-        {0x0862000000000ULL, -0x0898000000LL},
-        {0x0416000000000ULL, -0x082c000000LL},
-        {0xffe8000000000ULL, -0x1e90000000LL},
-        {0xf0a4000000000ULL, -0x1c00000000LL},
-        {0xe2a8000000000ULL, -0x19c0000000LL},
-        {0xd5c8000000000ULL, -0x17c8000000LL},
-        {0xc9e4000000000ULL, -0x1610000000LL},
-        {0xbedc000000000ULL, -0x1490000000LL},
-        {0xb498000000000ULL, -0x1330000000LL},
-        {0xab00000000000ULL, -0x11f8000000LL},
-        {0xa204000000000ULL, -0x10e8000000LL},
-        {0x9994000000000ULL, -0x0fe8000000LL},
-        {0x91a0000000000ULL, -0x0f08000000LL},
-        {0x8a1c000000000ULL, -0x0e38000000LL},
-        {0x8304000000000ULL, -0x0d78000000LL},
-        {0x7c48000000000ULL, -0x0cc8000000LL},
-        {0x75e4000000000ULL, -0x0c28000000LL},
-        {0x6fd0000000000ULL, -0x0b98000000LL},
-}};
-
-[[nodiscard]] static inline double frsqrte(const double val) {
-    c64 bits(val);
-
-    uint64_t mantissa = bits.u & MANTISSA_MASK_F64;
-    int64_t exponent = bits.u & EXPONENT_MASK_F64;
-    bool sign = (bits.u & SIGN_MASK_F64) != 0;
-
-    // Handle 0 case
-    if (mantissa == 0 && exponent == 0) {
-        return std::copysign(std::numeric_limits<double>::infinity(), bits.f);
-    }
-
-    // Handle NaN-like
-    if (exponent == EXPONENT_MASK_F64) {
-        if (mantissa == 0) {
-            return sign ? std::numeric_limits<double>::quiet_NaN() : 0.0;
-        }
-
-        return val;
-    }
-
-    // Handle negative inputs
-    if (sign) {
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-
-    if (exponent == 0) {
-        // Shift so one bit goes to where the exponent would be,
-        // then clear that bit to mimic a not-subnormal number!
-        // Aka, if there are 12 leading zeroes, shift left once
-        uint32_t shift = std::countl_zero(mantissa) - static_cast<uint32_t>(63 - EXPONENT_SHIFT_F64);
-
-        mantissa <<= shift;
-        mantissa &= MANTISSA_MASK_F64;
-        // The shift is subtracted by 1 because denormals by default
-        // are offset by 1 (exponent 0 doesn't have implied 1 bit)
-        exponent -= static_cast<int64_t>(shift - 1) << EXPONENT_SHIFT_F64;
-    }
-
-    // In reality this doesn't get the full exponent -- Only the least significant bit
-    // Only that's needed because square roots of higher exponent bits simply multiply the
-    // result by 2!!
-    uint32_t key = static_cast<uint32_t>((static_cast<uint64_t>(exponent) | mantissa) >> 37);
-    uint64_t new_exp =
-            (static_cast<uint64_t>((0xbfcLL << EXPONENT_SHIFT_F64) - exponent) >> 1) & EXPONENT_MASK_F64;
-
-    // Remove the bits relating to anything higher than the LSB of the exponent
-    const auto &entry = RSQRTE_TABLE[0x1f & (key >> 11)];
-
-    // The result is given by an estimate then an adjustment based on the original
-    // key that was computed
-    uint64_t new_mantissa = static_cast<uint64_t>(entry.base + entry.dec * static_cast<int64_t>(key & 0x7ff));
-
-    return c64(new_exp | new_mantissa).f;
-}
+#include <dolphin/ppc_math.h>

 #endif // _SRC_DUSK_MATH_H_
@@ -0,0 +1,20 @@
+#ifndef DUSK_SCOPE_GUARD_HPP
+#define DUSK_SCOPE_GUARD_HPP
+
+#include <functional>
+
+class SimpleScopeGuard {
+public:
+    // Store the function in the constructor
+    explicit SimpleScopeGuard(const std::function<void()>& func) : m_func(func) {}
+
+    // Run the function when the object goes out of scope
+    ~SimpleScopeGuard() {
+        if (m_func) m_func();
+    }
+
+private:
+    std::function<void()> m_func;
+};
+
+#endif //DUSK_SCOPE_GUARD_HPP
@@ -1,6 +1,8 @@
 #ifndef DUSK_CONFIG_H
 #define DUSK_CONFIG_H

+#include <array>
+
 #include "dusk/config_var.hpp"

 namespace dusk {
@@ -13,12 +15,49 @@ enum class BloomMode : int {
    Dusk = 2,
 };

+enum class GameLanguage : u8 {
+    English = OS_LANGUAGE_ENGLISH,
+    German = OS_LANGUAGE_GERMAN,
+    French = OS_LANGUAGE_FRENCH,
+    Spanish = OS_LANGUAGE_SPANISH,
+    Italian = OS_LANGUAGE_ITALIAN,
+};
+
+enum class DiscVerificationState : u8 {
+    Unknown = 0,
+    Success,
+    HashMismatch,
+};
+
+enum class GyroMode : u8 {
+    Sensor = 0,
+    Mouse = 1,
+};
+
 namespace config {
 template <>
 struct ConfigEnumRange<BloomMode> {
    static constexpr auto min = BloomMode::Off;
    static constexpr auto max = BloomMode::Dusk;
 };
+
+template <>
+struct ConfigEnumRange<GameLanguage> {
+    static constexpr auto min = GameLanguage::English;
+    static constexpr auto max = GameLanguage::Italian;
+};
+
+template <>
+struct ConfigEnumRange<DiscVerificationState> {
+    static constexpr auto min = DiscVerificationState::Unknown;
+    static constexpr auto max = DiscVerificationState::HashMismatch;
+};
+
+template <>
+struct ConfigEnumRange<GyroMode> {
+    static constexpr auto min = GyroMode::Sensor;
+    static constexpr auto max = GyroMode::Mouse;
+};
 }

 // Persistent user settings
@@ -31,6 +70,12 @@ struct UserSettings {
        ConfigVar<bool> enableFullscreen;
        ConfigVar<bool> enableVsync;
        ConfigVar<bool> lockAspectRatio;
+        ConfigVar<bool> enableFpsOverlay;
+        ConfigVar<int> fpsOverlayCorner;
+        ConfigVar<int> windowPositionX;
+        ConfigVar<int> windowPositionY;
+        ConfigVar<int> windowWidth;
+        ConfigVar<int> windowHeight;
    } video;

    struct {
@@ -41,15 +86,18 @@ struct UserSettings {
        ConfigVar<int> soundEffectsVolume;
        ConfigVar<int> fanfareVolume;
        ConfigVar<bool> enableReverb;
+        ConfigVar<bool> enableHrtf;
+        ConfigVar<bool> menuSounds;
    } audio;

    // Game settings

    struct {
+        ConfigVar<GameLanguage> language;
+
        // QoL
        ConfigVar<bool> enableQuickTransform;
        ConfigVar<bool> hideTvSettingsScreen;
-        ConfigVar<bool> skipWarningScreen;
        ConfigVar<bool> biggerWallets;
        ConfigVar<bool> noReturnRupees;
        ConfigVar<bool> disableRupeeCutscenes;
@@ -60,53 +108,112 @@ struct UserSettings {
        ConfigVar<bool> fastClimbing;
        ConfigVar<bool> noMissClimbing;
        ConfigVar<bool> fastTears;
+        ConfigVar<bool> no2ndFishForCat;
        ConfigVar<bool> instantSaves;
+        ConfigVar<bool> instantText;
        ConfigVar<bool> sunsSong;
+        ConfigVar<bool> autoSave;

        // Preferences
        ConfigVar<bool> enableMirrorMode;
-        ConfigVar<bool> invertCameraXAxis;
-        ConfigVar<bool> disableMainHUD;
+        ConfigVar<bool> minimalHUD;
+        ConfigVar<bool> pauseOnFocusLost;
+        ConfigVar<bool> enableLinkDollRotation;
+        ConfigVar<bool> enableAchievementToasts;
+        ConfigVar<bool> enableControllerToasts;
+        ConfigVar<bool> enableDiscordPresence;

        // Graphics
        ConfigVar<BloomMode> bloomMode;
        ConfigVar<float> bloomMultiplier;
-        ConfigVar<bool> enableWaterRefraction;
+        ConfigVar<bool> disableWaterRefraction;
+        ConfigVar<bool> enableTextureReplacements;
        ConfigVar<bool> enableFrameInterpolation;
+        ConfigVar<int> internalResolutionScale;
        ConfigVar<int> shadowResolutionMultiplier;
+        ConfigVar<bool> enableDepthOfField;
+        ConfigVar<bool> enableMapBackground;
+        ConfigVar<bool> disableCutscenePillarboxing;

        // Audio
        ConfigVar<bool> noLowHpSound;
        ConfigVar<bool> midnasLamentNonStop;

        // Input
+        ConfigVar<GyroMode> gyroMode;
        ConfigVar<bool> enableGyroAim;
-        ConfigVar<float> gyroAimSensitivityX;
-        ConfigVar<float> gyroAimSensitivityY;
-        ConfigVar<bool> gyroAimInvertPitch;
-        ConfigVar<bool> gyroAimInvertYaw;
+        ConfigVar<bool> enableGyroRollgoal;
+        ConfigVar<float> gyroSensitivityX;
+        ConfigVar<float> gyroSensitivityY;
+        ConfigVar<float> gyroSensitivityRollgoal;
+        ConfigVar<float> gyroSmoothing;
+        ConfigVar<float> gyroDeadband;
+        ConfigVar<bool> gyroInvertPitch;
+        ConfigVar<bool> gyroInvertYaw;
+        ConfigVar<bool> freeCamera;
+        ConfigVar<bool> invertCameraXAxis;
+        ConfigVar<bool> invertCameraYAxis;
+        ConfigVar<bool> invertFirstPersonXAxis;
+        ConfigVar<bool> invertFirstPersonYAxis;
+        ConfigVar<float> freeCameraSensitivity;
+        ConfigVar<bool> debugFlyCam;
+        ConfigVar<bool> debugFlyCamLockEvents;
+        ConfigVar<bool> allowBackgroundInput;

        // Cheats
+        ConfigVar<bool> infiniteHearts;
+        ConfigVar<bool> infiniteArrows;
+        ConfigVar<bool> infiniteSeeds;
+        ConfigVar<bool> infiniteBombs;
+        ConfigVar<bool> infiniteOil;
+        ConfigVar<bool> infiniteOxygen;
+        ConfigVar<bool> infiniteRupees;
+        ConfigVar<bool> enableIndefiniteItemDrops;
+        ConfigVar<bool> moonJump;
+        ConfigVar<bool> superClawshot;
+        ConfigVar<bool> alwaysGreatspin;
        ConfigVar<bool> enableFastIronBoots;
        ConfigVar<bool> canTransformAnywhere;
+        ConfigVar<bool> fastRoll;
        ConfigVar<bool> fastSpinner;
        ConfigVar<bool> freeMagicArmor;
+        ConfigVar<bool> invincibleEnemies;

        // Technical
        ConfigVar<bool> restoreWiiGlitches;

        // Controls
        ConfigVar<bool> enableTurboKeybind;
+        ConfigVar<bool> enableResetKeybind;
+
+        // Tools
+        ConfigVar<bool> speedrunMode;
+        ConfigVar<bool> liveSplitEnabled;
+        ConfigVar<bool> showSpeedrunRTATimer;
+        ConfigVar<bool> recordingMode;
+        ConfigVar<bool> showInputViewer;
+        ConfigVar<bool> showInputViewerGyro;
    } game;

    struct {
        ConfigVar<std::string> isoPath;
+        ConfigVar<DiscVerificationState> isoVerification;
        ConfigVar<std::string> graphicsBackend;
        ConfigVar<bool> skipPreLaunchUI;
        ConfigVar<bool> showPipelineCompilation;
        ConfigVar<bool> wasPresetChosen;
-        ConfigVar<bool> enableCrashReporting;
+        ConfigVar<bool> checkForUpdates;
+        ConfigVar<int> cardFileType;
+        ConfigVar<bool> enableAdvancedSettings;
    } backend;
+
+    // Arrays of size 4 for 4 ports
+    struct {
+        std::array<ActionBindConfigVar, 4> firstPersonCamera;
+        std::array<ActionBindConfigVar, 4> callMidna;
+        std::array<ActionBindConfigVar, 4> openDusklightMenu;
+        std::array<ActionBindConfigVar, 4> turboSpeedButton;
+    } actionBindings;
 };

 UserSettings& getSettings();
@@ -130,6 +237,7 @@ struct TransientSettings {
    CollisionViewSettings collisionView;
    bool skipFrameRateLimit;
    bool moveLinkActive;
+    bool stateShareLoadActive;
 };

 TransientSettings& getTransientSettings();
@@ -0,0 +1,41 @@
+#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
@@ -1,9 +1,10 @@
 #ifndef DUSK_TIME_H
 #define DUSK_TIME_H

-#include <chrono>
-#include <numeric>
 #include <array>
+#include <numeric>
+
+#include "SDL3/SDL_timer.h"

 #ifdef _WIN32
 #ifndef WIN32_LEAN_AND_MEAN
@@ -15,28 +16,26 @@
 #include <Windows.h>
 #include <shellapi.h>
 #include <intrin.h>
-#else
-#include "SDL3/SDL_timer.h"
 #endif

 class Limiter {
-  using delta_clock = std::chrono::high_resolution_clock;
-  using duration_t = std::chrono::nanoseconds;
-
 public:
-  void Reset() { m_oldTime = delta_clock::now(); }
+  using duration_t = Uint64;
+
+  void Reset() { m_oldTime = SDL_GetTicksNS(); }

  void Sleep(duration_t targetFrameTime) {
-    if (targetFrameTime.count() == 0) {
+    if (targetFrameTime == 0) {
      return;
    }

-    auto start = delta_clock::now();
+    const Uint64 start = SDL_GetTicksNS();
    duration_t adjustedSleepTime = SleepTime(targetFrameTime);
-    if (adjustedSleepTime.count() > 0) {
+    if (adjustedSleepTime > 0) {
      NanoSleep(adjustedSleepTime);
-      duration_t overslept = TimeSince(start) - adjustedSleepTime;
-      if (overslept < duration_t{targetFrameTime}) {
+      const duration_t elapsed = TimeSince(start);
+      const duration_t overslept = elapsed > adjustedSleepTime ? elapsed - adjustedSleepTime : 0;
+      if (overslept < targetFrameTime) {
        m_overheadTimes[m_overheadTimeIdx] = overslept;
        m_overheadTimeIdx = (m_overheadTimeIdx + 1) % m_overheadTimes.size();
      }
@@ -45,23 +44,23 @@ public:
  }

  duration_t SleepTime(duration_t targetFrameTime) {
-    const auto sleepTime = duration_t{targetFrameTime} - TimeSince(m_oldTime);
-    m_overhead = std::accumulate(m_overheadTimes.begin(), m_overheadTimes.end(), duration_t{}) / m_overheadTimes.size();
+    const duration_t elapsed = TimeSince(m_oldTime);
+    const duration_t sleepTime = elapsed < targetFrameTime ? targetFrameTime - elapsed : 0;
+    m_overhead = std::accumulate(m_overheadTimes.begin(), m_overheadTimes.end(), duration_t{0}) /
+                 m_overheadTimes.size();
    if (sleepTime > m_overhead) {
      return sleepTime - m_overhead;
    }
-    return duration_t{0};
+    return 0;
  }

 private:
-  delta_clock::time_point m_oldTime;
+  Uint64 m_oldTime = 0;
  std::array<duration_t, 4> m_overheadTimes{};
  size_t m_overheadTimeIdx = 0;
-  duration_t m_overhead = duration_t{0};
+  duration_t m_overhead = 0;

-  duration_t TimeSince(delta_clock::time_point start) {
-    return std::chrono::duration_cast<duration_t>(delta_clock::now() - start);
-  }
+  duration_t TimeSince(Uint64 start) const { return SDL_GetTicksNS() - start; }

 #if _WIN32
  void NanoSleep(const duration_t duration) {
@@ -85,9 +84,10 @@ private:

    LARGE_INTEGER start, current;
    QueryPerformanceCounter(&start);
-    LONGLONG ticksToWait = static_cast<LONGLONG>(duration.count() * countPerNs);
-    if (DWORD ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count(); ms > 1) {
-      ::Sleep(ms - 1);
+    const LONGLONG ticksToWait = static_cast<LONGLONG>(duration * countPerNs);
+    const Uint64 ms = duration / 1'000'000ULL;
+    if (ms > 1) {
+      ::Sleep(static_cast<DWORD>(ms - 1));
    }
    do {
      QueryPerformanceCounter(&current);
@@ -99,7 +99,7 @@ private:
    } while (current.QuadPart - start.QuadPart < ticksToWait);
  }
 #else
-  void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration.count()); }
+  void NanoSleep(const duration_t duration) { SDL_DelayPrecise(duration); }
 #endif
 };

@@ -0,0 +1,67 @@
+#ifndef DUSK_VERSION_HPP
+#define DUSK_VERSION_HPP
+
+/**
+ * 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,
+    };
+
+    bool isGcn();
+    bool isWii();
+    bool isPalOrAtLeastWiiR2();
+
+    bool isRegionPal();
+    bool isRegionJpn();
+    bool isRegionUsa();
+
+    GameVersion getGameVersion();
+
+    const DVDDiskID& getDiskID();
+
+    void init();
+
+    template<typename T>
+    struct VersionOption {
+        GameVersion mVersion;
+        T mValue;
+
+        constexpr VersionOption(GameVersion version, T value) : mVersion(version), mValue(value) {}
+    };
+
+    template<typename T>
+    const T& versionSelect(const std::initializer_list<VersionOption<T>> options) {
+        const auto version = getGameVersion();
+        for (const auto& opt : options) {
+            if (opt.mVersion == version) {
+                return opt.mValue;
+            }
+        }
+
+        // Unable to find value.
+        abort();
+    }
+
+    template<typename T>
+    const T& versionSelect(const std::initializer_list<VersionOption<T>> options, const T& defaultValue) {
+        const auto version = getGameVersion();
+        for (const auto& opt : options) {
+            if (opt.mVersion == version) {
+                return opt.mValue;
+            }
+        }
+
+        return defaultValue;
+    }
+}  // namespace dusk::version
+
+#endif  // DUSK_VERSION_HPP
@@ -108,7 +108,7 @@ struct fopAcM_search_prm {
 struct fOpAcm_HIO_entry_c : public mDoHIO_entry_c {
    virtual ~fOpAcm_HIO_entry_c() {}

-    #if DEBUG
+    #if DEBUG && !TARGET_PC
    void removeHIO(const fopAc_ac_c* i_this) { removeHIO(*i_this); }
    void removeHIO(const fopAc_ac_c& i_this) { removeHIO(i_this.base); }
    void removeHIO(const fopEn_enemy_c& i_this) { removeHIO(i_this.base); }
@@ -25,7 +25,7 @@ typedef struct leafdraw_class : base_process_class {
 #endif
    /* 0xB8 */ leafdraw_method_class* leaf_methods;
    /* 0xBC */ s8 unk_0xBC;
-    /* 0xBD */ u8 unk_0xBD;
+    /* 0xBD */ u8 draw_interp_frame;
    /* 0xBE */ draw_priority_class draw_priority;
 } leafdraw_class;

@@ -18,6 +18,7 @@ typedef struct process_node_class {
    /* 0x0BC */ layer_class layer;
    /* 0x0E8 */ node_list_class layer_nodelist[16];
    /* 0x1A8 */ s8 unk_0x1A8;
+    /* 0x1A9 */ s8 draw_interp_frame;
 } process_node_class;

 typedef struct node_process_profile_definition {
@@ -73,6 +73,9 @@
 #endif

 #ifndef __MWERKS__
+#ifdef __cplusplus
+extern "C" {
+#endif
 // Silence clangd errors about MWCC PPC intrinsics by declaring them here.
 extern int __cntlzw(unsigned int);
 extern int __rlwimi(int, int, int, int, int);
@@ -80,7 +83,14 @@ extern void __dcbf(void*, int);
 extern void __dcbz(void*, int);
 extern void __sync();
 extern int __abs(int);
-void* __memcpy(void*, const void*, int);
+#if defined(__has_builtin) && __has_builtin(__builtin_memcpy)
+#define __memcpy __builtin_memcpy
+#else
+#define __memcpy memcpy
+#endif
+#ifdef __cplusplus
+}
+#endif
 #endif

 #ifndef M_PI
@@ -220,12 +230,16 @@ using std::isnan;
 // Some basic macros that are more convenient than putting down #if blocks for one-line changes.
 #if TARGET_PC
 #define IF_DUSK(statement) statement
+#define IF_DUSK_BLOCK(cond) if (cond) {
+#define IF_DUSK_BLOCK_END }
 #define IF_DUSK_ARG(expr) , expr
 #define IF_NOT_DUSK(statement)
 #define DUSK_IF_ELSE(dusk, orig) dusk
 #else
 #define IF_DUSK(statement)
 #define IF_DUSK_ARG(expr)
+#define IF_DUSK_BLOCK(cond)
+#define IF_DUSK_BLOCK_END
 #define IF_NOT_DUSK(statement) statement
 #define DUSK_IF_ELSE(dusk, orig) orig
 #endif
@@ -5,6 +5,7 @@
 #include "Z2AudioLib/Z2EnvSeMgr.h"
 #include "Z2AudioLib/Z2LinkMgr.h"
 #include "dusk/audio.h"
+#include "dusk/settings.h"

 class mDoAud_zelAudio_c : public Z2AudioMgr {
 public:
@@ -132,6 +133,18 @@ inline void mDoAud_seStart(u32 i_sfxID, const Vec* i_sePos, u32 param_2, s8 i_re
                                               -1.0f, -1.0f, 0);
 }

+#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);
+}
+#endif
+
 inline void mDoAud_seStartLevel(u32 i_sfxID, const Vec* i_sePos, u32 param_2, s8 i_reverb) {
    DUSK_AUDIO_SKIP()
    Z2AudioMgr::getInterface()->seStartLevel(i_sfxID, i_sePos, param_2, i_reverb, 1.0f, 1.0f,
@@ -125,8 +125,15 @@ public:
 #if TARGET_PC
    static f32 hudAspectScaleDown;
    static f32 hudAspectScaleUp;
-    static f32 ScaleHUDXLeft(f32 baseX) { return getMinXF() + baseX; }
-    static f32 ScaleHUDXRight(f32 baseX) { return -getMinXF() + baseX; }
+    static void updateSafeAreaBounds();
+    static f32 getSafeMinXF() { return m_safeMinXF; }
+    static f32 getSafeMinYF() { return m_safeMinYF; }
+    static f32 getSafeWidthF() { return m_safeWidthF; }
+    static f32 getSafeHeightF() { return m_safeHeightF; }
+    static f32 getSafeMaxXF() { return m_safeMaxXF; }
+    static f32 getSafeMaxYF() { return m_safeMaxYF; }
+    static f32 ScaleHUDXLeft(f32 baseX) { return getSafeMinXF() + baseX; }
+    static f32 ScaleHUDXRight(f32 baseX) { return getSafeMaxXF() - FB_WIDTH_BASE + baseX; }
 #endif

    static void setBlureMtx(const Mtx m) {
@@ -279,12 +286,7 @@ public:
    #if WIDESCREEN_SUPPORT
    static void setTvSize();

-    #if TARGET_PC
-    static void onWide(f32 width, f32 height);
-    #else
    static void onWide();
-    #endif
-
    static void offWide();
    static u8 isWide();

@@ -297,7 +299,7 @@ public:
    #endif

    #if TARGET_PC
-    static void setWindowSize(AuroraWindowSize const& size);
+    static void updateRenderSize();
    #endif

    static TGXTexObj mFrameBufferTexObj;
@@ -369,6 +371,15 @@ public:
    static int m_height;
    static f32 m_heightF;
    static 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;
+    #endif
    #endif
 };

@@ -43,10 +43,6 @@ struct mDoLib_clipper {
 };

 void mDoLib_project(Vec* src, Vec* dst);
-#if TARGET_PC
-void mDoLib_project(Vec* src, Vec* dst, JGeometry::TBox2<f32> viewport);
-#endif
-
 u32 mDoLib_setResTimgObj(ResTIMG const* res, TGXTexObj* o_texObj, u32 tlut_name,
                          GXTlutObj* o_tlutObj);
 void mDoLib_pos2camera(Vec* src, Vec* dst);
@@ -79,6 +79,10 @@ public:
    virtual void viewCalc();
    virtual ~J3DModel() {}

+#if TARGET_PC
+    static void interp_callback(bool isSimFrame, void* pUserWork);
+#endif
+
    J3DModelData* getModelData() { return mModelData; }

    void onFlag(u32 flag) { mFlags |= flag; }
@@ -105,9 +109,7 @@ public:
    void setAnmMtx(int jointNo, Mtx m) {
        mMtxBuffer->setAnmMtx(jointNo, m);
 #ifdef TARGET_PC
-        dusk::frame_interp::record_final_mtx_raw(
-            reinterpret_cast<const Mtx*>(mMtxBuffer->getAnmMtx(jointNo)),
-            mMtxBuffer->getAnmMtx(jointNo));
+        dusk::frame_interp::record_final_mtx(mMtxBuffer->getAnmMtx(jointNo));
 #endif
    }
    MtxP getAnmMtx(int jointNo) { return mMtxBuffer->getAnmMtx(jointNo); }
@@ -23,6 +23,10 @@ public:
    void syncJ3DSysPointers() const;
    void syncJ3DSysFlags() const;

+#if TARGET_PC
+    bool needsInterpCallBack() const;
+#endif
+
    virtual ~J3DModelData() {}

    void simpleCalcMaterial(Mtx mtx) { simpleCalcMaterial(0, mtx); }
@@ -33,6 +33,9 @@ public:
    void copy(J3DMaterial*);
    s32 newSharedDisplayList(u32);
    s32 newSingleSharedDisplayList(u32);
+#if TARGET_PC
+    bool needsInterpCallBack() const;
+#endif

    virtual void calc(f32 const (*)[4]);
    virtual void calcDiffTexMtx(f32 const (*)[4]);
@@ -46,7 +49,6 @@ public:
    virtual void change();

    J3DMaterial() { initialize(); }
-    ~J3DMaterial() {}
    J3DMaterial* getNext() { return mNext; }
    J3DShape* getShape() { return mShape; }
    J3DTevBlock* getTevBlock() { return mTevBlock; }
@@ -1,9 +1,9 @@
 #ifndef J3DSTRUCT_H
 #define J3DSTRUCT_H

+#include <cstring>
 #include <gx.h>
 #include <mtx.h>
-#include <mtx.h>
 #include "global.h"
 #include "JSystem/JMath/JMath.h"

@@ -11,7 +11,7 @@

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DLightInfo {
    bool operator==(J3DLightInfo& other) const;
@@ -28,7 +28,7 @@ struct J3DLightInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTextureSRTInfo {
    // NOTE: Big endian when loaded from file!
@@ -79,7 +79,7 @@ enum J3DTexMtxMode {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTexMtxInfo {
    bool operator==(J3DTexMtxInfo& other) const;
@@ -97,7 +97,7 @@ struct J3DTexMtxInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DIndTexMtxInfo {
    J3DIndTexMtxInfo& operator=(J3DIndTexMtxInfo const&);
@@ -107,7 +107,7 @@ struct J3DIndTexMtxInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DFogInfo {
    bool operator==(J3DFogInfo&) const;
@@ -126,7 +126,7 @@ struct J3DFogInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DNBTScaleInfo {
    bool operator==(const J3DNBTScaleInfo& other) const;
@@ -153,7 +153,7 @@ struct J3DIndTexOrderInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevSwapModeInfo {
    /* 0x0 */ u8 mRasSel;
@@ -164,7 +164,7 @@ struct J3DTevSwapModeInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevSwapModeTableInfo {
    /* 0x0 */ u8 field_0x0;
@@ -175,7 +175,7 @@ struct J3DTevSwapModeTableInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevStageInfo {
    /* 0x0 */ u8 field_0x0;
@@ -202,7 +202,7 @@ struct J3DTevStageInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DIndTevStageInfo {
    /* 0x0 */ u8 mIndStage;
@@ -219,7 +219,7 @@ struct J3DIndTevStageInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTexCoordInfo {
    /* 0x0 */ u8 mTexGenType;
@@ -265,7 +265,7 @@ struct J3DBlendInfo {

 /**
 * @ingroup jsystem-j3d
- * 
+ *
 */
 struct J3DTevOrderInfo {
    void operator=(const J3DTevOrderInfo& other) {
@@ -59,6 +59,9 @@ public:
    bool isActive() const { return mSeqList.getNumLinks() != 0; }
    int getNumActiveSeqs() const { return mSeqList.getNumLinks(); }
    void pause(bool paused) { mActivity.field_0x0.flags.flag2 = paused; }
+    #if TARGET_PC
+    JSUList<JAISeq>* getSeqList() { return &mSeqList; }
+    #endif

 private:
    /* 0x08 */ JAIAudience* mAudience;
@@ -101,10 +101,6 @@ public:

    void setDrawDoneMethod(EDrawDone drawDone) { mDrawDoneMethod = drawDone; }
    void setFader(JUTFader* fader) { mFader = fader; }
-#ifdef TARGET_PC
-    // For frame interpolation
-    void setFaderSimSteps(u32 steps);
-#endif
    void resetFader() { setFader(NULL); }
    JUTFader* getFader() const { return mFader; }
    void setClearColor(JUtility::TColor color) { mClearColor = color; }
@@ -207,4 +207,11 @@ void JPARegistAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*);
 void JPARegistPrmAlpha(JPAEmitterWorkData*, JPABaseParticle*);
 void JPARegistPrmAlphaEnv(JPAEmitterWorkData*, JPABaseParticle*);

+#if TARGET_PC
+void JPAInterpBillboard(JPAEmitterWorkData*, JPABaseParticle*);
+void JPAInterpRotBillboard(JPAEmitterWorkData*, JPABaseParticle*);
+void JPAInterpDirection(JPAEmitterWorkData*, JPABaseParticle*);
+void JPAInterpRotDirection(JPAEmitterWorkData*, JPABaseParticle*);
+#endif
+
 #endif /* JPABASESHAPE_H */
@@ -24,6 +24,9 @@ public:
    void init_c(JPAEmitterWorkData*, JPABaseParticle*);
    bool calc_p(JPAEmitterWorkData*);
    bool calc_c(JPAEmitterWorkData*);
+#if TARGET_PC
+    void interp(JPAEmitterWorkData*, void const* drawFunc);
+#endif
    bool canCreateChild(JPAEmitterWorkData*);
    f32 getWidth(JPABaseEmitter const*) const;
    f32 getHeight(JPABaseEmitter const*) const;
@@ -11,8 +11,10 @@
 class JUTFader {
 public:
    enum EStatus {
-        UNKSTATUS_M1 = -1,
-        UNKSTATUS_0 = 0,
+        None,
+        Wait,
+        FadeIn,
+        FadeOut,
    };

    JUTFader(int, int, int, int, JUtility::TColor);
@@ -29,12 +31,12 @@ public:
    void setColor(JUtility::TColor color) { mColor.set(color); }

    /* 0x04 */ s32 mStatus;
-    /* 0x08 */ u16 field_0x8;
-    /* 0x0A */ u16 field_0xa;
+    /* 0x08 */ u16 mDuration;
+    /* 0x0A */ u16 mTimer;
    /* 0x0C */ JUtility::TColor mColor;
    /* 0x10 */ JGeometry::TBox2<f32> mBox;
-    /* 0x20 */ int mEStatus;
-    /* 0x24 */ u32 field_0x24;
+    /* 0x20 */ int mStatusTimer;
+    /* 0x24 */ u32 mNextStatus;
 };

 #endif /* JUTFADER_H */
@@ -263,6 +263,9 @@ public:
    /* 0x9C */ u8 field_0x9c[4];
    /* 0xA0 */ OSTime mResetHoldStartTime;
    /* 0xA8 */ u8 field_0xa8;
+#if TARGET_PC
+    u32 mResetHoldFrameCount;
+#endif
 };

 /**
@@ -40,6 +40,9 @@ public:
    JUTTransparency getTransparency() const { return JUTTransparency(mTransparency); }
    u16 getNumColors() const { return mNumColors; }
    ResTLUT* getColorTable() const { return mColorTable; }
+#if TARGET_PC
+    void dataUploaded();
+#endif

 private:
    /* 0x00 */ GXTlutObj mTlutObj;
@@ -75,6 +75,7 @@ public:
    s32 getTransparency() const { return mTexInfo->alphaEnabled; }
    s32 getWidth() const { return mTexInfo->width; }
    s32 getHeight() const { return mTexInfo->height; }
+    JUTPalette* getPalette() const { return mPalette; }
    void setCaptureFlag(bool flag) { mFlags &= 2 | flag; }
    bool getCaptureFlag() const { return mFlags & 1; }
    bool getEmbPaletteDelFlag() const { return mFlags & 2; }
@@ -82,7 +83,7 @@ public:
    int getTlutName() const { return mTlutName; }
    bool operator==(const JUTTexture& other) {
        return mTexInfo == other.mTexInfo
-            && field_0x2c == other.field_0x2c
+            && mPalette == other.mPalette
            && mWrapS == other.mWrapS
            && mWrapT == other.mWrapT
            && mMinFilter == other.mMinFilter
@@ -100,7 +101,7 @@ private:
    /* 0x20 */ const ResTIMG* mTexInfo;
    /* 0x24 */ void* mTexData;
    /* 0x28 */ JUTPalette* mEmbPalette;
-    /* 0x2C */ JUTPalette* field_0x2c;
+    /* 0x2C */ JUTPalette* mPalette;
    /* 0x30 */ u8 mWrapS;
    /* 0x31 */ u8 mWrapT;
    /* 0x32 */ u8 mMinFilter;
--- a/Show More
+++ b/Show More