Invert First Person Aiming (#870 )

- Inverts first person aiming on either axis, for both stick and gyro controls Could be separated from gyro if desirable, but I think it makes the most sense to have it apply to both
fix going into first person with orbital cam (#923 )
2026-07-05 19:43:41 -04:00 · 2026-05-10 19:00:20 -06:00 · 2026-05-10 19:00:09 -06:00 · 2026-05-10 18:42:31 -06:00 · 2026-05-10 18:37:22 -06:00 · 2026-05-10 17:35:29 -06:00
48 changed files with 1439 additions and 214 deletions
@@ -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
@@ -67,7 +65,6 @@ jobs:
        run: ci/build-appimage.sh

      - name: Upload artifacts
-        if: startsWith(github.event.ref, 'refs/tags/v')
        uses: actions/upload-artifact@v7
        with:
          name: dusk-${{env.DUSK_VERSION}}-linux-${{matrix.preset}}-${{matrix.artifact_arch}}
@@ -77,7 +74,7 @@ jobs:

  build-apple:
    name: Build Apple (${{matrix.name}})
-    runs-on: [self-hosted, macOS]
+    runs-on: macos-latest
    strategy:
      fail-fast: false
      matrix:
@@ -86,14 +83,14 @@ jobs:
            platform: macos
            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 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
@@ -106,7 +103,6 @@ jobs:
          submodules: recursive

      - name: Install dependencies
-        if: 'false'
        run: brew install cmake ninja

      - name: Install Rust iOS target
@@ -128,7 +124,7 @@ jobs:
          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}}
@@ -137,7 +133,6 @@ jobs:
        run: cmake --build --preset ${{matrix.preset}}

      - name: Upload artifacts
-        if: startsWith(github.event.ref, 'refs/tags/v')
        uses: actions/upload-artifact@v7
        with:
          name: dusk-${{env.DUSK_VERSION}}-${{matrix.artifact_name}}
@@ -145,6 +140,73 @@ jobs:
            build/install/Dusk.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 dusk
+
+      - 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: dusk-${{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}}
@@ -154,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
@@ -191,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
@@ -203,7 +264,6 @@ jobs:
        run: cmake --build --preset x-windows-ci-${{matrix.preset}}

      - name: Upload artifacts
-        if: startsWith(github.event.ref, 'refs/tags/v')
        uses: actions/upload-artifact@v7
        with:
          name: dusk-${{env.DUSK_VERSION}}-win32-msvc-${{matrix.artifact_arch}}
@@ -121,6 +121,16 @@ option(DUSK_ENABLE_SENTRY_NATIVE "Enable sentry-native crash reporting support"
 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)
@@ -150,6 +160,7 @@ if (DUSK_MOVIE_SUPPORT)
            CMAKE_C_COMPILER_LAUNCHER
            CMAKE_MAKE_PROGRAM
            CMAKE_MSVC_RUNTIME_LIBRARY
+            CMAKE_MSVC_DEBUG_INFORMATION_FORMAT
            CMAKE_OSX_ARCHITECTURES
            DEPLOYMENT_TARGET
            ENABLE_ARC
@@ -366,16 +377,6 @@ if (DUSK_ENABLE_DISCORD AND NOT ANDROID AND NOT IOS AND NOT TVOS)
    list(APPEND GAME_COMPILE_DEFS DUSK_DISCORD=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 ()
-endif ()
-
 if(ANDROID)
    list(APPEND GAME_COMPILE_DEFS TARGET_ANDROID=1)
 endif ()
@@ -443,6 +444,12 @@ target_link_libraries(dusk PRIVATE aurora::main ${GAME_LIBS} ${JSYSTEM_LINK_LIBR
 target_precompile_headers(dusk PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:${CMAKE_SOURCE_DIR}/include/dusk_pch.hpp>")
 if (TARGET crashpad_handler)
    add_dependencies(dusk crashpad_handler)
+    add_custom_command(TARGET dusk POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "$<TARGET_FILE:crashpad_handler>"
+            "$<TARGET_FILE_DIR:dusk>"
+        COMMENT "Copying crashpad handler"
+    )
 endif ()

 if (ANDROID)
@@ -30,7 +30,7 @@
        "CMAKE_CXX_COMPILER_LAUNCHER": "sccache",
        "DUSK_ENABLE_SENTRY_NATIVE": {
          "type": "BOOL",
-          "value": false
+          "value": true
        },
        "DUSK_SENTRY_DSN": "$env{SENTRY_DSN}",
        "DUSK_SENTRY_ENVIRONMENT": "production"
@@ -352,6 +352,31 @@
        "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,
@@ -412,6 +437,7 @@
        "x-macos-ci"
      ],
      "cacheVariables": {
+        "AURORA_DAWN_PROVIDER": "vendor",
        "CMAKE_OSX_ARCHITECTURES": "x86_64",
        "Rust_CARGO_TARGET": "x86_64-apple-darwin"
      }
@@ -555,6 +581,15 @@
        "dusk"
      ]
    },
+    {
+      "name": "x-android-ci-arm64",
+      "configurePreset": "x-android-ci-arm64",
+      "description": "(Internal) Android CI arm64-v8a",
+      "displayName": "(Internal) Android CI arm64-v8a",
+      "targets": [
+        "dusk"
+      ]
+    },
    {
      "name": "windows-msvc-debug",
      "configurePreset": "windows-msvc-debug",
@@ -19,6 +19,9 @@ It aims to be as accurate as possible to the original while also providing new o
 > [!IMPORTANT]
 > Dusk does *not* provide any copyrighted assets. You must provide your own copy of the original game.

+> [!IMPORTANT]
+> At a minimum, Dusk 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 likelyhood of incompatibility. We are also aware of a number of issues on devices with Adreno GPUs and are working to resolve them.
+
 ### 1. Verify your dump

 First, make sure your dump of the game is clean and supported by Dusk. You can do this by checking the SHA-1 hash of your dump against this list of supported versions:
@@ -52,7 +55,7 @@ First, make sure your dump of the game is clean and supported by Dusk. You can d

 If you'd like to build Dusk from source, please read the [build instructions](docs/building.md).

-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.
+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

@@ -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

 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
@@ -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.  
@@ -1450,6 +1450,7 @@ set(DUSK_FILES
        src/dusk/imgui/ImGuiBloomWindow.hpp
        src/dusk/imgui/ImGuiMenuTools.cpp
        src/dusk/imgui/ImGuiMenuTools.hpp
+        src/dusk/imgui/ImGuiActorSpawner.cpp
        src/dusk/imgui/ImGuiProcessOverlay.cpp
        src/dusk/imgui/ImGuiCameraOverlay.cpp
        src/dusk/imgui/ImGuiHeapOverlay.cpp
@@ -1494,6 +1495,8 @@ set(DUSK_FILES
        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
@@ -5,9 +5,73 @@
  outputs = { self, nixpkgs }:
    let
      pkgs = import nixpkgs { system = "x86_64-linux"; };
+      
+      # Dependencies that are not packaged in nixpkgs:
+      aurora-src = pkgs.fetchFromGitHub {
+        owner = "encounter";
+        repo = "aurora";
+        rev = "63606a43265a3bc18dafd500ab4d7a2108f109e6";
+        hash = "sha256-xBvnAwGwNzav67Ac6oUz7RqDUwqgL2bsME3OOMn8Tqw=";
+      };
+      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=";
+      };
+      # Dusk Actual
      dusk = pkgs.stdenv.mkDerivation {
        name = "dusk";
        src = ./.;
+        postUnpack = ''
+          mkdir -p $sourceRoot/extern/aurora
+          cp -r ${aurora-src}/. $sourceRoot/extern/aurora/
+          chmod -R u+w $sourceRoot/extern/aurora
+          sed -i '/add_subdirectory(tests)/d' $sourceRoot/extern/aurora/CMakeLists.txt
+        '';
+        # Remove last line to re-enable tests
+        cmakeFlags = [
+          "-DFETCHCONTENT_FULLY_DISCONNECTED=ON"
+          "-DFETCHCONTENT_SOURCE_DIR_CXXOPTS=${pkgs.cxxopts.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_JSON=${pkgs.nlohmann_json.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_DAWN_PREBUILT=${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=${nod-src}"
+          "-DAURORA_NOD_PROVIDER=package"
+          "-DFETCHCONTENT_SOURCE_DIR_FREETYPE=${pkgs.freetype.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_ZSTD=${pkgs.zstd.src}"
+          "-DFETCHCONTENT_SOURCE_DIR_SQLITE3=${sqlite-src}"
+          "-DFETCHCONTENT_SOURCE_DIR_IMGUI=${imgui-src}"
+          "-DFETCHCONTENT_SOURCE_DIR_RMLUI=${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 dusk $out/bin/dusk
+          cp -r ./res $out/bin/res
+        '';
        nativeBuildInputs = [
          pkgs.cmake
          pkgs.pkg-config
@@ -25,6 +89,13 @@
          pkgs.libjpeg8
          pkgs.libxkbcommon
          pkgs.libglvnd
+          pkgs.cxxopts
+          pkgs.abseil-cpp
+          pkgs.sdl3
+          pkgs.fmt
+          pkgs.tracy
+          pkgs.freetype
+          pkgs.zstd
        ];
      };
    in {
@@ -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
@@ -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
@@ -7,6 +7,14 @@

 #include <filesystem>

+#if defined(_WIN32) ||                                                                             \
+    (defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_TV && !TARGET_OS_MACCATALYST) ||           \
+    (defined(__linux__) && !defined(__ANDROID__))
+#define DUSK_CAN_OPEN_DATA_FOLDER 1
+#else
+#define DUSK_CAN_OPEN_DATA_FOLDER 0
+#endif
+
 namespace dusk {
    extern bool IsRunning;
    extern bool IsShuttingDown;
@@ -22,6 +30,7 @@ namespace dusk {
 #endif

    void RequestRestart() noexcept;
+    bool OpenDataFolder();
 }

 #endif  // DUSK_MAIN_H
@@ -144,6 +144,8 @@ struct UserSettings {
        ConfigVar<bool> freeCamera;
        ConfigVar<bool> invertCameraXAxis;
        ConfigVar<bool> invertCameraYAxis;
+        ConfigVar<bool> invertFirstPersonXAxis;
+        ConfigVar<bool> invertFirstPersonYAxis;
        ConfigVar<float> freeCameraSensitivity;
        ConfigVar<bool> debugFlyCam;
        ConfigVar<bool> debugFlyCamLockEvents;
@@ -184,7 +186,6 @@ struct UserSettings {
        ConfigVar<bool> skipPreLaunchUI;
        ConfigVar<bool> showPipelineCompilation;
        ConfigVar<bool> wasPresetChosen;
-        ConfigVar<bool> enableCrashReporting;
        ConfigVar<bool> checkForUpdates;
        ConfigVar<int> cardFileType;
        ConfigVar<bool> enableAdvancedSettings;
@@ -24,6 +24,17 @@
        <meta-data android:name="android.game_mode_config"
            android:resource="@xml/game_mode_config" />

+        <provider
+            android:name="dev.twilitrealm.dusk.DuskDocumentsProvider"
+            android:authorities="dev.twilitrealm.dusk.documents"
+            android:exported="true"
+            android:grantUriPermissions="true"
+            android:permission="android.permission.MANAGE_DOCUMENTS">
+            <intent-filter>
+                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
+            </intent-filter>
+        </provider>
+
        <activity
            android:name="dev.twilitrealm.dusk.DuskActivity"
            android:alwaysRetainTaskState="true"
@@ -0,0 +1,413 @@
+package dev.twilitrealm.dusk;
+
+import android.content.ContentResolver;
+import android.content.res.AssetFileDescriptor;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.ParcelFileDescriptor;
+import android.provider.DocumentsContract;
+import android.provider.DocumentsContract.Document;
+import android.provider.DocumentsContract.Root;
+import android.provider.DocumentsProvider;
+import android.webkit.MimeTypeMap;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class DuskDocumentsProvider extends DocumentsProvider {
+    public static final String AUTHORITY = "dev.twilitrealm.dusk.documents";
+
+    private static final String ROOT_ID = "dusk";
+    private static final String ROOT_DOCUMENT_ID = "root";
+    private static final String DIRECTORY_MIME_TYPE = Document.MIME_TYPE_DIR;
+
+    private static final String[] DEFAULT_ROOT_PROJECTION = new String[] {
+        Root.COLUMN_ROOT_ID,
+        Root.COLUMN_FLAGS,
+        Root.COLUMN_TITLE,
+        Root.COLUMN_DOCUMENT_ID,
+        Root.COLUMN_ICON,
+        Root.COLUMN_AVAILABLE_BYTES,
+        Root.COLUMN_SUMMARY
+    };
+
+    private static final String[] DEFAULT_DOCUMENT_PROJECTION = new String[] {
+        Document.COLUMN_DOCUMENT_ID,
+        Document.COLUMN_DISPLAY_NAME,
+        Document.COLUMN_FLAGS,
+        Document.COLUMN_MIME_TYPE,
+        Document.COLUMN_LAST_MODIFIED,
+        Document.COLUMN_SIZE
+    };
+
+    @Override
+    public boolean onCreate() {
+        ensureUserDirectories();
+        return true;
+    }
+
+    @Override
+    public Cursor queryRoots(String[] projection) throws FileNotFoundException {
+        final MatrixCursor result = new MatrixCursor(resolveRootProjection(projection));
+        final File root = getRootDirectory();
+        final MatrixCursor.RowBuilder row = result.newRow();
+
+        row.add(Root.COLUMN_ROOT_ID, ROOT_ID);
+        row.add(Root.COLUMN_FLAGS,
+            Root.FLAG_LOCAL_ONLY |
+            Root.FLAG_SUPPORTS_CREATE |
+            Root.FLAG_SUPPORTS_IS_CHILD);
+        row.add(Root.COLUMN_TITLE, getContext().getString(R.string.app_name));
+        row.add(Root.COLUMN_DOCUMENT_ID, ROOT_DOCUMENT_ID);
+        row.add(Root.COLUMN_ICON, R.mipmap.icon);
+        row.add(Root.COLUMN_AVAILABLE_BYTES, root.getFreeSpace());
+        row.add(Root.COLUMN_SUMMARY, getContext().getString(R.string.documents_provider_summary));
+
+        return result;
+    }
+
+    @Override
+    public Cursor queryDocument(String documentId, String[] projection) throws FileNotFoundException {
+        final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
+        includeDocument(result, documentId, getFileForDocumentId(documentId));
+        return result;
+    }
+
+    @Override
+    public Cursor queryChildDocuments(String parentDocumentId, String[] projection, String sortOrder)
+        throws FileNotFoundException
+    {
+        return queryChildDocumentsInternal(parentDocumentId, projection);
+    }
+
+    @Override
+    public Cursor queryChildDocuments(String parentDocumentId, String[] projection, Bundle queryArgs)
+        throws FileNotFoundException
+    {
+        return queryChildDocumentsInternal(parentDocumentId, projection);
+    }
+
+    private Cursor queryChildDocumentsInternal(String parentDocumentId, String[] projection)
+        throws FileNotFoundException
+    {
+        final MatrixCursor result = new MatrixCursor(resolveDocumentProjection(projection));
+        final File parent = getFileForDocumentId(parentDocumentId);
+        final File[] files = parent.listFiles();
+        result.setNotificationUri(getContext().getContentResolver(), getChildDocumentsUri(parentDocumentId));
+
+        if (files == null) {
+            return result;
+        }
+
+        for (File file : files) {
+            includeDocument(result, getDocumentIdForFile(file), file);
+        }
+
+        return result;
+    }
+
+    @Override
+    public boolean isChildDocument(String parentDocumentId, String documentId) {
+        try {
+            final File parent = getFileForDocumentId(parentDocumentId);
+            final File child = getFileForDocumentId(documentId);
+            return isInside(parent, child);
+        } catch (FileNotFoundException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public String createDocument(String parentDocumentId, String mimeType, String displayName)
+        throws FileNotFoundException
+    {
+        final File parent = getFileForDocumentId(parentDocumentId);
+        if (!parent.isDirectory()) {
+            throw new FileNotFoundException("Parent is not a directory: " + parentDocumentId);
+        }
+
+        final String safeDisplayName = sanitizeDisplayName(displayName);
+        final File file = buildUniqueFile(parent, safeDisplayName);
+        final boolean created;
+        if (DIRECTORY_MIME_TYPE.equals(mimeType)) {
+            created = file.mkdir();
+        } else {
+            try {
+                created = file.createNewFile();
+            } catch (IOException e) {
+                throw asFileNotFound("Unable to create document", e);
+            }
+        }
+
+        if (!created) {
+            throw new FileNotFoundException("Unable to create document: " + displayName);
+        }
+
+        notifyChildrenChanged(parentDocumentId);
+        return getDocumentIdForFile(file);
+    }
+
+    @Override
+    public String renameDocument(String documentId, String displayName) throws FileNotFoundException {
+        final File file = getFileForDocumentId(documentId);
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            throw new FileNotFoundException("Cannot rename root document");
+        }
+
+        final File target = buildUniqueFile(file.getParentFile(), sanitizeDisplayName(displayName));
+        final String parentDocumentId = getDocumentIdForFile(file.getParentFile());
+        if (!file.renameTo(target)) {
+            throw new FileNotFoundException("Unable to rename document: " + documentId);
+        }
+        notifyDocumentChanged(documentId);
+        notifyDocumentChanged(getDocumentIdForFile(target));
+        notifyChildrenChanged(parentDocumentId);
+        return getDocumentIdForFile(target);
+    }
+
+    @Override
+    public void deleteDocument(String documentId) throws FileNotFoundException {
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            throw new FileNotFoundException("Cannot delete root document");
+        }
+
+        final File file = getFileForDocumentId(documentId);
+        final String parentDocumentId = getDocumentIdForFile(file.getParentFile());
+        deleteRecursively(file);
+        notifyDocumentChanged(documentId);
+        notifyChildrenChanged(parentDocumentId);
+    }
+
+    @Override
+    public ParcelFileDescriptor openDocument(String documentId, String mode, CancellationSignal signal)
+        throws FileNotFoundException
+    {
+        return ParcelFileDescriptor.open(getFileForDocumentId(documentId), modeToParcelMode(mode));
+    }
+
+    @Override
+    public AssetFileDescriptor openDocumentThumbnail(String documentId, android.graphics.Point sizeHint,
+        CancellationSignal signal) throws FileNotFoundException
+    {
+        throw new FileNotFoundException("Thumbnails are not supported");
+    }
+
+    private void includeDocument(MatrixCursor result, String documentId, File file) throws FileNotFoundException {
+        final MatrixCursor.RowBuilder row = result.newRow();
+        final boolean isDirectory = file.isDirectory();
+        final String displayName = ROOT_DOCUMENT_ID.equals(documentId)
+            ? getContext().getString(R.string.documents_provider_root_name)
+            : file.getName();
+
+        int flags = Document.FLAG_SUPPORTS_DELETE | Document.FLAG_SUPPORTS_RENAME;
+        if (isDirectory) {
+            flags |= Document.FLAG_DIR_SUPPORTS_CREATE;
+        } else if (file.canWrite()) {
+            flags |= Document.FLAG_SUPPORTS_WRITE;
+        }
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            flags &= ~(Document.FLAG_SUPPORTS_DELETE | Document.FLAG_SUPPORTS_RENAME);
+        }
+
+        row.add(Document.COLUMN_DOCUMENT_ID, documentId);
+        row.add(Document.COLUMN_DISPLAY_NAME, displayName);
+        row.add(Document.COLUMN_FLAGS, flags);
+        row.add(Document.COLUMN_MIME_TYPE, isDirectory ? DIRECTORY_MIME_TYPE : getMimeType(file));
+        row.add(Document.COLUMN_LAST_MODIFIED, file.lastModified());
+        row.add(Document.COLUMN_SIZE, isDirectory ? null : file.length());
+    }
+
+    private File getRootDirectory() throws FileNotFoundException {
+        final File root = getContext().getFilesDir();
+        if (root == null) {
+            throw new FileNotFoundException("Dusk files directory is unavailable");
+        }
+        return root;
+    }
+
+    private File getFileForDocumentId(String documentId) throws FileNotFoundException {
+        final File root = getRootDirectory();
+        if (ROOT_DOCUMENT_ID.equals(documentId)) {
+            return root;
+        }
+        if (!documentId.startsWith(ROOT_DOCUMENT_ID + "/")) {
+            throw new FileNotFoundException("Invalid document id: " + documentId);
+        }
+
+        final String relativePath = documentId.substring(ROOT_DOCUMENT_ID.length() + 1);
+        final File file = new File(root, relativePath);
+        if (!isInside(root, file)) {
+            throw new FileNotFoundException("Document escapes Dusk files directory: " + documentId);
+        }
+        if (!file.exists()) {
+            throw new FileNotFoundException("Document does not exist: " + documentId);
+        }
+        return file;
+    }
+
+    private String getDocumentIdForFile(File file) throws FileNotFoundException {
+        final File root = getRootDirectory();
+        if (sameFile(root, file)) {
+            return ROOT_DOCUMENT_ID;
+        }
+        if (!isInside(root, file)) {
+            throw new FileNotFoundException("File escapes Dusk files directory: " + file);
+        }
+
+        final String rootPath = canonicalPath(root);
+        final String filePath = canonicalPath(file);
+        return ROOT_DOCUMENT_ID + "/" + filePath.substring(rootPath.length() + 1);
+    }
+
+    private void ensureUserDirectories() {
+        final File root = getContext().getFilesDir();
+        if (root == null) {
+            return;
+        }
+        new File(root, "texture_replacements").mkdirs();
+        new File(root, "USA/Card A").mkdirs();
+        new File(root, "EUR/Card A").mkdirs();
+    }
+
+    private static String[] resolveRootProjection(String[] projection) {
+        return projection != null ? projection : DEFAULT_ROOT_PROJECTION;
+    }
+
+    private static String[] resolveDocumentProjection(String[] projection) {
+        return projection != null ? projection : DEFAULT_DOCUMENT_PROJECTION;
+    }
+
+    private static String sanitizeDisplayName(String displayName) throws FileNotFoundException {
+        if (displayName == null) {
+            throw new FileNotFoundException("Document name is empty");
+        }
+
+        final String sanitized = displayName.trim();
+        if (sanitized.isEmpty() || ".".equals(sanitized) || "..".equals(sanitized) ||
+            sanitized.contains("/") || sanitized.contains("\\"))
+        {
+            throw new FileNotFoundException("Invalid document name: " + displayName);
+        }
+        return sanitized;
+    }
+
+    private static File buildUniqueFile(File parent, String displayName) {
+        File file = new File(parent, displayName);
+        if (!file.exists()) {
+            return file;
+        }
+
+        final int dot = displayName.lastIndexOf('.');
+        final String baseName = dot > 0 ? displayName.substring(0, dot) : displayName;
+        final String extension = dot > 0 ? displayName.substring(dot) : "";
+        for (int i = 1; i < 100; ++i) {
+            file = new File(parent, baseName + " (" + i + ")" + extension);
+            if (!file.exists()) {
+                return file;
+            }
+        }
+        return new File(parent, baseName + " (" + System.currentTimeMillis() + ")" + extension);
+    }
+
+    private static int modeToParcelMode(String mode) {
+        if ("r".equals(mode)) {
+            return ParcelFileDescriptor.MODE_READ_ONLY;
+        }
+        if ("w".equals(mode) || "wt".equals(mode)) {
+            return ParcelFileDescriptor.MODE_WRITE_ONLY |
+                ParcelFileDescriptor.MODE_CREATE |
+                ParcelFileDescriptor.MODE_TRUNCATE;
+        }
+        if ("wa".equals(mode)) {
+            return ParcelFileDescriptor.MODE_WRITE_ONLY |
+                ParcelFileDescriptor.MODE_CREATE |
+                ParcelFileDescriptor.MODE_APPEND;
+        }
+        if ("rw".equals(mode)) {
+            return ParcelFileDescriptor.MODE_READ_WRITE |
+                ParcelFileDescriptor.MODE_CREATE;
+        }
+        if ("rwt".equals(mode)) {
+            return ParcelFileDescriptor.MODE_READ_WRITE |
+                ParcelFileDescriptor.MODE_CREATE |
+                ParcelFileDescriptor.MODE_TRUNCATE;
+        }
+        return ParcelFileDescriptor.MODE_READ_ONLY;
+    }
+
+    private static String getMimeType(File file) {
+        final int dot = file.getName().lastIndexOf('.');
+        if (dot >= 0) {
+            final String extension = file.getName().substring(dot + 1).toLowerCase();
+            final String mimeType = MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension);
+            if (mimeType != null) {
+                return mimeType;
+            }
+        }
+        return "application/octet-stream";
+    }
+
+    private Uri getChildDocumentsUri(String parentDocumentId) {
+        return DocumentsContract.buildChildDocumentsUri(AUTHORITY, parentDocumentId);
+    }
+
+    private void notifyChildrenChanged(String parentDocumentId) {
+        final ContentResolver resolver = getContext().getContentResolver();
+        resolver.notifyChange(getChildDocumentsUri(parentDocumentId), null, false);
+    }
+
+    private void notifyDocumentChanged(String documentId) {
+        final ContentResolver resolver = getContext().getContentResolver();
+        resolver.notifyChange(DocumentsContract.buildDocumentUri(AUTHORITY, documentId), null, false);
+    }
+
+    private static void deleteRecursively(File file) throws FileNotFoundException {
+        if (file.isDirectory()) {
+            final File[] children = file.listFiles();
+            if (children != null) {
+                for (File child : children) {
+                    deleteRecursively(child);
+                }
+            }
+        }
+        if (!file.delete()) {
+            throw new FileNotFoundException("Unable to delete document: " + file);
+        }
+    }
+
+    private static boolean isInside(File parent, File child) {
+        try {
+            final String parentPath = canonicalPath(parent);
+            final String childPath = canonicalPath(child);
+            return childPath.equals(parentPath) || childPath.startsWith(parentPath + File.separator);
+        } catch (FileNotFoundException e) {
+            return false;
+        }
+    }
+
+    private static boolean sameFile(File a, File b) {
+        try {
+            return canonicalPath(a).equals(canonicalPath(b));
+        } catch (FileNotFoundException e) {
+            return false;
+        }
+    }
+
+    private static String canonicalPath(File file) throws FileNotFoundException {
+        try {
+            return file.getCanonicalPath();
+        } catch (IOException e) {
+            throw asFileNotFound("Unable to resolve path", e);
+        }
+    }
+
+    private static FileNotFoundException asFileNotFound(String message, IOException cause) {
+        final FileNotFoundException exception = new FileNotFoundException(message + ": " + cause.getMessage());
+        exception.initCause(cause);
+        return exception;
+    }
+}
@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
    <string name="app_name">Dusk</string>
+    <string name="documents_provider_root_name">Dusk Data</string>
+    <string name="documents_provider_summary">Saves, texture packs, settings, and logs</string>
 </resources>
@@ -79,5 +79,11 @@
    <true/>
    <key>CADisableMinimumFrameDurationOnPhone</key>
    <true/>
+    <key>UIFileSharingEnabled</key>
+    <true/>
+    <key>LSSupportsOpeningDocumentsInPlace</key>
+    <true/>
+    <key>LSSupportsGameMode</key>
+    <true/>
 </dict>
 </plist>
@@ -28,5 +28,7 @@
 	<string>${MACOSX_BUNDLE_SHORT_VERSION_STRING}</string>
 	<key>NSHighResolutionCapable</key>
 	<true/>
+	<key>LSSupportsGameMode</key>
+    <true/>
 </dict>
 </plist>
@@ -45,5 +45,7 @@
    <string>LaunchScreen</string>
    <key>UIUserInterfaceStyle</key>
    <string>Automatic</string>
+    <key>LSSupportsGameMode</key>
+    <true />
 </dict>
 </plist>
@@ -119,8 +119,8 @@ BOOL daAlink_c::setBodyAngleToCamera() {
                var_f31 /= dComIfGp_getCameraZoomScale(field_0x317c);
            }

-            shape_angle.y = shape_angle.y + (var_f31 * cM_ssin(mStickAngle));
-            sp8 = mBodyAngle.x + (var_f31 * cM_scos(mStickAngle));
+            shape_angle.y = shape_angle.y + (var_f31 * cM_ssin(mStickAngle) IF_DUSK(* (dusk::getSettings().game.invertFirstPersonXAxis ? -1.0f : 1.0f)));
+            sp8 = mBodyAngle.x + (var_f31 * cM_scos(mStickAngle) IF_DUSK(* (dusk::getSettings().game.invertFirstPersonYAxis ? -1.0f : 1.0f)));

            if (checkNotItemSinkLimit() && sp8 > 0 && sp8 > mBodyAngle.x) {
                sp8 = mBodyAngle.x;
@@ -144,8 +144,8 @@ BOOL daAlink_c::setBodyAngleToCamera() {
            f32 gy_pitch = 0.f;
            dusk::gyro::getAimDeltas(gy_yaw, gy_pitch);

-            shape_angle.y = shape_angle.y + cM_rad2s(gy_yaw * gyro_scale);
-            sp8 = sp8 + cM_rad2s(gy_pitch * gyro_scale);
+            shape_angle.y = shape_angle.y + cM_rad2s(gy_yaw * gyro_scale * (dusk::getSettings().game.invertFirstPersonXAxis ? -1.0f : 1.0f));
+            sp8 = sp8 + cM_rad2s(gy_pitch * gyro_scale * (dusk::getSettings().game.invertFirstPersonYAxis ? -1.0f : 1.0f));

            if (checkNotItemSinkLimit() && sp8 > 0 && sp8 > mBodyAngle.x) {
                sp8 = mBodyAngle.x;
@@ -7648,7 +7648,10 @@ bool dCamera_c::freeCamera() {
    cXyz camMovement = {mPadInfo.mCStick.mLastPosX, mPadInfo.mCStick.mLastPosY, 0.0f};
    f32 magnitude = sqrt(mPadInfo.mCStick.mLastPosX * mPadInfo.mCStick.mLastPosX + mPadInfo.mCStick.mLastPosY * mPadInfo.mCStick.mLastPosY);

-    if (mPadInfo.mCStick.mLastPosX != 0 || mPadInfo.mCStick.mLastPosY != 0) {
+    // If we aren't in manual cam mode, don't trigger it if the player tries to hit C-up
+    // for first person
+    if (mPadInfo.mCStick.mLastPosX != 0 || mPadInfo.mCStick.mLastPosY < 0 ||
+        (mCamParam.mManualMode == 1 && mPadInfo.mCStick.mLastPosY != 0)) {
        mCamParam.mManualMode = 1;
        camMovement = camMovement.normalize();
        camMovement.y *= dusk::getSettings().game.invertCameraYAxis ? 1.0f : -1.0f;
@@ -1030,7 +1030,7 @@ void AchievementSystem::load() {
        return;
    }
    try {
-        auto data = io::FileStream::ReadAllBytes(filePath.string().c_str());
+        auto data = io::FileStream::ReadAllBytes(filePath);
        auto j = json::parse(data);
        if (!j.is_object()) {
            return;
@@ -1067,7 +1067,7 @@ void AchievementSystem::save() {
    }
    try {
        io::FileStream::WriteAllText(
-            (dusk::ConfigPath / ACHIEVEMENTS_FILENAME).string().c_str(),
+            dusk::ConfigPath / ACHIEVEMENTS_FILENAME,
            j.dump(2)
        );
    } catch (const std::exception&) {}
@@ -23,8 +23,8 @@ aurora::Module DuskConfigLog("dusk::config");
 static absl::flat_hash_map<std::string_view, ConfigVarBase*> RegisteredConfigVars;
 static bool RegistrationDone = false;

-static std::string GetConfigJsonPath() {
-    return (dusk::ConfigPath / ConfigFileName).string();
+static std::u8string GetConfigJsonPath() {
+    return (dusk::ConfigPath / ConfigFileName).u8string();
 }

 ConfigVarBase::ConfigVarBase(const char* name, const ConfigImplBase* impl) : name(name), registered(false), layer(ConfigVarLayer::Default), impl(impl) {
@@ -189,7 +189,7 @@ void dusk::config::LoadFromUserPreferences() {
    if (configJsonPath.empty()) {
        return;
    }
-    LoadFromFileName(configJsonPath.c_str());
+    LoadFromFileName(reinterpret_cast<const char*>(configJsonPath.c_str()));
 }

 static void LoadFromPath(const char* path) {
@@ -241,7 +241,9 @@ void dusk::config::Save() {
        return;
    }

-    DuskConfigLog.info("Saving config to '{}'", configJsonPath);
+    DuskConfigLog.info(
+        "Saving config to '{}'",
+        reinterpret_cast<const char*>(configJsonPath.c_str()));

    json j;

@@ -251,7 +253,7 @@ void dusk::config::Save() {
        }
    }

-    io::FileStream::WriteAllText(configJsonPath.c_str(), j.dump(4));
+    io::FileStream::WriteAllText(reinterpret_cast<const char*>(configJsonPath.c_str()), j.dump(4));
 }

 ConfigVarBase* dusk::config::GetConfigVar(std::string_view name) {
@@ -4,7 +4,6 @@
 #include "dusk/dusk.h"
 #include "dusk/logging.h"
 #include "dusk/main.h"
-#include "dusk/settings.h"
 #include "version.h"

 #include <cstdlib>
@@ -13,114 +12,83 @@
 #include <string_view>
 #include <system_error>

-#include "SDL3/SDL_filesystem.h"
-
 #if DUSK_ENABLE_SENTRY_NATIVE
 #include <sentry.h>
 #endif

-namespace dusk {
+namespace dusk::crash_reporting {

 namespace {

 #if DUSK_ENABLE_SENTRY_NATIVE
 bool g_sentryInitialized = false;

-bool IsTruthy(std::string_view value) {
-    return value == "1" || value == "true" || value == "TRUE" || value == "yes"
-        || value == "YES" || value == "on" || value == "ON";
+bool truthy(std::string_view value) {
+    return value == "1" || value == "true" || value == "TRUE" || value == "yes" || value == "YES" ||
+           value == "on" || value == "ON";
 }

-std::string GetEnvOrEmpty(const char* name) {
+std::string env_or_empty(const char* name) {
    if (const char* value = std::getenv(name)) {
        return value;
    }
    return {};
 }

-bool GetEffectiveEnabled() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_ENABLED");
-    if (!env.empty()) {
-        return IsTruthy(env);
-    }
-    return getSettings().backend.enableCrashReporting;
+bool disabled_by_env() {
+    const std::string env = env_or_empty("DUSK_SENTRY_ENABLED");
+    return !env.empty() && !truthy(env);
 }

-std::string GetEffectiveDsn() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_DSN");
+std::string effective_dsn() {
+    const std::string env = env_or_empty("DUSK_SENTRY_DSN");
    if (!env.empty()) {
        return env;
    }
    return DUSK_SENTRY_DSN;
 }

-bool GetEffectiveDebug() {
-    const std::string env = GetEnvOrEmpty("DUSK_SENTRY_DEBUG");
+bool effective_debug() {
+    const std::string env = env_or_empty("DUSK_SENTRY_DEBUG");
    if (!env.empty()) {
-        return IsTruthy(env);
+        return truthy(env);
    }
    return false;
 }

-std::string GetReleaseName() {
+std::string release_name() {
    return std::string(AppName) + "@" DUSK_WC_DESCRIBE;
 }

-std::filesystem::path GetSentryDatabasePath() {
+std::filesystem::path sentry_database_path() {
    return dusk::ConfigPath / "sentry";
 }

-std::filesystem::path GetLogAttachmentPath() {
+std::filesystem::path log_attachment_path() {
    if (const char* logPath = GetLogFilePath()) {
        return logPath;
    }
    return {};
 }

-std::filesystem::path GetCrashpadHandlerPath() {
-    const char* basePath = SDL_GetBasePath();
-    if (!basePath) {
-        return {};
-    }
-
-    const std::filesystem::path handlerDir(basePath);
-#if _WIN32
-    return handlerDir / "crashpad_handler.exe";
-#else
-    return handlerDir / "crashpad_handler";
-#endif
-}
-
-void ConfigurePathOptions(sentry_options_t* options) {
-    const auto databasePath = GetSentryDatabasePath();
+void configure_path_options(sentry_options_t* options) {
+    const auto databasePath = sentry_database_path();
    std::error_code ec;
    std::filesystem::create_directories(databasePath, ec);
    if (ec) {
-        DuskLog.warn("Unable to create Sentry database path '{}': {}",
-                     databasePath.string(), ec.message());
+        DuskLog.warn(
+            "Unable to create Sentry database path '{}': {}", databasePath.string(), ec.message());
    }

 #if _WIN32
    const std::wstring databasePathWide = databasePath.wstring();
    sentry_options_set_database_pathw(options, databasePathWide.c_str());
-
-    const auto handlerPath = GetCrashpadHandlerPath();
-    if (!handlerPath.empty()) {
-        const std::wstring handlerPathWide = handlerPath.wstring();
-        sentry_options_set_handler_pathw(options, handlerPathWide.c_str());
-    }
 #else
    const std::string databasePathUtf8 = databasePath.string();
    sentry_options_set_database_path(options, databasePathUtf8.c_str());
-
-    const auto handlerPath = GetCrashpadHandlerPath();
-    if (!handlerPath.empty()) {
-        const std::string handlerPathUtf8 = handlerPath.string();
-        sentry_options_set_handler_path(options, handlerPathUtf8.c_str());
-    }
 #endif

-    const auto logPath = GetLogAttachmentPath();
+    const auto logPath = log_attachment_path();
    if (!logPath.empty()) {
 #if _WIN32
        sentry_options_add_attachmentw(options, logPath.wstring().c_str());
@@ -133,32 +101,29 @@ void ConfigurePathOptions(sentry_options_t* options) {

 }  // namespace

-void InitializeCrashReporting() {
+void initialize() {
 #if DUSK_ENABLE_SENTRY_NATIVE
-    if (g_sentryInitialized) {
+    if (g_sentryInitialized || disabled_by_env()) {
        return;
    }

-    if (!GetEffectiveEnabled()) {
-        return;
-    }
-
-    const std::string dsn = GetEffectiveDsn();
+    const std::string dsn = effective_dsn();
    if (dsn.empty()) {
        DuskLog.warn("Crash reporting is enabled but no Sentry DSN is configured");
        return;
    }

-    const std::string release = GetReleaseName();
+    const std::string release = release_name();

    sentry_options_t* options = sentry_options_new();
    sentry_options_set_dsn(options, dsn.c_str());
    sentry_options_set_release(options, release.c_str());
    sentry_options_set_environment(options, DUSK_SENTRY_ENVIRONMENT);
-    sentry_options_set_debug(options, GetEffectiveDebug() ? 1 : 0);
+    sentry_options_set_debug(options, effective_debug() ? 1 : 0);
+    sentry_options_set_require_user_consent(options, 1);
    sentry_options_set_cache_keep(options, 1);
    sentry_options_set_max_breadcrumbs(options, 100);
-    ConfigurePathOptions(options);
+    configure_path_options(options);

    if (sentry_init(options) != 0) {
        DuskLog.warn("Failed to initialize Sentry crash reporting");
@@ -173,7 +138,7 @@ void InitializeCrashReporting() {
 #endif
 }

-void ShutdownCrashReporting() {
+void shutdown() {
 #if DUSK_ENABLE_SENTRY_NATIVE
    if (!g_sentryInitialized) {
        return;
@@ -184,4 +149,40 @@ void ShutdownCrashReporting() {
 #endif
 }

-}  // namespace dusk
+Consent get_consent() {
+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (!g_sentryInitialized) {
+        return Consent::Unavailable;
+    }
+
+    switch (sentry_user_consent_get()) {
+    case SENTRY_USER_CONSENT_GIVEN:
+        return Consent::Given;
+    case SENTRY_USER_CONSENT_REVOKED:
+        return Consent::Revoked;
+    case SENTRY_USER_CONSENT_UNKNOWN:
+    default:
+        return Consent::Unknown;
+    }
+#else
+    return Consent::Unavailable;
+#endif
+}
+
+void set_consent(bool enabled) {
+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (!g_sentryInitialized) {
+        return;
+    }
+
+    if (enabled) {
+        sentry_user_consent_give();
+    } else {
+        sentry_user_consent_revoke();
+    }
+#else
+    (void)enabled;
+#endif
+}
+
+}  // namespace dusk::crash_reporting
@@ -140,8 +140,8 @@ void read(float dt) {
        float my_rel = 0.0f;
        SDL_GetRelativeMouseState(&mx_rel, &my_rel);
        // Convert pixels to radians
-        s_pitch_rad = my_rel * kMousePixelToRad * getSettings().game.gyroSensitivityX;
-        s_yaw_rad = -mx_rel * kMousePixelToRad * getSettings().game.gyroSensitivityY;
+        s_pitch_rad = my_rel * kMousePixelToRad * getSettings().game.gyroSensitivityY;
+        s_yaw_rad = -mx_rel * kMousePixelToRad * getSettings().game.gyroSensitivityX;
        s_roll_rad = 0.0f;

        s_pitch_rad = getSettings().game.gyroInvertPitch ? -s_pitch_rad : s_pitch_rad;
@@ -184,7 +184,7 @@ void read(float dt) {
    const float yaw_rate = apply_deadband(s_smooth_gy, deadband);
    const float roll_rate = apply_deadband(s_smooth_gz, deadband);

-    s_pitch_rad = -pitch_rate * dt * getSettings().game.gyroSensitivityX;
+    s_pitch_rad = -pitch_rate * dt * getSettings().game.gyroSensitivityY;
    s_roll_rad  = roll_rate * dt * getSettings().game.gyroSensitivityX; // GYRO NOTE: Exposing Z sensitivity seems unusual, so I'm just using X

    float horizontal_rate = yaw_rate;
@@ -223,7 +223,7 @@ void read(float dt) {
        }
    }

-    s_yaw_rad = horizontal_rate * dt * getSettings().game.gyroSensitivityY;
+    s_yaw_rad = horizontal_rate * dt * getSettings().game.gyroSensitivityX;

    s_pitch_rad = getSettings().game.gyroInvertPitch ? -s_pitch_rad : s_pitch_rad;
    s_yaw_rad = getSettings().game.gyroInvertYaw ? -s_yaw_rad : s_yaw_rad;
@@ -0,0 +1,142 @@
+#include "imgui.h"
+
+#include "ImGuiMenuTools.hpp"
+#include "d/actor/d_a_alink.h"
+#include "d/d_com_inf_game.h"
+#include "f_op/f_op_actor_mng.h"
+#include "SSystem/SComponent/c_sxyz.h"
+#include "SSystem/SComponent/c_xyz.h"
+
+namespace dusk {
+namespace {
+
+struct ActorSpawnerState {
+    int actorId    = 0;
+    int params     = -1;
+    int argument   = -1;
+    int angleX     = 0;
+    int angleY     = 0;
+    int angleZ     = 0;
+    float scaleX   = 1.0f;
+    float scaleY   = 1.0f;
+    float scaleZ   = 1.0f;
+    bool usePlayerRoom = true;
+    int manualRoom = 0;
+    int spawnCount = 1;
+    bool hasResult = false;
+    unsigned int lastResult = 0;
+    int lastAttempted = 0;
+};
+
+ActorSpawnerState s_state;
+
+}  // namespace
+
+void ImGuiMenuTools::ShowActorSpawner() {
+    if (!m_showActorSpawner) {
+        return;
+    }
+
+    if (!ImGui::Begin("Actor Spawner", &m_showActorSpawner)) {
+        ImGui::End();
+        return;
+    }
+
+    daAlink_c* player = (daAlink_c*)dComIfGp_getPlayer(0);
+
+    ImGui::SeparatorText("Actor");
+    ImGui::InputInt("Actor ID", &s_state.actorId);
+    ImGui::InputInt("Params (hex)", &s_state.params, 0, 0, ImGuiInputTextFlags_CharsHexadecimal);
+    ImGui::InputInt("Argument", &s_state.argument);
+    s_state.argument = (s_state.argument < -128) ? -128 : (s_state.argument > 127) ? 127 : s_state.argument;
+
+    ImGui::SeparatorText("Angle");
+    ImGui::InputInt("Angle X", &s_state.angleX);
+    ImGui::InputInt("Angle Y", &s_state.angleY);
+    ImGui::InputInt("Angle Z", &s_state.angleZ);
+
+    ImGui::SeparatorText("Scale");
+    ImGui::InputFloat("Scale X", &s_state.scaleX, 0.1f, 1.0f);
+    ImGui::InputFloat("Scale Y", &s_state.scaleY, 0.1f, 1.0f);
+    ImGui::InputFloat("Scale Z", &s_state.scaleZ, 0.1f, 1.0f);
+
+    ImGui::SeparatorText("Spawn");
+    ImGui::InputInt("Count", &s_state.spawnCount);
+    if (s_state.spawnCount < 1) {
+        s_state.spawnCount = 1;
+    }
+
+    ImGui::SeparatorText("Position");
+    ImGui::Checkbox("Use player room", &s_state.usePlayerRoom);
+    if (!s_state.usePlayerRoom) {
+        ImGui::InputInt("Room No", &s_state.manualRoom);
+    }
+
+    if (player != nullptr) {
+        ImGui::Text("Spawn pos: %.2f, %.2f, %.2f",
+            player->current.pos.x, player->current.pos.y, player->current.pos.z);
+    } else {
+        ImGui::TextDisabled("Player not available");
+    }
+
+    ImGui::Separator();
+
+    bool canSpawn = player != nullptr;
+    if (!canSpawn) {
+        ImGui::BeginDisabled();
+    }
+
+    if (ImGui::Button("Spawn", ImVec2(-1, 0))) {
+        cXyz pos = player->current.pos;
+        csXyz angle;
+        angle.set((s16)s_state.angleX, (s16)s_state.angleY, (s16)s_state.angleZ);
+        cXyz scale(s_state.scaleX, s_state.scaleY, s_state.scaleZ);
+        int roomNo = s_state.usePlayerRoom ? player->current.roomNo : s_state.manualRoom;
+
+        layer_class* savedLayer = fpcLy_CurrentLayer();
+        base_process_class* playScene = fpcM_SearchByName(fpcNm_PLAY_SCENE_e);
+        if (playScene != nullptr) {
+            fpcLy_SetCurrentLayer(&((process_node_class*)playScene)->layer);
+        }
+
+        s_state.lastResult = 0;
+        s_state.lastAttempted = s_state.spawnCount;
+        for (int i = 0; i < s_state.spawnCount; ++i) {
+            unsigned int result = fopAcM_create(
+                (s16)s_state.actorId,
+                (u32)s_state.params,
+                &pos,
+                roomNo,
+                &angle,
+                &scale,
+                (s8)s_state.argument
+            );
+            if (result != 0) {
+                s_state.lastResult = result;
+            }
+        }
+        s_state.hasResult = true;
+
+        fpcLy_SetCurrentLayer(savedLayer);
+    }
+
+    if (!canSpawn) {
+        ImGui::EndDisabled();
+    }
+
+    if (s_state.hasResult) {
+        if (s_state.lastResult != 0) {
+            if (s_state.lastAttempted == 1) {
+                ImGui::Text("Spawned: proc ID %u", s_state.lastResult);
+            } else {
+                ImGui::Text("Spawned %d (last proc ID %u)", s_state.lastAttempted, s_state.lastResult);
+            }
+        } else {
+            ImGui::TextColored(ImVec4(1, 0.4f, 0.4f, 1), "Spawn failed (returned 0)");
+        }
+    }
+
+    ImGui::End();
+}
+
+}  // namespace dusk
@@ -313,7 +313,9 @@ namespace dusk {
                ImGui::PopFont();
            }
            ImGui::PushFont(ImGuiEngine::fontLarge);
-            ImGuiTextCenter("Failed to initialize any graphics backend");
+            ImGuiTextCenter("Failed to initialize any graphics backend.");
+            ImGuiTextCenter("\nYour system may be misconfigured, or your hardware may not support the required versions of any of the available backends.");
+            ImGuiTextCenter("\nA clean reinstall of Dusk may help. For further assistance, please visit #tech-support on the Twilit Realm Discord server.");
            const auto& style = ImGui::GetStyle();
            const auto retrySize = ImGui::CalcTextSize("Retry (Auto backend)");
            const auto quitSize = ImGui::CalcTextSize("Quit");
@@ -373,6 +375,7 @@ namespace dusk {
            m_menuTools.ShowAudioDebug();
            m_menuTools.ShowSaveEditor();
            m_menuTools.ShowStateShare();
+            m_menuTools.ShowActorSpawner();
        }

        // Hide mouse cursor if the F1 menu is not open and the cursor is idle for 3 seconds.
@@ -2,11 +2,9 @@
 #define DUSK_IMGUI_HPP

 #include <deque>
-#include <filesystem>
 #include <string>
 #include <string_view>

-#include <SDL3/SDL_misc.h>
 #include <aurora/aurora.h>

 #include "ImGuiMenuGame.hpp"
@@ -73,24 +71,4 @@ bool ImGuiButtonCenter(std::string_view text);
 float ImGuiScale();
 }  // namespace dusk

-#if defined(_WIN32) ||                                                                             \
-    (defined(__APPLE__) && !TARGET_OS_IOS && !TARGET_OS_TV && !TARGET_OS_MACCATALYST) ||           \
-    (defined(__linux__) && !defined(__ANDROID__))
-#define DUSK_CAN_OPEN_DATA_FOLDER 1
-
-namespace fs = std::filesystem;
-
-static void OpenDataFolder() {
-    const std::string path = fs::absolute(dusk::ConfigPath).generic_string();
-#if defined(_WIN32)
-    const std::string url = std::string("file:///") + path;
-#else
-    const std::string url = std::string("file://") + path;
-#endif
-    (void)SDL_OpenURL(url.c_str());
-}
-#else
-#define DUSK_CAN_OPEN_DATA_FOLDER 0
-#endif
-
 #endif  // DUSK_IMGUI_HPP
@@ -56,12 +56,12 @@ namespace dusk {
        }

        // L+R+A+Start to reset timer
-        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigStart(PAD_1)) {
+        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigZ(PAD_1)) {
            m_speedrunInfo.reset();
        }

        // L+R+A+Z to manually stop timer
-        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigZ(PAD_1)) {
+        if (mDoCPd_c::getHoldL(PAD_1) && mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getHoldA(PAD_1) && mDoCPd_c::getTrigY(PAD_1)) {
            if (m_speedrunInfo.m_isRunStarted) {
                m_speedrunInfo.m_endTimestamp = OSGetTime() - m_speedrunInfo.m_startTimestamp;
                m_speedrunInfo.m_isRunStarted = false;
@@ -107,6 +107,7 @@ namespace dusk {
            ImGui::MenuItem("Audio Debug", hotkeys::SHOW_AUDIO_DEBUG, &m_showAudioDebug);
            ImGui::MenuItem("Bloom", nullptr, &m_showBloomWindow);
            ImGui::MenuItem("Stub Log", nullptr, &m_showStubLog);
+            ImGui::MenuItem("Actor Spawner", nullptr, &m_showActorSpawner);

            if (!dusk::IsGameLaunched) {
                ImGui::EndDisabled();
@@ -28,6 +28,7 @@ namespace dusk {
        void ShowSaveEditor();
        void ShowStateShare();
        void ShowInputViewer();
+        void ShowActorSpawner();

    private:
 		bool m_showDebugOverlay = false;
@@ -70,6 +71,7 @@ namespace dusk {

        bool m_showInputViewer = false;
        bool m_showInputViewerGyro = false;
+        bool m_showActorSpawner = false;
        int m_inputOverlayCorner = 3;
        std::string m_controllerName;
    };
@@ -48,19 +48,18 @@ void ImGuiStateShare::onMergeFileSelected(void* userdata, const char* path, cons



-static std::string GetStatesFilePath() {
-    return (dusk::ConfigPath / STATES_FILENAME).string();
+static std::filesystem::path GetStatesFilePath() {
+    return ConfigPath / STATES_FILENAME;
 }

 void ImGuiStateShare::loadStatesFile() {
    m_loaded = true;
-    const std::filesystem::path filePath = dusk::ConfigPath / STATES_FILENAME;
+    const std::filesystem::path filePath = GetStatesFilePath();
    if (!std::filesystem::exists(filePath)) {
        return;
    }
    try {
-        const std::string pathStr = filePath.string();
-        auto data = io::FileStream::ReadAllBytes(pathStr.c_str());
+        auto data = io::FileStream::ReadAllBytes(filePath);
        auto j = json::parse(data);
        if (!j.is_array()) {
            return;
@@ -85,7 +84,7 @@ void ImGuiStateShare::saveStatesFile() {
        j.push_back(json{{"name", s.name}, {"data", s.encoded}});
    }
    try {
-        io::FileStream::WriteAllText(GetStatesFilePath().c_str(), j.dump(2));
+        io::FileStream::WriteAllText(GetStatesFilePath(), j.dump(2));
    } catch (const std::exception& e) {
        m_statusMsg = fmt::format("Failed to save states: {}", e.what());
    }
@@ -1,7 +1,8 @@
-#include "dusk/io.hpp"
 #include <cstdio>
 #include <filesystem>

+#include "dusk/io.hpp"
+
 using namespace dusk::io;

 #if _WIN32
@@ -58,7 +59,7 @@ static FILE* OpenCore(const char* path, const MODE_TYPE* mode) {
 FileStream::FileStream() noexcept : file(nullptr) {
 }

-FileStream::FileStream(void* file) : file(file) {
+FileStream::FileStream(FILE* file) : file(file) {
    if (!file) {
        CRASH("Invalid file handle");
    }
@@ -78,10 +79,18 @@ FileStream FileStream::OpenRead(const char* utf8Path) {
    return FileStream(OpenCore(utf8Path, MODE("rb")));
 }

+FileStream FileStream::OpenRead(const std::filesystem::path& path) {
+    return FileStream(OpenCore(path, MODE("rb")));
+}
+
 FileStream FileStream::Create(const char* utf8Path) {
    return FileStream(OpenCore(utf8Path, MODE("wb")));
 }

+FileStream FileStream::Create(const std::filesystem::path& path) {
+    return FileStream(OpenCore(path, MODE("wb")));
+}
+
 std::vector<u8> FileStream::ReadFull() {
    const auto fileHandle = ThrowIfNotOpen(*this);

@@ -128,7 +137,11 @@ std::vector<u8> FileStream::ReadFull() {
 }

 std::vector<u8> FileStream::ReadAllBytes(const char* utf8Path) {
-    auto handle = OpenRead(utf8Path);
+    return ReadAllBytes(reinterpret_cast<const char8_t*>(utf8Path));
+}
+
+std::vector<u8> FileStream::ReadAllBytes(const std::filesystem::path& path) {
+    auto handle = OpenRead(path);
    return std::move(handle.ReadFull());
 }

@@ -142,6 +155,16 @@ void FileStream::Write(const char* data, size_t dataLen) {
 }

 void FileStream::WriteAllText(const char* utf8Path, const std::string_view text) {
-    auto handle = Create(utf8Path);
+    WriteAllText(reinterpret_cast<const char8_t*>(utf8Path), text);
+}
+
+void FileStream::WriteAllText(const std::filesystem::path& path, const std::string_view text) {
+    auto handle = Create(path);
    handle.Write(text.data(), text.size());
 }
+
+FILE* FileStream::ToInner() {
+    auto handle = file;
+    file = nullptr;
+    return handle;
+}
@@ -9,6 +9,8 @@
 #include <stdexcept>
 #include <string_view>

+#include "dusk/logging.h"
+
 namespace {

 constexpr uint8_t hex_nibble_to_u8(char c) {
@@ -42,6 +44,18 @@ constexpr XXH128_hash_t parse_xxh128(std::string_view hex) {
    };
 }

+const char* verification_state_name(dusk::DiscVerificationState state) noexcept {
+    switch (state) {
+    case dusk::DiscVerificationState::Success:
+        return "verified";
+    case dusk::DiscVerificationState::HashMismatch:
+        return "hash mismatch";
+    case dusk::DiscVerificationState::Unknown:
+    default:
+        return "unknown";
+    }
+}
+
 }  // namespace

 namespace dusk::iso {
@@ -248,4 +262,10 @@ bool isPal(const char* path) {
    DiscInfo info{};
    return inspect(path, info) == ValidationError::Success && info.isPal;
 }
+
+void log_verification_state(std::string_view path, DiscVerificationState state) {
+    const std::string pathText = path.empty() ? "<none>" : std::string(path);
+    DuskLog.info(
+        "Disc verification status: {} (path: {})", verification_state_name(state), pathText);
+}
 }  // namespace dusk::iso
@@ -31,6 +31,7 @@ struct DiscInfo {
 ValidationError inspect(const char* path, DiscInfo& info);
 ValidationError validate(const char* path, VerificationStatus& status, DiscInfo& info);
 bool isPal(const char* path);
+void log_verification_state(std::string_view path, DiscVerificationState state);

 }  // namespace dusk::iso

@@ -8,6 +8,7 @@
 #include <mutex>
 #include <string>

+#include "dusk/io.hpp"
 #include "tracy/Tracy.hpp"

 #if TARGET_ANDROID
@@ -40,7 +41,7 @@ std::atomic g_logStateAlive(true);
 struct LogState {
    std::mutex mutex;
    FILE* file = nullptr;
-    std::string filePath;
+    std::u8string filePath;

    ~LogState() {
        CloseFile();
@@ -207,19 +208,19 @@ void dusk::InitializeFileLogging(const std::filesystem::path& configDir, AuroraL
    std::filesystem::create_directories(logsDir, ec);
    if (ec) {
        std::fprintf(stderr, "[WARNING | dusk] Failed to create log directory '%s': %s\n",
-                     logsDir.string().c_str(), ec.message().c_str());
+            io::fs_path_to_string(logsDir).c_str(), ec.message().c_str());
        return;
    }

    const std::filesystem::path logPath = logsDir / MakeTimestampedLogName();
-    g_logState.file = std::fopen(logPath.string().c_str(), "wb");
+    g_logState.file = io::FileStream::Create(logPath).ToInner();
    if (g_logState.file == nullptr) {
        std::fprintf(stderr, "[WARNING | dusk] Failed to open log file '%s'\n",
-                     logPath.string().c_str());
+            io::fs_path_to_string(logPath).c_str());
        return;
    }

-    g_logState.filePath = logPath.string();
+    g_logState.filePath = logPath.u8string();
    aurora::g_config.logCallback = &aurora_log_callback;
    aurora::g_config.logLevel = logLevel;
    WriteLogLine(g_logState.file, "INFO", "dusk", "File logging initialized", 24);
@@ -237,5 +238,6 @@ const char* dusk::GetLogFilePath() {
        return nullptr;
    }
    std::lock_guard lock(g_logState.mutex);
-    return g_logState.filePath.empty() ? nullptr : g_logState.filePath.c_str();
+    return reinterpret_cast<const char*>(
+        g_logState.filePath.empty() ? nullptr : g_logState.filePath.c_str());
 }
@@ -6,6 +6,7 @@

 #include <aurora/main.h>
 #include "dusk/main.h"
+#include "dusk/io.hpp"

 #include <algorithm>
 #include <array>
@@ -91,7 +92,7 @@ bool RestartProcess(int argc, char* argv[]) {

    std::vector<std::string> args;
    args.reserve(static_cast<size_t>(std::max(argc, 1)));
-    args.push_back(executablePath.string());
+    args.push_back(dusk::io::fs_path_to_string(executablePath));
    for (int i = 1; i < argc; ++i) {
        args.emplace_back(argv[i] != nullptr ? argv[i] : "");
    }
@@ -81,6 +81,8 @@ UserSettings g_userSettings = {
        .freeCamera {"game.freeCamera", false},
        .invertCameraXAxis {"game.invertCameraXAxis", false},
        .invertCameraYAxis {"game.invertCameraYAxis", false},
+        .invertFirstPersonXAxis {"game.invertFirstPersonXAxis", false},
+        .invertFirstPersonYAxis {"game.invertFirstPersonYAxis", false},
        .freeCameraSensitivity {"game.freeCameraSensitivity", 1.0f},
        .debugFlyCam {"game.debugFlyCam", false},
        .debugFlyCamLockEvents {"game.debugFlyCamLockEvents", true},
@@ -121,7 +123,6 @@ UserSettings g_userSettings = {
        .skipPreLaunchUI {"backend.skipPreLaunchUI", false},
        .showPipelineCompilation {"backend.showPipelineCompilation", false},
        .wasPresetChosen {"backend.wasPresetChosen", false},
-        .enableCrashReporting {"backend.enableCrashReporting", true},
        .checkForUpdates {"backend.checkForUpdates", true},
        .cardFileType {"backend.cardFileType", static_cast<int>(CARD_GCIFOLDER)},
        .enableAdvancedSettings {"backend.enableAdvancedSettings", false},
@@ -171,6 +172,8 @@ void registerSettings() {
    Register(g_userSettings.game.enableMirrorMode);
    Register(g_userSettings.game.invertCameraXAxis);
    Register(g_userSettings.game.invertCameraYAxis);
+    Register(g_userSettings.game.invertFirstPersonXAxis);
+    Register(g_userSettings.game.invertFirstPersonYAxis);
    Register(g_userSettings.game.freeCameraSensitivity);
    Register(g_userSettings.game.minimalHUD);
    Register(g_userSettings.game.pauseOnFocusLost);
@@ -228,7 +231,6 @@ void registerSettings() {
    Register(g_userSettings.backend.skipPreLaunchUI);
    Register(g_userSettings.backend.showPipelineCompilation);
    Register(g_userSettings.backend.wasPresetChosen);
-    Register(g_userSettings.backend.enableCrashReporting);
    Register(g_userSettings.backend.checkForUpdates);
    Register(g_userSettings.backend.cardFileType);
    Register(g_userSettings.backend.enableAdvancedSettings);
@@ -208,7 +208,15 @@ bool input_neutral(int port) {
 bool keyboard_escape_pressed() {
    int keyCount = 0;
    const bool* keys = SDL_GetKeyboardState(&keyCount);
-    return keys != nullptr && SDL_SCANCODE_ESCAPE < keyCount && keys[SDL_SCANCODE_ESCAPE];
+    if (keys == nullptr || SDL_SCANCODE_ESCAPE >= keyCount || !keys[SDL_SCANCODE_ESCAPE]) {
+        return false;
+    }
+    for (int i = 0; i < keyCount; ++i) {
+        if (i != SDL_SCANCODE_ESCAPE && keys[i]) {
+            return false;
+        }
+    }
+    return true;
 }

 Rml::String keyboard_key_name(s32 scancode) {
@@ -302,9 +302,17 @@ std::string get_error_msg(iso::ValidationError error) {
 }

 void persist_disc_choice(const std::string& path, iso::ValidationError validation) {
+    const auto previousPath = getSettings().backend.isoPath.getValue();
+    const auto previousVerification = getSettings().backend.isoVerification.getValue();
+    const auto verification = verification_to_config(validation);
+
    getSettings().backend.isoPath.setValue(path);
-    getSettings().backend.isoVerification.setValue(verification_to_config(validation));
+    getSettings().backend.isoVerification.setValue(verification);
    config::Save();
+
+    if (previousPath != path || previousVerification != verification) {
+        iso::log_verification_state(path, verification);
+    }
 }

 void apply_valid_disc_result(
@@ -33,6 +33,7 @@ void applyPresetDusk() {
    s.game.fastTears.setValue(true);
    s.game.biggerWallets.setValue(true);
    s.game.invertCameraXAxis.setValue(true);
+    s.game.invertFirstPersonYAxis.setValue(true);
    s.game.no2ndFishForCat.setValue(true);
    s.game.enableAchievementToasts.setValue(true);
    s.game.enableControllerToasts.setValue(true);
@@ -0,0 +1,113 @@
+#if DUSK_ENABLE_SENTRY_NATIVE
+
+#include "reporting.hpp"
+
+#include "button.hpp"
+#include "dusk/crash_reporting.h"
+#include "ui.hpp"
+
+#include <dolphin/gx/GXAurora.h>
+
+namespace dusk::ui {
+
+CrashReportWindow::CrashReportWindow() : WindowSmall("modal", "modal-dialog") {
+    mDialog->SetClass("modal-dialog", true);
+
+    auto* header = append(mDialog, "div");
+    header->SetClass("modal-header", true);
+
+    auto* title = append(header, "div");
+    title->SetClass("modal-title", true);
+    title->SetInnerRML("Send Crash Reports");
+
+    auto* headIcon = append(header, "icon");
+    headIcon->SetClass("question-mark", true);
+
+    auto* intro = append(mDialog, "div");
+    intro->SetClass("modal-body", true);
+    intro->SetInnerRML(
+        "Dusk can automatically send crash reports to the developers. Crash reports contain the "
+        "following:"
+        "<br/>• Operating system version<br/>• CPU architecture<br/>• GPU model & driver version"
+        "<br/>• File paths (may include account username)<br/>• Stack trace<br/><br/>"
+        "This can be changed in the Settings menu at any time.");
+
+    auto* grid = append(mDialog, "div");
+    grid->SetClass("preset-grid", true);
+
+    struct OptionInfo {
+        const char* name;
+        const char* desc;
+        void (*apply)();
+    };
+
+    static constexpr OptionInfo kOptions[] = {
+        {"Enable",
+            "Send crash reports to Dusk developers. Reports will include the information described "
+            "above.",
+            [] { crash_reporting::set_consent(true); }},
+        {"Disable",
+            "Do not send crash reports. This may make it more difficult to resolve issues you "
+            "encounter.",
+            [] { crash_reporting::set_consent(false); }},
+    };
+
+    for (const auto& option : kOptions) {
+        auto* col = append(grid, "div");
+        col->SetClass("preset-col", true);
+
+        auto btn = std::make_unique<Button>(col, Rml::String(option.name));
+        btn->on_nav_command([this, apply = option.apply](Rml::Event&, NavCommand cmd) {
+            if (cmd == NavCommand::Confirm) {
+                apply();
+                hide(true);
+                return true;
+            }
+            return false;
+        });
+        mButtons.push_back(std::move(btn));
+
+        auto* desc = append(col, "div");
+        desc->SetClass("preset-desc", true);
+        desc->SetInnerRML(option.desc);
+    }
+}
+
+bool CrashReportWindow::focus() {
+    if (!mButtons.empty()) {
+        return mButtons.back()->focus();
+    }
+    return false;
+}
+
+bool CrashReportWindow::handle_nav_command(Rml::Event& event, NavCommand cmd) {
+    if (cmd == NavCommand::Cancel || cmd == NavCommand::Menu) {
+        return true;
+    }
+    int direction = 0;
+    if (cmd == NavCommand::Left) {
+        direction = -1;
+    } else if (cmd == NavCommand::Right) {
+        direction = 1;
+    } else {
+        return false;
+    }
+    auto* target = event.GetTargetElement();
+    for (int i = 0; i < static_cast<int>(mButtons.size()); ++i) {
+        if (mButtons[i]->contains(target)) {
+            const int next = i + direction;
+            if (next >= 0 && next < static_cast<int>(mButtons.size())) {
+                if (mButtons[next]->focus()) {
+                    mDoAud_seStartMenu(kSoundItemFocus);
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    return false;
+}
+
+}  // namespace dusk::ui
+
+#endif
@@ -0,0 +1,28 @@
+#pragma once
+
+#if DUSK_ENABLE_SENTRY_NATIVE
+
+#include "component.hpp"
+#include "window.hpp"
+
+#include <memory>
+#include <vector>
+
+namespace dusk::ui {
+
+class CrashReportWindow : public WindowSmall {
+public:
+    CrashReportWindow();
+
+    bool focus() override;
+
+protected:
+    bool handle_nav_command(Rml::Event& event, NavCommand cmd) override;
+
+private:
+    std::vector<std::unique_ptr<Component>> mButtons;
+};
+
+}  // namespace dusk::ui
+
+#endif
@@ -9,6 +9,7 @@
 #include "dusk/file_select.hpp"
 #include "dusk/imgui/ImGuiEngine.hpp"
 #include "dusk/livesplit.h"
+#include "dusk/main.h"
 #include "graphics_tuner.hpp"
 #include "m_Do/m_Do_main.h"
 #include "menu_bar.hpp"
@@ -18,6 +19,10 @@
 #include "prelaunch.hpp"
 #include "ui.hpp"

+#if DUSK_ENABLE_SENTRY_NATIVE
+#include "dusk/crash_reporting.h"
+#endif
+
 #include <algorithm>

 namespace dusk::ui {
@@ -640,6 +645,10 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
        config_percent_select(leftPane, rightPane, getSettings().game.freeCameraSensitivity,
            "Free Camera Sensitivity", "Adjusts twin-stick camera sensitivity.", 50, 200, 5,
            [] { return !getSettings().game.freeCamera; });
+        addOption("Invert First Person X Axis", getSettings().game.invertFirstPersonXAxis,
+            "Invert horizontal movement while aiming with items or first person camera. Applies to both stick and gyro aiming.");
+        addOption("Invert First Person Y Axis", getSettings().game.invertFirstPersonYAxis,
+            "Invert vertical movement while aiming with items or first person camera. Applies to both stick and gyro aiming.");

        leftPane.add_section("Gyro");
        leftPane.register_control(
@@ -946,6 +955,18 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
        auto& rightPane = add_child<Pane>(content, Pane::Type::Uncontrolled);

        leftPane.add_section("Dusk");
+#if DUSK_CAN_OPEN_DATA_FOLDER
+        leftPane.register_control(
+            leftPane.add_button("Open Data Folder").on_pressed([] {
+                mDoAud_seStartMenu(kSoundClick);
+                dusk::OpenDataFolder();
+            }),
+            rightPane, [](Pane& pane) {
+                pane.add_text(
+                    "Open the folder where Dusk stores settings, saves, logs, texture "
+                    "replacements, and other app data.");
+            });
+#endif
        leftPane.register_control(
            leftPane.add_select_button({
                .key = "Notifications",
@@ -1011,16 +1032,24 @@ SettingsWindow::SettingsWindow(bool prelaunch) : mPrelaunch(prelaunch) {
                pane.add_rml("<br/>Choose which notifications can be displayed.");
            });
 #if DUSK_ENABLE_SENTRY_NATIVE
-        config_bool_select(leftPane, rightPane, getSettings().backend.enableCrashReporting,
-            {.key = "Crash Reporting",
-                .helpText = "Enable automatic reporting of crashes to the developers.<br/><br/>"
-                            "Submissions include logs which may contain sensitive information. "
-                            "Refrain from "
-                            "enabling reporting if you do not agree with the following "
-                            "inclusions:<br/><br/> "
-                            "- Operating System<br/>- CPU Architecture<br/>- GPU Model & Driver "
-                            "Version<br/>"
-                            "- Account Username"});
+        auto& crashReporting = leftPane.add_child<BoolButton>(BoolButton::Props{
+            .key = "Crash Reporting",
+            .getValue =
+                [] { return crash_reporting::get_consent() == crash_reporting::Consent::Given; },
+            .setValue = [](bool enabled) { crash_reporting::set_consent(enabled); },
+            .isDisabled =
+                [] {
+                    return crash_reporting::get_consent() == crash_reporting::Consent::Unavailable;
+                },
+            .isModified = [] { return false; },
+        });
+        leftPane.register_control(crashReporting, rightPane, [](Pane& pane) {
+            pane.clear();
+            pane.add_rml("Dusk can automatically send crash reports to the developers. Crash "
+                         "reports contain the following:<br/>• Operating system version<br/>• CPU "
+                         "architecture<br/>• GPU model & driver version<br/>• File paths (may "
+                         "include account username)<br/>• Stack trace");
+        });
 #endif
        config_bool_select(leftPane, rightPane, getSettings().backend.skipPreLaunchUI,
            {
@@ -11,6 +11,7 @@
 #include <ranges>

 #include "aurora/lib/window.hpp"
+#include "dusk/io.hpp"
 #include "input.hpp"
 #include "prelaunch.hpp"
 #include "window.hpp"
@@ -19,7 +20,7 @@ namespace dusk::ui {
 namespace {

 void load_font(const char* filename, bool fallback = false) {
-    Rml::LoadFontFace(resource_path(filename).string(), fallback);
+    Rml::LoadFontFace(io::fs_path_to_string(resource_path(filename)), fallback);
 }

 bool sInitialized = false;
@@ -740,6 +740,8 @@ static void fapGm_AfterRecord() {
    fapGm_After();
 }

+BOOL isRecording = false;
+
 static void duskExecute() {
    handleGamepadColor();
    updateAutoSave();
@@ -747,6 +749,11 @@ static void duskExecute() {
    if (dusk::getSettings().game.recordingMode) {
        Z2GetSoundMgr()->getSeqMgr()->getParams()->moveVolume(0.0f, 0);
        Z2GetSoundMgr()->getStreamMgr()->getParams()->moveVolume(0.0f, 0);
+        isRecording = true;
+    } else if (isRecording) {
+        Z2GetSoundMgr()->getSeqMgr()->getParams()->moveVolume(1.0f, 0);
+        Z2GetSoundMgr()->getStreamMgr()->getParams()->moveVolume(1.0f, 0);
+        isRecording = false;
    }

    if (mDoCPd_c::getHoldR(PAD_1) && mDoCPd_c::getTrigX(PAD_1)) {
@@ -71,18 +71,28 @@
 #include <dolphin/dvd.h>

 #include "SDL3/SDL_filesystem.h"
+#include "SDL3/SDL_iostream.h"
+#include "SDL3/SDL_misc.h"
 #include "cxxopts.hpp"
 #include "d/actor/d_a_movie_player.h"
 #include "dusk/audio/DuskAudioSystem.h"
 #include "dusk/audio/DuskDsp.hpp"
 #include "dusk/config.hpp"
 #include "dusk/settings.h"
+#include "dusk/io.hpp"
 #include "dusk/version.hpp"
 #include "dusk/discord_presence.hpp"
 #include "tracy/Tracy.hpp"
 #include "f_pc/f_pc_draw.h"
 #include "tracy/Tracy.hpp"
 #include <RmlUi/Core.h>
+#ifdef __APPLE__
+#include <TargetConditionals.h>
+#endif
+
+#if DUSK_ENABLE_SENTRY_NATIVE
+#include "dusk/ui/reporting.hpp"
+#endif

 // --- GLOBALS ---
 s8 mDoMain::developmentMode = -1;
@@ -114,6 +124,32 @@ void dusk::RequestRestart() noexcept {
    IsRunning = false;
 }

+bool dusk::OpenDataFolder() {
+#if DUSK_CAN_OPEN_DATA_FOLDER
+    std::error_code ec;
+    std::filesystem::path path = std::filesystem::absolute(ConfigPath, ec);
+    if (ec) {
+        DuskLog.warn("Failed to resolve absolute data folder path '{}': {}",
+            io::fs_path_to_string(ConfigPath), ec.message());
+        path = ConfigPath;
+    }
+
+#if defined(_WIN32)
+    const std::string url = "file:///" + path.generic_string();
+#else
+    const std::string url = "file://" + path.generic_string();
+#endif
+    if (!SDL_OpenURL(url.c_str())) {
+        DuskLog.warn(
+            "Failed to open data folder '{}': {}", io::fs_path_to_string(path), SDL_GetError());
+        return false;
+    }
+    return true;
+#else
+    return false;
+#endif
+}
+
 s32 LOAD_COPYDATE(void*) {
    char buffer[32];
    memset(buffer, 0, sizeof(buffer));
@@ -392,13 +428,77 @@ static void ApplyCVarOverrides(const cxxopts::OptionValue& option) {
    }
 }

-static std::filesystem::path CalculateConfigPath() {
+static void migrate_directory(const std::filesystem::path& from, const std::filesystem::path& to) {
+    std::error_code ec;
+    std::filesystem::create_directories(to, ec);
+    if (ec) {
+        return;
+    }
+
+    for (std::filesystem::recursive_directory_iterator it(
+             from, std::filesystem::directory_options::skip_permission_denied, ec);
+        it != std::filesystem::recursive_directory_iterator(); it.increment(ec))
+    {
+        if (ec) {
+            return;
+        }
+
+        const auto relativePath = std::filesystem::relative(it->path(), from, ec);
+        if (ec) {
+            return;
+        }
+
+        const auto targetPath = to / relativePath;
+        if (it->is_directory(ec)) {
+            std::filesystem::create_directories(targetPath, ec);
+            if (ec) {
+                return;
+            }
+        } else if (it->is_regular_file(ec) && !std::filesystem::exists(targetPath, ec)) {
+            std::filesystem::create_directories(targetPath.parent_path(), ec);
+            if (ec) {
+                return;
+            }
+            std::filesystem::copy_file(
+                it->path(), targetPath, std::filesystem::copy_options::skip_existing, ec);
+            if (ec) {
+                return;
+            }
+        }
+    }
+}
+
+static std::filesystem::path calculate_config_path() {
+#ifdef __APPLE__
+#if TARGET_OS_IOS && !TARGET_OS_TV
+    const char* documentsPath = SDL_GetUserFolder(SDL_FOLDER_DOCUMENTS);
+    if (!documentsPath) {
+        DuskLog.fatal("Unable to get iOS Documents path: {}", SDL_GetError());
+    }
+
+    std::filesystem::path configPath = reinterpret_cast<const char8_t*>(documentsPath);
+
+    char* oldPrefPath = SDL_GetPrefPath(dusk::OrgName, dusk::AppName);
+    if (oldPrefPath) {
+        const std::filesystem::path oldConfigPath = reinterpret_cast<const char8_t*>(oldPrefPath);
+        SDL_free(oldPrefPath);
+
+        std::error_code ec;
+        if (oldConfigPath != configPath && std::filesystem::exists(oldConfigPath, ec)) {
+            migrate_directory(oldConfigPath, configPath);
+        }
+    }
+
+    return configPath;
+#endif
+#endif
+
    const auto result = SDL_GetPrefPath(dusk::OrgName, dusk::AppName);
    if (!result) {
        DuskLog.fatal("Unable to get PrefPath: {}", SDL_GetError());
    }

-    return result;
+    return reinterpret_cast<const char8_t*>(result);
 }

 static void EnsureInitialPipelineCache(const std::filesystem::path& configDir) {
@@ -411,16 +511,21 @@ static void EnsureInitialPipelineCache(const std::filesystem::path& configDir) {
        return;
    }

-    const char* basePath = SDL_GetBasePath();
-    if (basePath == nullptr) {
-        DuskLog.warn("Unable to resolve base path while seeding pipeline cache: {}", SDL_GetError());
-        return;
-    }
+    std::string sourcePathString;
+    SDL_IOStream* source = nullptr;

-    const std::filesystem::path initialPipelineCachePath =
-        std::filesystem::path(basePath) / "initial_pipeline_cache.db";
-    if (!std::filesystem::exists(initialPipelineCachePath)) {
-        DuskLog.info("No bundled initial pipeline cache found at '{}'", initialPipelineCachePath.string());
+    const char* basePath = SDL_GetBasePath();
+    if (basePath != nullptr) {
+        sourcePathString = dusk::io::fs_path_to_string(
+            std::filesystem::path(basePath) / "initial_pipeline_cache.db");
+        source = SDL_IOFromFile(sourcePathString.c_str(), "rb");
+    }
+    if (source == nullptr) {
+        sourcePathString = "initial_pipeline_cache.db";
+        source = SDL_IOFromFile(sourcePathString.c_str(), "rb");
+    }
+    if (source == nullptr) {
+        DuskLog.info("No bundled initial pipeline cache found");
        return;
    }

@@ -428,18 +533,68 @@ static void EnsureInitialPipelineCache(const std::filesystem::path& configDir) {
    std::filesystem::create_directories(configDir, ec);
    if (ec) {
        DuskLog.warn("Failed to create config directory '{}' for pipeline cache: {}",
-                     configDir.string(), ec.message());
+            dusk::io::fs_path_to_string(configDir), ec.message());
+        SDL_CloseIO(source);
        return;
    }

-    std::filesystem::copy_file(initialPipelineCachePath, pipelineCachePath, std::filesystem::copy_options::none, ec);
-    if (ec) {
-        DuskLog.warn("Failed to seed pipeline cache from '{}' to '{}': {}",
-                     initialPipelineCachePath.string(), pipelineCachePath.string(), ec.message());
+    const auto pipelineCacheString = dusk::io::fs_path_to_string(pipelineCachePath);
+    SDL_IOStream* destination = SDL_IOFromFile(pipelineCacheString.c_str(), "wb");
+    if (destination == nullptr) {
+        DuskLog.warn("Failed to open '{}' for seeded pipeline cache: {}", pipelineCacheString,
+            SDL_GetError());
+        SDL_CloseIO(source);
        return;
    }

-    DuskLog.info("Seeded pipeline cache from '{}'", initialPipelineCachePath.string());
+    bool copied = true;
+    std::array<char, 64 * 1024> buffer{};
+    while (true) {
+        const size_t bytesRead = SDL_ReadIO(source, buffer.data(), buffer.size());
+        if (bytesRead > 0) {
+            size_t bytesWritten = 0;
+            while (bytesWritten < bytesRead) {
+                const size_t written = SDL_WriteIO(
+                    destination, buffer.data() + bytesWritten, bytesRead - bytesWritten);
+                if (written == 0) {
+                    DuskLog.warn("Failed to write seeded pipeline cache '{}': {}",
+                        pipelineCacheString, SDL_GetError());
+                    copied = false;
+                    break;
+                }
+                bytesWritten += written;
+            }
+        }
+
+        if (!copied) {
+            break;
+        }
+
+        if (bytesRead < buffer.size()) {
+            if (SDL_GetIOStatus(source) == SDL_IO_STATUS_EOF) {
+                break;
+            }
+
+            DuskLog.warn(
+                "Failed to read bundled pipeline cache '{}': {}", sourcePathString, SDL_GetError());
+            copied = false;
+            break;
+        }
+    }
+
+    if (!SDL_CloseIO(destination)) {
+        DuskLog.warn("Failed to close seeded pipeline cache '{}': {}",
+            dusk::io::fs_path_to_string(pipelineCachePath), SDL_GetError());
+        copied = false;
+    }
+    SDL_CloseIO(source);
+
+    if (!copied) {
+        std::filesystem::remove(pipelineCachePath, ec);
+        return;
+    }
+
+    DuskLog.info("Seeded pipeline cache from '{}'", sourcePathString);
 }

 static constexpr PADDefaultMapping defaultPadMapping = {
@@ -536,22 +691,22 @@ int game_main(int argc, char* argv[]) {
        exit(1);
    }

-    dusk::ConfigPath = CalculateConfigPath();
+    dusk::ConfigPath = calculate_config_path();
    const auto startupLogLevel = static_cast<AuroraLogLevel>(parsed_arg_options["log-level"].as<uint8_t>());
    dusk::InitializeFileLogging(dusk::ConfigPath, startupLogLevel);

    dusk::config::LoadFromUserPreferences();
    ApplyCVarOverrides(parsed_arg_options["cvar"]);
-    dusk::InitializeCrashReporting();
+    dusk::crash_reporting::initialize();
    EnsureInitialPipelineCache(dusk::ConfigPath);
    // TODO: How to handle this?
    //PADSetDefaultMapping(&defaultPadMapping, PAD_TYPE_STANDARD);

    {
-        const auto configPathString = dusk::ConfigPath.string();
+        const auto configPathString = dusk::ConfigPath.u8string();
        AuroraConfig config{};
        config.appName = dusk::AppName;
-        config.configPath = configPathString.c_str();
+        config.configPath = reinterpret_cast<const char*>(configPathString.c_str());
        config.vsync = dusk::getSettings().video.enableVsync;
        config.startFullscreen = dusk::getSettings().video.enableFullscreen;
        config.windowPosX = -1;
@@ -593,7 +748,7 @@ int game_main(int argc, char* argv[]) {
    // Run ImGui UI loop if Aurora couldn't initialize a backend
    if (auroraInfo.backend == BACKEND_NULL) {
        launchUILoop();
-        dusk::ShutdownCrashReporting();
+        dusk::crash_reporting::shutdown();
        dusk::ShutdownFileLogging();
        fflush(stdout);
        fflush(stderr);
@@ -649,6 +804,10 @@ int game_main(int argc, char* argv[]) {
        }
    }

+    dusk::iso::log_verification_state(
+        dusk::getSettings().backend.isoPath.getValue(),
+        dusk::getSettings().backend.isoVerification.getValue());
+
    if (!dvd_opened) {
        if (dusk::getSettings().backend.isoPath.getValue().empty()) {
            forcePreLaunchUI = true;
@@ -667,7 +826,7 @@ int game_main(int argc, char* argv[]) {

            // pre game launch ui main loop
            if (!launchUILoop()) {
-                dusk::ShutdownCrashReporting();
+                dusk::crash_reporting::shutdown();
                dusk::ShutdownFileLogging();
                fflush(stdout);
                fflush(stderr);
@@ -698,6 +857,12 @@ int game_main(int argc, char* argv[]) {
        dusk::IsGameLaunched = true;
    }

+#if DUSK_ENABLE_SENTRY_NATIVE
+    if (dusk::crash_reporting::get_consent() == dusk::crash_reporting::Consent::Unknown) {
+        dusk::ui::push_document(std::make_unique<dusk::ui::CrashReportWindow>());
+    }
+#endif
+
    if (!dusk::getSettings().backend.wasPresetChosen) {
        dusk::ui::push_document(std::make_unique<dusk::ui::PresetWindow>());
    }
@@ -729,7 +894,7 @@ int game_main(int argc, char* argv[]) {

    dusk::MoviePlayerShutdown();

-    dusk::ShutdownCrashReporting();
+    dusk::crash_reporting::shutdown();
    dusk::ShutdownFileLogging();
    fflush(stdout);
    fflush(stderr);
Author	SHA1	Message	Date
SuperDude88	1b4a842eec	Invert First Person Aiming (#870 ) - Inverts first person aiming on either axis, for both stick and gyro controls Could be separated from gyro if desirable, but I think it makes the most sense to have it apply to both	2026-05-10 19:00:20 -06:00
gymnast86	08c7261262	fix going into first person with orbital cam (#923 )	2026-05-10 19:00:09 -06:00
Luke Street	07b440a1c9	Update aurora	2026-05-10 18:42:31 -06:00
SuperDude88	e7ab978a30	Crash Reporting Popup (#879 ) * Initial Draft - Add draft crash report window on startup If you want to disable them before/during startup, there is a command line option to force it * Fixes - Update language to be more precise, consistent with settings menu - Actually shut down reporting properly if you disable it - Fix my silly syntax errors * Update text & use Sentry consent --------- Co-authored-by: Luke Street <luke@street.dev>	2026-05-10 18:37:22 -06:00
qwertyquerty	3a02e129e7	Fix keyboard not binding maybe (idk i cant repro) (#901 ) * fixkb * restore comment	2026-05-10 17:35:29 -06:00
qwertyquerty	93c6106770	cherry pick actor spawner (#920 )	2026-05-10 17:30:39 -06:00
Luke Street	b08d994e32	Update aurora	2026-05-10 17:27:30 -06:00
Luke Street	0665a78c84	Update CMakePresets.json	2026-05-10 13:35:58 -06:00
Luke Street	4db8b51f24	Disable Sentry on Android	2026-05-10 13:22:26 -06:00
Luke Street	800da8dbff	Update aurora	2026-05-10 12:48:49 -06:00
Luke Street	a0ecdb1735	Re-enable Sentry for release builds	2026-05-10 12:10:32 -06:00
Luke Street	c948bffd32	Update aurora	2026-05-10 10:55:30 -06:00
Luke Street	4bcf4ca354	Improve build-appimage.sh	2026-05-10 10:54:43 -06:00
Krutonium	bfd9917ca1	Fix Flake to Build Successfully (#791 ) * Fix Flake to Build Successfully * Fix typo; Res Folder is now correctly placed	2026-05-10 10:53:07 -06:00
Pieter-Jan Briers	7f6212f9b7	Add some basic code conventions to the README (#831 )	2026-05-10 10:52:47 -06:00
Irastris	80245387f3	Update README & fallback ImGui error message (#857 )	2026-05-10 10:52:34 -06:00
Markos Theocharis	0a1fea4bc7	Add `LSSupportsGameMode` to enable game mode (#859 )	2026-05-10 10:51:45 -06:00
project516	4ec7b01213	update github actions in ci (#852 )	2026-05-10 10:39:55 -06:00
Luke Street	5187fe90c3	Seed initial pipeline cache through SDL IO & UTF8 path fixes	2026-05-10 10:39:11 -06:00
Pieter-Jan Briers	a86fa9c162	State share Unicode fix (#834 )	2026-05-10 10:35:11 -06:00
MelonSpeedruns	4ec8c1aaee	Fix recording mode muting music until next reboot (#832 ) Co-authored-by: MelonSpeedruns <melonspeedruns@stratobox.net>	2026-05-10 17:32:55 +02:00
Luke Street	97d032f8b5	Add Android CI	2026-05-10 00:51:34 -06:00
Luke Street	286532904a	Update aurora	2026-05-10 00:31:49 -06:00
Luke Street	04b5861f29	Update CI (again x2)	2026-05-10 00:12:11 -06:00
Luke Street	453e958068	Update CI (again)	2026-05-10 00:11:05 -06:00
Luke Street	e7d2fbcc0b	Update CI	2026-05-10 00:08:42 -06:00
Krutonium	8f71c70d14	fix io.hpp to enable compiling on GCC15 (#790 )	2026-05-09 23:41:15 -06:00
Luke Street	df23edcb69	Add iOS UIFileSharingEnabled integration	2026-05-09 21:42:43 -06:00
Luke Street	daff157027	Fix change notifications in Android DocumentsProvider	2026-05-09 21:42:32 -06:00
Luke Street	0c23bd4332	Add "Open Data Folder" to Interface menu	2026-05-09 20:57:34 -06:00
Luke Street	7562486449	Log disc verification status	2026-05-09 20:40:59 -06:00
Luke Street	5e08b810fc	Update aurora	2026-05-09 20:26:37 -06:00
Pieter-Jan Briers	c66cccf660	Fix handling of Unicode paths on Windows (#767 ) I love C++	2026-05-09 20:24:50 -06:00
Luke Street	3b1118229b	Add Android DocumentsProvider	2026-05-09 20:23:11 -06:00
TakaRikka	491da372a1	Merge pull request #764 from TwilitRealm/gyro-axis-fix Fix Gyro Sensitivity Axes	2026-05-09 17:47:59 -07:00
SuperDude88	a2f463d146	Fix Gyro Sensitivity Axes Fixes #759	2026-05-09 20:15:33 -04:00
TakaRikka	63b3ce4849	temp fix for speedrun timer controls	2026-05-09 15:16:54 -07:00